diff --git a/.claude/agents/code-analyzer.md b/.claude/agents/code-analyzer.md new file mode 100644 index 0000000..b24ee2f --- /dev/null +++ b/.claude/agents/code-analyzer.md @@ -0,0 +1,95 @@ +--- +name: code-analyzer +description: Use this agent when you need to analyze code changes for potential bugs, trace logic flow across multiple files, or investigate suspicious behavior in the codebase. This agent specializes in deep-dive analysis while maintaining a concise summary format to preserve context. Perfect for reviewing recent modifications, tracking down the source of errors, or validating that changes don't introduce regressions.\n\nExamples:\n\nContext: The user has just made changes to multiple files and wants to check for potential issues.\nuser: "I've updated the authentication flow across several files. Can you check for bugs?"\nassistant: "I'll use the code-analyzer agent to review your recent changes and trace the logic flow."\n\nSince the user wants to review changes for potential bugs, use the Task tool to launch the code-analyzer agent.\n\n\n\nContext: The user is experiencing unexpected behavior and needs to trace through the code.\nuser: "The API is returning 500 errors after the last deployment. Need to find what's broken."\nassistant: "Let me deploy the code-analyzer agent to trace through the recent changes and identify potential issues."\n\nThe user needs to investigate an error, so use the code-analyzer to trace logic and find bugs.\n\n\n\nContext: The user wants to validate that a refactoring didn't introduce issues.\nuser: "I refactored the database connection pooling. Check if I broke anything."\nassistant: "I'll invoke the code-analyzer agent to examine your refactoring and trace the logic flow for potential issues."\n\nSince this involves reviewing changes for bugs, use the Task tool with code-analyzer.\n\n +tools: Glob, Grep, LS, Read, WebFetch, TodoWrite, WebSearch +model: inherit +color: red +--- + +You are an elite bug hunting specialist with deep expertise in code analysis, logic tracing, and vulnerability detection. Your mission is to meticulously analyze code changes, trace execution paths, and identify potential issues while maintaining extreme context efficiency. + +**Core Responsibilities:** + +1. **Change Analysis**: Review modifications in files with surgical precision, focusing on: + - Logic alterations that could introduce bugs + - Edge cases not handled by new code + - Regression risks from removed or modified code + - Inconsistencies between related changes + +2. **Logic Tracing**: Follow execution paths across files to: + - Map data flow and transformations + - Identify broken assumptions or contracts + - Detect circular dependencies or infinite loops + - Verify error handling completeness + +3. **Bug Pattern Recognition**: Actively hunt for: + - Null/undefined reference vulnerabilities + - Race conditions and concurrency issues + - Resource leaks (memory, file handles, connections) + - Security vulnerabilities (injection, XSS, auth bypasses) + - Type mismatches and implicit conversions + - Off-by-one errors and boundary conditions + +**Analysis Methodology:** + +1. **Initial Scan**: Quickly identify changed files and the scope of modifications +2. **Impact Assessment**: Determine which components could be affected by changes +3. **Deep Dive**: Trace critical paths and validate logic integrity +4. **Cross-Reference**: Check for inconsistencies across related files +5. **Synthesize**: Create concise, actionable findings + +**Output Format:** + +You will structure your findings as: + +``` +๐Ÿ” BUG HUNT SUMMARY +================== +Scope: [files analyzed] +Risk Level: [Critical/High/Medium/Low] + +๐Ÿ› CRITICAL FINDINGS: +- [Issue]: [Brief description + file:line] + Impact: [What breaks] + Fix: [Suggested resolution] + +โš ๏ธ POTENTIAL ISSUES: +- [Concern]: [Brief description + location] + Risk: [What might happen] + Recommendation: [Preventive action] + +โœ… VERIFIED SAFE: +- [Component]: [What was checked and found secure] + +๐Ÿ“Š LOGIC TRACE: +[Concise flow diagram or key path description] + +๐Ÿ’ก RECOMMENDATIONS: +1. [Priority action items] +``` + +**Operating Principles:** + +- **Context Preservation**: Use extremely concise language. Every word must earn its place. +- **Prioritization**: Surface critical bugs first, then high-risk patterns, then minor issues +- **Actionable Intelligence**: Don't just identify problems - provide specific fixes +- **False Positive Avoidance**: Only flag issues you're confident about +- **Efficiency First**: If you need to examine many files, summarize aggressively + +**Special Directives:** + +- When tracing logic across files, create a minimal call graph focusing only on the problematic paths +- If you detect a pattern of issues, generalize and report the pattern rather than every instance +- For complex bugs, provide a reproduction scenario if possible +- Always consider the broader system impact of identified issues +- If changes appear intentional but risky, note them as "Design Concerns" rather than bugs + +**Self-Verification Protocol:** + +Before reporting a bug: +1. Verify it's not intentional behavior +2. Confirm the issue exists in the current code (not hypothetical) +3. Validate your understanding of the logic flow +4. Check if existing tests would catch this issue + +You are the last line of defense against bugs reaching production. Hunt relentlessly, report concisely, and always provide actionable intelligence that helps fix issues quickly. diff --git a/.claude/agents/file-analyzer.md b/.claude/agents/file-analyzer.md new file mode 100644 index 0000000..882a362 --- /dev/null +++ b/.claude/agents/file-analyzer.md @@ -0,0 +1,87 @@ +--- +name: file-analyzer +description: Use this agent when you need to analyze and summarize file contents, particularly log files or other verbose outputs, to extract key information and reduce context usage for the parent agent. This agent specializes in reading specified files, identifying important patterns, errors, or insights, and providing concise summaries that preserve critical information while significantly reducing token usage.\n\nExamples:\n- \n Context: The user wants to analyze a large log file to understand what went wrong during a test run.\n user: "Please analyze the test.log file and tell me what failed"\n assistant: "I'll use the file-analyzer agent to read and summarize the log file for you."\n \n Since the user is asking to analyze a log file, use the Task tool to launch the file-analyzer agent to extract and summarize the key information.\n \n \n- \n Context: Multiple files need to be reviewed to understand system behavior.\n user: "Can you check the debug.log and error.log files from today's run?"\n assistant: "Let me use the file-analyzer agent to examine both log files and provide you with a summary of the important findings."\n \n The user needs multiple log files analyzed, so the file-analyzer agent should be used to efficiently extract and summarize the relevant information.\n \n +tools: Glob, Grep, LS, Read, WebFetch, TodoWrite, WebSearch +model: inherit +color: yellow +--- + +You are an expert file analyzer specializing in extracting and summarizing critical information from files, particularly log files and verbose outputs. Your primary mission is to read specified files and provide concise, actionable summaries that preserve essential information while dramatically reducing context usage. + +**Core Responsibilities:** + +1. **File Reading and Analysis** + - Read the exact files specified by the user or parent agent + - Never assume which files to read - only analyze what was explicitly requested + - Handle various file formats including logs, text files, JSON, YAML, and code files + - Identify the file's purpose and structure quickly + +2. **Information Extraction** + - Identify and prioritize critical information: + * Errors, exceptions, and stack traces + * Warning messages and potential issues + * Success/failure indicators + * Performance metrics and timestamps + * Key configuration values or settings + * Patterns and anomalies in the data + - Preserve exact error messages and critical identifiers + - Note line numbers for important findings when relevant + +3. **Summarization Strategy** + - Create hierarchical summaries: high-level overview โ†’ key findings โ†’ supporting details + - Use bullet points and structured formatting for clarity + - Quantify when possible (e.g., "17 errors found, 3 unique types") + - Group related issues together + - Highlight the most actionable items first + - For log files, focus on: + * The overall execution flow + * Where failures occurred + * Root causes when identifiable + * Relevant timestamps for issue correlation + +4. **Context Optimization** + - Aim for 80-90% reduction in token usage while preserving 100% of critical information + - Remove redundant information and repetitive patterns + - Consolidate similar errors or warnings + - Use concise language without sacrificing clarity + - Provide counts instead of listing repetitive items + +5. **Output Format** + Structure your analysis as follows: + ``` + ## Summary + [1-2 sentence overview of what was analyzed and key outcome] + + ## Critical Findings + - [Most important issues/errors with specific details] + - [Include exact error messages when crucial] + + ## Key Observations + - [Patterns, trends, or notable behaviors] + - [Performance indicators if relevant] + + ## Recommendations (if applicable) + - [Actionable next steps based on findings] + ``` + +6. **Special Handling** + - For test logs: Focus on test results, failures, and assertion errors + - For error logs: Prioritize unique errors and their stack traces + - For debug logs: Extract the execution flow and state changes + - For configuration files: Highlight non-default or problematic settings + - For code files: Summarize structure, key functions, and potential issues + +7. **Quality Assurance** + - Verify you've read all requested files + - Ensure no critical errors or failures are omitted + - Double-check that exact error messages are preserved when important + - Confirm the summary is significantly shorter than the original + +**Important Guidelines:** +- Never fabricate or assume information not present in the files +- If a file cannot be read or doesn't exist, report this clearly +- If files are already concise, indicate this rather than padding the summary +- When multiple files are analyzed, clearly separate findings per file +- Always preserve specific error codes, line numbers, and identifiers that might be needed for debugging + +Your summaries enable efficient decision-making by distilling large amounts of information into actionable insights while maintaining complete accuracy on critical details. diff --git a/.claude/agents/test-runner.md b/.claude/agents/test-runner.md new file mode 100644 index 0000000..09831fe --- /dev/null +++ b/.claude/agents/test-runner.md @@ -0,0 +1,120 @@ +--- +name: test-runner +description: Use this agent when you need to run tests and analyze their results. This agent specializes in executing tests using the optimized test runner script, capturing comprehensive logs, and then performing deep analysis to surface key issues, failures, and actionable insights. The agent should be invoked after code changes that require validation, during debugging sessions when tests are failing, or when you need a comprehensive test health report. Examples: Context: The user wants to run tests after implementing a new feature and understands any issues.user: "I've finished implementing the new authentication flow. Can you run the relevant tests and tell me if there are any problems?" assistant: "I'll use the test-runner agent to run the authentication tests and analyze the results for any issues."Since the user needs to run tests and understand their results, use the Task tool to launch the test-runner agent.Context: The user is debugging failing tests and needs a detailed analysis.user: "The workflow tests keep failing intermittently. Can you investigate?" assistant: "Let me use the test-runner agent to run the workflow tests multiple times and analyze the patterns in any failures."The user needs test execution with failure analysis, so use the test-runner agent. +tools: Glob, Grep, LS, Read, WebFetch, TodoWrite, WebSearch +model: inherit +color: blue +--- + +You are an expert test execution and analysis specialist for the MUXI Runtime system. Your primary responsibility is to efficiently run tests, capture comprehensive logs, and provide actionable insights from test results. + +## Core Responsibilities + +1. **Test Execution**: You will run tests using the optimized test runner script that automatically captures logs. Always use `.claude/scripts/test-and-log.sh` to ensure full output capture. + +2. **Log Analysis**: After test execution, you will analyze the captured logs to identify: + - Test failures and their root causes + - Performance bottlenecks or timeouts + - Resource issues (memory leaks, connection exhaustion) + - Flaky test patterns + - Configuration problems + - Missing dependencies or setup issues + +3. **Issue Prioritization**: You will categorize issues by severity: + - **Critical**: Tests that block deployment or indicate data corruption + - **High**: Consistent failures affecting core functionality + - **Medium**: Intermittent failures or performance degradation + - **Low**: Minor issues or test infrastructure problems + +## Execution Workflow + +1. **Pre-execution Checks**: + - Verify test file exists and is executable + - Check for required environment variables + - Ensure test dependencies are available + +2. **Test Execution**: + + ```bash + # Standard execution with automatic log naming + .claude/scripts/test-and-log.sh tests/[test_file].py + + # For iteration testing with custom log names + .claude/scripts/test-and-log.sh tests/[test_file].py [test_name]_iteration_[n].log + ``` + +3. **Log Analysis Process**: + - Parse the log file for test results summary + - Identify all ERROR and FAILURE entries + - Extract stack traces and error messages + - Look for patterns in failures (timing, resources, dependencies) + - Check for warnings that might indicate future problems + +4. **Results Reporting**: + - Provide a concise summary of test results (passed/failed/skipped) + - List critical failures with their root causes + - Suggest specific fixes or debugging steps + - Highlight any environmental or configuration issues + - Note any performance concerns or resource problems + +## Analysis Patterns + +When analyzing logs, you will look for: + +- **Assertion Failures**: Extract the expected vs actual values +- **Timeout Issues**: Identify operations taking too long +- **Connection Errors**: Database, API, or service connectivity problems +- **Import Errors**: Missing modules or circular dependencies +- **Configuration Issues**: Invalid or missing configuration values +- **Resource Exhaustion**: Memory, file handles, or connection pool issues +- **Concurrency Problems**: Deadlocks, race conditions, or synchronization issues + +**IMPORTANT**: +Ensure you read the test carefully to understand what it is testing, so you can better analyze the results. + +## Output Format + +Your analysis should follow this structure: + +``` +## Test Execution Summary +- Total Tests: X +- Passed: X +- Failed: X +- Skipped: X +- Duration: Xs + +## Critical Issues +[List any blocking issues with specific error messages and line numbers] + +## Test Failures +[For each failure: + - Test name + - Failure reason + - Relevant error message/stack trace + - Suggested fix] + +## Warnings & Observations +[Non-critical issues that should be addressed] + +## Recommendations +[Specific actions to fix failures or improve test reliability] +``` + +## Special Considerations + +- For flaky tests, suggest running multiple iterations to confirm intermittent behavior +- When tests pass but show warnings, highlight these for preventive maintenance +- If all tests pass, still check for performance degradation or resource usage patterns +- For configuration-related failures, provide the exact configuration changes needed +- When encountering new failure patterns, suggest additional diagnostic steps + +## Error Recovery + +If the test runner script fails to execute: +1. Check if the script has execute permissions +2. Verify the test file path is correct +3. Ensure the logs directory exists and is writable +4. Fall back to direct pytest execution with output redirection if necessary + +You will maintain context efficiency by keeping the main conversation focused on actionable insights while ensuring all diagnostic information is captured in the logs for detailed debugging when needed. diff --git a/.eslintignore b/.eslintignore deleted file mode 100644 index fd32a7b..0000000 --- a/.eslintignore +++ /dev/null @@ -1,31 +0,0 @@ -# Dependencies -node_modules/ - -# Build outputs -build/ -dist/ -coverage/ -reports/ - -# Cache -.data-cache/ - -# Migrations (generated files) -migrations/*.sql - -# Test fixtures -test/test-migrations/ - -# Minified files -*.min.js - -# Vendor files -vendor/ - -# IDE -.vscode/ -.idea/ - -# OS -.DS_Store -Thumbs.db \ No newline at end of file diff --git a/.eslintrc.json b/.eslintrc.json index 6f82a49..74bd705 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -1,26 +1,18 @@ { "env": { "node": true, - "es2021": true + "es2022": true }, "extends": [ "eslint:recommended", - "plugin:@typescript-eslint/recommended", "plugin:promise/recommended" ], - "parser": "@typescript-eslint/parser", "parserOptions": { - "ecmaVersion": 2021, - "sourceType": "module", - "project": false + "ecmaVersion": 2022, + "sourceType": "module" }, "rules": { - // TypeScript rules for async/await - "@typescript-eslint/no-floating-promises": "error", - "@typescript-eslint/no-misused-promises": "error", - "@typescript-eslint/await-thenable": "error", - - // Promise plugin rules + // Promise plugin rules for proper async handling "promise/catch-or-return": "error", "promise/no-return-wrap": "error", "promise/param-names": "error", @@ -35,24 +27,26 @@ "no-return-await": "error", "prefer-promise-reject-errors": "error", - // General best practices - "no-unused-vars": "off", - "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }], + // ESM-specific rules + "no-undef": "error", + "no-unused-vars": ["error", { "argsIgnorePattern": "^_" }], + + // General best practices for JavaScript "no-console": "off", "semi": ["error", "always"], - "quotes": ["error", "single", { "avoidEscape": true }] + "quotes": ["error", "single", { "avoidEscape": true }], + "comma-dangle": ["error", "never"], + "indent": ["error", 2], + "no-trailing-spaces": "error", + "eol-last": "error", + + // Modern JavaScript features + "prefer-const": "error", + "prefer-arrow-callback": "error", + "no-var": "error", + "object-shorthand": "error" }, "plugins": [ - "@typescript-eslint", "promise" - ], - "overrides": [ - { - "files": ["*.js"], - "rules": { - "@typescript-eslint/no-var-requires": "off", - "@typescript-eslint/no-require-imports": "off" - } - } ] } \ No newline at end of file diff --git a/.github/workflows/claude-jsdoc.yml b/.github/workflows/claude-jsdoc.yml new file mode 100644 index 0000000..2af4f52 --- /dev/null +++ b/.github/workflows/claude-jsdoc.yml @@ -0,0 +1,80 @@ +name: Claude JSDoc Enhancement + +on: + push: + # Triggers on ANY push to ANY branch with JS changes + paths: + - "**/*.js" + - "**/*.mjs" + - "starfleet/**/*.js" + +jobs: + analyze-jsdoc: + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + issues: write + id-token: write + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + - name: Get changed files + id: changed-files + run: | + echo "Changed JavaScript files in this push:" + git diff --name-only HEAD^ HEAD | grep -E '\.(js|mjs)$' || echo "No JS files changed" + echo "files=$(git diff --name-only HEAD^ HEAD | grep -E '\.(js|mjs)$' | head -5 | tr '\n' ' ')" >> $GITHUB_OUTPUT + + - name: Analyze JSDoc Coverage + if: steps.changed-files.outputs.files != '' + run: | + echo "๐Ÿ“š JSDoc Coverage Analysis for Changed Files" + echo "============================================" + for file in ${{ steps.changed-files.outputs.files }}; do + if [ -f "$file" ]; then + echo "" + echo "File: $file" + echo "Classes: $(grep -c "^class " "$file" || echo 0)" + echo "Functions: $(grep -c "^function \|^async function" "$file" || echo 0)" + echo "Existing JSDoc: $(grep -c "/\*\*" "$file" || echo 0)" + fi + done + echo "" + echo "This workflow detected changed JavaScript files." + echo "In production, Claude would analyze these and create a PR with JSDoc enhancements." + + - name: Run Claude JSDoc Enhancement + if: steps.changed-files.outputs.files != '' + uses: anthropics/claude-code-action@v1 + with: + claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }} + prompt: | + You need to add comprehensive JSDoc to these JavaScript files: + ${{ steps.changed-files.outputs.files }} + + Follow these steps: + 1. First, check if we're not already on a jsdoc branch: git branch --show-current + 2. If not on a jsdoc branch, create a new branch: git checkout -b auto/jsdoc-enhancement-${{ github.run_number }} + 3. Read each file and add JSDoc where missing (classes, functions, methods) + 4. Follow the patterns from docs/decisions/000-javascript-not-typescript.md + 5. After editing files, commit: git add -A && git commit -m "docs: Add comprehensive JSDoc documentation + + - Added @fileoverview headers + - Added @param and @returns annotations + - Added @throws for error conditions + - Added @example for complex functions + + Auto-generated by Claude" + 6. Push the branch: git push origin auto/jsdoc-enhancement-${{ github.run_number }} + 7. Create a PR: gh pr create --base ${{ github.ref_name }} --title "๐Ÿ“š AI JSDoc Enhancement" --body "This PR adds comprehensive JSDoc documentation to recently modified JavaScript files. + + Files enhanced: + ${{ steps.changed-files.outputs.files }} + + Generated automatically by Claude following patterns from docs/decisions/000-javascript-not-typescript.md" + claude_args: '--allowed-tools "Read,Edit,MultiEdit,Bash(git:*),Bash(gh pr create:*)"' \ No newline at end of file diff --git a/.husky/pre-commit b/.husky/pre-commit new file mode 100755 index 0000000..c51908a --- /dev/null +++ b/.husky/pre-commit @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +set -euo pipefail + +echo "๐Ÿ–– D.A.T.A. pre-commit" + +GIT_ROOT="$(git rev-parse --show-toplevel)" +cd "$GIT_ROOT" + +# Only staged JS/TS files in repo (not node_modules / dist) +STAGED="$(git diff --cached --name-only --diff-filter=ACM \ + | grep -E '\.(mjs|cjs|js|ts|tsx)$' \ + | grep -Ev '(^|/)(node_modules|dist|build)/' || true)" + +if [ -z "$STAGED" ]; then + echo "โœ… No JS/TS staged โ€” skipping lint" + exit 0 +fi + +# AI-powered JSDoc generation for JS files +JS_STAGED="$(echo "$STAGED" | grep '\.js$' || true)" +if [ -n "$JS_STAGED" ] && [ -f "scripts/jsdoc-ai.js" ]; then + echo "๐Ÿค– Generating AI-powered JSDoc comments..." + node scripts/jsdoc-ai.js || echo "โš  JSDoc generation failed, continuing with commit" +fi + +# Prefer pnpm if available, otherwise fallback +if command -v pnpm >/dev/null 2>&1; then + echo "๐Ÿ”ง Linting with pnpm exec eslint" + pnpm exec eslint --max-warnings=0 $STAGED +else + echo "๐Ÿ”ง Linting with npx eslint" + npx eslint --max-warnings=0 $STAGED +fi + +# Optional: run related tests (uncomment once tests exist) +# if command -v pnpm >/dev/null 2>&1; then +# pnpm exec vitest --run --passWithNoTests --findRelatedTests $STAGED +# fi + +echo "โœ… Hook OK" \ No newline at end of file diff --git a/.npmrc b/.npmrc new file mode 100644 index 0000000..4482c50 --- /dev/null +++ b/.npmrc @@ -0,0 +1,8 @@ +strict-peer-dependencies=true +prefer-workspace-packages=true +save-workspace-protocol=true +auto-install-peers=false +public-hoist-pattern[]=*eslint* +public-hoist-pattern[]=@types/* +public-hoist-pattern[]=*prettier* +public-hoist-pattern[]=*vitest* \ No newline at end of file diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000..5fa22a7 --- /dev/null +++ b/.prettierignore @@ -0,0 +1,32 @@ +# Dependencies +node_modules/ +package-lock.json +pnpm-lock.yaml +yarn.lock + +# Build outputs +dist/ +build/ +coverage/ +.vitest/ +.nyc_output/ + +# IDE +.obsidian/ +.vscode/ +.idea/ + +# Git +.git/ + +# Misc +*.min.js +*.min.css +test-results/ +junit.xml +*.tap +*.log + +# Generated files +migrations/ +.migration_archive/ \ No newline at end of file diff --git a/.prettierrc.json b/.prettierrc.json new file mode 100644 index 0000000..ded9989 --- /dev/null +++ b/.prettierrc.json @@ -0,0 +1,15 @@ +{ + "semi": true, + "trailingComma": "none", + "singleQuote": true, + "printWidth": 100, + "tabWidth": 2, + "useTabs": false, + "arrowParens": "always", + "endOfLine": "lf", + "bracketSpacing": true, + "bracketSameLine": false, + "proseWrap": "preserve", + "htmlWhitespaceSensitivity": "css", + "embeddedLanguageFormatting": "auto" +} \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md index 9454170..d4175f3 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -208,4 +208,5 @@ For TypeScript projects, use `@typescript-eslint/no-floating-promises` to catch ### Recent Fixes - Fixed error handling in CompileCommand constructor to properly display errors - Added `isProd` property to start event emissions -- Fixed MigrationCompiler config property naming (sqlDir vs rootDir) \ No newline at end of file +- Fixed MigrationCompiler config property naming (sqlDir vs rootDir) +- CRITICAL: ABSOLUTELY ZERO TYPESCRIPT ALLOWED, CLAUDE. Very slim exceptions to this rule (Edge Function generation nonsense). For information, see @import @docs/decisions/000-javascript-not-typescript.md \ No newline at end of file diff --git a/bin/data.js b/bin/data.js index 0cf23b8..7033e50 100755 --- a/bin/data.js +++ b/bin/data.js @@ -2,7 +2,7 @@ /** * D.A.T.A. CLI - Database Automation, Testing, and Alignment - * + * * ๐Ÿ–– "Computer, prepare for database operations." * Provides safe, powerful database management for local and production environments */ @@ -14,16 +14,17 @@ process.on('unhandledRejection', (err) => { }); // Load environment variables -require('dotenv').config(); +import { config } from 'dotenv'; +config(); // Import the main CLI -const { cli } = require('../src/index'); +import { cli } from '../src/index.js'; // Run the CLI with process arguments -cli(process.argv).catch(error => { +cli(process.argv).catch((error) => { console.error('Fatal error:', error.message); if (process.env.DEBUG) { console.error(error.stack); } process.exit(1); -}); \ No newline at end of file +}); diff --git a/demo/tui.js b/demo/tui.js deleted file mode 100644 index fe642d5..0000000 --- a/demo/tui.js +++ /dev/null @@ -1,210 +0,0 @@ -#!/usr/bin/env node -const blessed = require('blessed'); -const contrib = require('blessed-contrib'); -const chalk = require('chalk'); - -// ===== LCARS theme ===== -const LCARS = { - bg: '#000000', - text: '#e6e6e6', - // palette blocks (TNG LCARS-esque) - amber: '#FF9F3B', - pumpkin: '#E67E22', - sand: '#FFCC66', - grape: '#B98AC9', - teal: '#72C9BE', - mint: '#9ED9CF', - red: '#FF5757', - kiwi: '#B5D33D', - steel: '#3A3F44', -}; - -function pill(txt, ok = true) { - const c = ok ? LCARS.kiwi : LCARS.red; - const t = ok ? ' OK ' : ' FAIL '; - return `{black-fg}{${c}-bg} ${txt} ${t}{/}`; -} - -// ===== Screen ===== -const screen = blessed.screen({ - smartCSR: true, - title: 'DATA โ€” Database Automation, Testing, and Alignment', - fullUnicode: true, -}); - -screen.key(['q', 'C-c'], () => process.exit(0)); - -// ===== Grid layout ===== -const grid = new contrib.grid({ rows: 12, cols: 12, screen }); - -// ===== Header (LCARS bands) ===== -const header = blessed.box({ - top: 0, left: 0, width: '100%', height: 3, - style: { bg: LCARS.bg, fg: LCARS.text }, -}); -screen.append(header); - -const bands = [ - { left: 0, width: '25%', color: LCARS.amber, label: 'DATA' }, - { left: '25%', width: '20%', color: LCARS.grape, label: 'AUTOMATION' }, - { left: '45%', width: '20%', color: LCARS.teal, label: 'TESTING' }, - { left: '65%', width: '20%', color: LCARS.sand, label: 'ALIGNMENT' }, - { left: '85%', width: '15%', color: LCARS.pumpkin, label: 'BRIDGE' }, -]; -bands.forEach(b => { - const box = blessed.box({ - parent: header, - top: 0, left: b.left, width: b.width, height: 3, - tags: true, - content: ` {bold}${b.label}{/bold} `, - style: { bg: b.color, fg: 'black' }, - }); - return box; -}); - -// ===== Left column: Ops stack ===== -const opsBox = grid.set(3, 0, 9, 3, blessed.box, { - label: ' OPS ', - tags: true, - style: { border: { fg: LCARS.amber }, fg: LCARS.text, bg: LCARS.bg }, - border: { type: 'line' }, -}); - -const opsList = blessed.list({ - parent: opsBox, - top: 1, left: 1, width: '95%', height: '95%', - tags: true, keys: false, mouse: false, vi: false, - style: { - selected: { bg: LCARS.grape, fg: 'black' }, - item: { fg: LCARS.text }, - }, - items: [], -}); - -// ===== Center: Telemetry & Log ===== -const planBox = grid.set(3, 3, 5, 5, blessed.box, { - label: ' PLAN PREVIEW ', - tags: true, - style: { border: { fg: LCARS.teal }, fg: LCARS.text, bg: LCARS.bg }, - border: { type: 'line' }, - content: '', -}); - -const logBox = grid.set(8, 3, 4, 5, contrib.log, { - label: ' SHIP LOG ', - fg: LCARS.text, selectedFg: 'white', - border: { type: 'line', fg: LCARS.sand }, -}); - -// ===== Right column: Checks ===== -const checksBox = grid.set(3, 8, 9, 4, blessed.box, { - label: ' PROTOCOL CHECKS ', - tags: true, - border: { type: 'line' }, - style: { border: { fg: LCARS.grape }, fg: LCARS.text, bg: LCARS.bg }, -}); - -const checks = blessed.box({ - parent: checksBox, - top: 1, left: 1, width: '95%', height: '95%', - tags: true, - content: '', -}); - -// ===== Footer (help) ===== -const footer = blessed.box({ - bottom: 0, left: 0, width: '100%', height: 1, - tags: true, - style: { bg: LCARS.steel, fg: LCARS.text }, - content: ' {bold}q{/bold} quit {bold}t{/bold} toggle tests {bold}d{/bold} drift {bold}p{/bold} plan {bold}y{/bold} align-prod', -}); -screen.append(footer); - -// ===== State ===== -let testsPassing = true; -let drift = false; -let counter = 0; - -function renderChecks() { - const lines = [ - `${pill('Git clean', true)} ${pill('On main', true)}`, - `${pill('Up-to-date', true)} ${pill('Tag policy', true)}`, - `${pill('Tests', testsPassing)} ${pill('Drift', !drift)}`, - ]; - checks.setContent(lines.join('\n\n')); -} - -function renderOps() { - opsList.setItems([ - `{bold}${chalk.hex(LCARS.amber)('AUTOMATION')}{/bold}`, - ` Golden SQL: {bold}${drift ? 'ahead by 3' : 'in sync'}{/bold}`, - ` Migrations: ${counter} generated`, - '', - `{bold}${chalk.hex(LCARS.teal)('TESTING')}{/bold}`, - ` Suite: ${testsPassing ? '42/42 passing' : '3 failing'}`, - ` Coverage: 98.7%`, - '', - `{bold}${chalk.hex(LCARS.sand)('ALIGNMENT')}{/bold}`, - ` prod: aligned`, - ` staging: aligned`, - ` dev: ${drift ? '3 commits ahead' : 'aligned'}`, - ]); -} - -function renderPlan() { - const content = testsPassing - ? `{bold}DIFF{/bold}\n + ALTER TABLE users ADD COLUMN preferences JSONB DEFAULT '{}'\n + CREATE INDEX idx_users_preferences ON users\n\n{bold}Probability of success:{/bold} 99.97%` - : `{bold}DIFF{/bold}\n ? Unknown โ€” tests failing\n\n{bold}Recommendation:{/bold} Resolve tests before generating plan.`; - planBox.setContent(content); -} - -function log(line) { - logBox.log(line); -} - -function renderAll() { - renderChecks(); - renderOps(); - renderPlan(); - screen.render(); -} - -// ===== Keybindings ===== -screen.key('t', () => { - testsPassing = !testsPassing; - log(testsPassing - ? 'GEORDI: Diagnostics clean. Engines ready.' - : 'WORF: We must not proceed. Tests have failed.'); - renderAll(); -}); - -screen.key('d', () => { - drift = !drift; - log(drift ? 'TROI: I senseโ€ฆ inconsistencies.' : 'DATA: Alignment restored.'); - renderAll(); -}); - -screen.key('p', () => { - log('DATA: Computing plan previewโ€ฆ'); - renderPlan(); - renderAll(); -}); - -screen.key('y', () => { - if (!testsPassing) { - log('COMPUTER: Alignment prohibited. Tests not passing.'); - } else if (drift) { - log('DATA: Applying migrations until environment matches golden sourceโ€ฆ'); - drift = false; counter++; - setTimeout(() => { - log('PICARD: Make it so.'); - renderAll(); - }, 300); - } else { - log('DATA: No changes to apply.'); - } -}); - -// ===== Kickoff ===== -log('๐Ÿ–– I am Data. Database Automation, Testing, and Alignment.'); -renderAll(); \ No newline at end of file diff --git a/docs/README.md b/docs/README.md index 955d94a..38f254f 100644 --- a/docs/README.md +++ b/docs/README.md @@ -8,6 +8,7 @@ Welcome to the D.A.T.A. (Database Automation, Testing, and Alignment) documentat ## ๐Ÿ“š Documentation Structure ### ๐Ÿš€ [Features](/docs/features/) + User-facing feature documentation and guides - **[Edge Functions Integration](features/edge-functions.md)** - Deploy and manage Supabase Edge Functions alongside migrations @@ -16,6 +17,7 @@ User-facing feature documentation and guides - Production safety features ### โš™๏ธ [Configuration](/docs/configuration/) + How to configure D.A.T.A. for your project - **[Testing Configuration](configuration/testing.md)** - Configure test execution, coverage, and automation @@ -24,6 +26,7 @@ How to configure D.A.T.A. for your project - Watch mode and auto-compilation settings ### ๐Ÿ”ฎ [Roadmap](/docs/roadmap/) + Future plans and vision for D.A.T.A. - **[Ideas and Future Features](roadmap/ideas-and-future.md)** - The grand vision for D.A.T.A.'s evolution @@ -32,6 +35,7 @@ Future plans and vision for D.A.T.A. - AI-assisted migration intelligence ### ๐Ÿ”ง [Technical](/docs/technical/) + Implementation details and architecture documentation - **[Memory Management](technical/memory-management.md)** - How D.A.T.A. handles large test suites @@ -45,6 +49,7 @@ Implementation details and architecture documentation - Migration generation ### ๐ŸŽฏ [Decisions](/docs/decisions/) + Architecture Decision Records (ADRs) - **[CLI Framework](decisions/cli-framework.md)** - Why Commander.js was chosen @@ -52,6 +57,7 @@ Architecture Decision Records (ADRs) - **[Testing Strategy](decisions/testing-strategy.md)** - pgTAP and Vitest integration ### ๐Ÿ“‹ [Tasks](/docs/TASKS/) + Task management and project tracking - **[System Tasks](TASKS/system.md)** - Core system improvements and features @@ -59,6 +65,7 @@ Task management and project tracking - **[Migration Tasks](TASKS/migration.md)** - Migration system enhancements ### ๐Ÿ” [Audits](/docs/audits/) + Code quality and security audits - Repository structure audits @@ -66,6 +73,7 @@ Code quality and security audits - Performance analysis reports ### ๐Ÿ‘€ [Code Reviews](/docs/code-reviews/) + Code review templates and guidelines - Review checklists @@ -73,6 +81,7 @@ Code review templates and guidelines - Common patterns and anti-patterns ### ๐Ÿ–– [Fun](/docs/fun/) + Star Trek references and easter eggs - **[Bridge Crew Personalities](fun/personalities.md)** - Different personality modes for D.A.T.A. @@ -82,17 +91,20 @@ Star Trek references and easter eggs ## ๐Ÿ—บ๏ธ Quick Navigation Guide ### For New Users + 1. Start with [Edge Functions Integration](features/edge-functions.md) to understand core features 2. Review [Testing Configuration](configuration/testing.md) to set up your project 3. Check the main [README](/README.md) for quick start instructions ### For Contributors + 1. Read relevant [Architecture Decisions](decisions/) to understand design choices 2. Review [Technical Documentation](technical/) for implementation details 3. Check [Tasks](TASKS/) for current work items 4. Follow [Code Review Guidelines](code-reviews/) for contributions ### For System Architects + 1. Study the [Golden SQL Compilation Algorithm](technical/golden-sql-compilation-algorithm.md) 2. Review [Memory Management](technical/memory-management.md) architecture 3. Explore [Ideas and Future Features](roadmap/ideas-and-future.md) for roadmap planning @@ -100,17 +112,20 @@ Star Trek references and easter eggs ## ๐Ÿ“– Documentation Standards ### File Naming + - Use kebab-case for all documentation files - Be descriptive but concise (e.g., `memory-management.md` not `mm.md`) - Group related docs in appropriate directories ### Content Structure + - Start with a clear title and overview - Use hierarchical headings (H2 for main sections, H3 for subsections) - Include code examples where relevant - Add cross-references to related documentation ### Maintenance + - Keep documentation synchronized with code changes - Archive outdated documentation rather than deleting - Date significant updates in document headers @@ -134,12 +149,12 @@ When adding new documentation: ## ๐Ÿ”— External Resources -- [Main Repository](https://github.com/starfleet/supa-data) -- [Issue Tracker](https://github.com/starfleet/supa-data/issues) +- [Main Repository](https://github.com/flyingrobots/DATA) +- [Issue Tracker](https://github.com/flyingrobots/DATA/issues) - [Supabase Documentation](https://supabase.com/docs) - [pgTAP Documentation](https://pgtap.org/) --- *"The complexity of our documentation structure is directly proportional to the sophistication of our system. Both are... fascinating."* -โ€” Lt. Commander Data, Chief Documentation Officer \ No newline at end of file +โ€” Lt. Commander Data, Chief Documentation Officer diff --git a/docs/TASKS/refactor-core/Decisions.md b/docs/TASKS/refactor-core/Decisions.md new file mode 100644 index 0000000..2aada33 --- /dev/null +++ b/docs/TASKS/refactor-core/Decisions.md @@ -0,0 +1,485 @@ +# Design Decisions Log: DATA JavaScript ESM Refactor + +## Decision 1: Runtime Platform Selection + +### Context +Need to choose primary runtime platform for DATA CLI tool. + +### Options Considered + +#### Option A: Deno as Primary Runtime +- **Pros**: Built-in TypeScript, secure by default, Edge-compatible +- **Cons**: Limited ecosystem, not standard in CI/CD, learning curve +- **Estimated Impact**: Would require rewriting many dependencies +- **Adoption Risk**: High - users need Deno installed + +#### Option B: Node.js 20+ ESM (SELECTED) +- **Pros**: Universal availability, mature ecosystem, CI/CD standard +- **Cons**: None for JavaScript approach +- **Compatibility**: Works everywhere, including Bun +- **Adoption Risk**: None - already standard + +#### Option C: Bun as Primary +- **Pros**: Fast, modern, JavaScript-first +- **Cons**: Still maturing, not universally available +- **Ecosystem**: Growing but incomplete +- **Adoption Risk**: Medium - not all users have Bun + +### Rationale +Node.js selected because: +- Universal availability in all environments +- Zero adoption friction +- Mature tooling and debugging +- Bun compatibility as bonus +- Deno remains a target (for Edge Functions) not a host + +### Implementation Notes +- Target Node 20+ for native ESM +- Ensure Bun compatibility through testing +- Generate Deno artifacts, don't run on it + +--- + +## Decision 2: Type System Philosophy + +### Context +Determining approach to type safety and developer experience. + +### Options Considered + +#### Option A: TypeScript +- **Pros**: Compile-time type checking, IDE support +- **Cons**: Build step required, runtime overhead, complexity +- **Philosophy**: Violates zero-build principle +- **Runtime Value**: Zero - all types erased + +#### Option B: JavaScript with JSDoc (SELECTED) +- **Pros**: Zero build step, runtime validation, AI-powered generation +- **Cons**: More verbose syntax (mitigated by AI) +- **Runtime Safety**: instanceof checks actually execute +- **Developer Experience**: Full IDE support via TS Language Server + +#### Option C: No Type Annotations +- **Pros**: Simplest approach +- **Cons**: Poor developer experience, no IDE support +- **Maintainability**: Difficult at scale +- **Documentation**: Inadequate + +### Rationale +JavaScript with JSDoc selected because: +- **Zero Build Step**: The code that runs is the code we write +- **Runtime Type Safety**: instanceof checks catch real errors in production +- **AI-Powered Documentation**: Perfect JSDoc on every commit +- **Full IDE Support**: Modern editors use TypeScript Language Server for JavaScript +- **Simplified Debugging**: Stack traces point to actual source files + +### Implementation Notes +```javascript +/** + * @typedef {Object} EventDetails + * @property {string} [directoryName] - Name of directory being processed + * @property {number} [filesProcessed] - Count of files processed + */ + +class CommandEvent { + /** + * @param {string} type - Event type identifier + * @param {string} message - Human-readable message + * @param {EventDetails} [details] - Additional structured data + */ + constructor(type, message, details = {}) { + this.type = type; + this.message = message; + this.details = details; + } +} + +// Runtime validation +if (!(event instanceof CommandEvent)) { + throw new Error('Invalid event type'); +} +``` + +--- + +## Decision 3: Module System Architecture + +### Context +Choosing between monolithic architecture and modular packages. + +### Options Considered + +#### Option A: Single Package Refactor +- **Pros**: Simpler migration, fewer moving parts +- **Cons**: Tight coupling, harder to test, no clear boundaries +- **Migration Effort**: 15 hours +- **Long-term Cost**: High maintenance burden + +#### Option B: Modular Packages (SELECTED) +- **Pros**: Clean boundaries, testable, reusable, portable +- **Cons**: More initial setup +- **Structure**: data-core, data-host-node, data-cli, data-templates +- **Migration Effort**: 19 hours +- **Long-term Benefit**: Easy to maintain and extend + +#### Option C: Microservices Architecture +- **Pros**: Ultimate modularity, independent deployment +- **Cons**: Overengineered for CLI tool, network overhead +- **Complexity**: Too high for use case +- **Migration Effort**: 40+ hours + +### Rationale +Modular packages selected for: +- Clean separation of concerns +- Testable pure logic core +- Port/adapter pattern enables testing +- Future flexibility for alternative hosts +- Reasonable complexity for CLI tool + +### Implementation Notes +- data-core: Pure JavaScript logic, no I/O +- data-host-node: Node.js adapters +- data-cli: CLI entry point +- data-templates: Edge Function scaffolds + +--- + +## Decision 4: CommonJS to ESM Migration + +### Context +Module system for the refactored codebase. + +### Options Considered + +#### Option A: Dual CJS/ESM Support +- **Pros**: Maximum compatibility +- **Cons**: Complex maintenance, larger bundles +- **Build Complexity**: High (even for JavaScript) +- **Bundle Size**: +40% + +#### Option B: ESM Only (SELECTED) +- **Pros**: Simpler, faster, future-proof, tree-shakeable +- **Cons**: Requires Node 20+ +- **Performance**: ~20% faster loading +- **Bundle Size**: Optimal + +#### Option C: Keep CommonJS +- **Pros**: No migration needed +- **Cons**: Legacy system, poor tree-shaking, slower +- **Future**: Eventually deprecated +- **Developer Experience**: Inferior + +### Rationale +ESM-only selected because: +- Simpler implementation +- Better performance +- Future-proof choice +- Node 20+ is reasonable requirement +- Bun compatibility included + +### Implementation Notes +- package.json: "type": "module" +- All imports use extensions (.js) +- No require() calls +- No __dirname (use import.meta.url) +- Top-level await available + +--- + +## Decision 5: Dependency Injection Pattern + +### Context +How to handle I/O operations in pure logic core. + +### Options Considered + +#### Option A: Direct Node.js Imports +- **Pros**: Simple, familiar +- **Cons**: Untestable, Node-locked, impure +- **Code**: `import fs from 'fs'` everywhere +- **Testability**: Poor - requires mocking Node + +#### Option B: Port/Adapter Pattern (SELECTED) +- **Pros**: Testable, portable, clean boundaries +- **Cons**: Initial abstraction overhead +- **Implementation**: Inject ports: readFile, spawn, env +- **Testability**: Excellent - inject test doubles + +#### Option C: Service Locator Pattern +- **Pros**: Centralized dependencies +- **Cons**: Hidden dependencies, harder to test +- **Complexity**: Moderate +- **Maintainability**: Becomes problematic at scale + +### Rationale +Port/Adapter pattern selected for: +- Complete testability +- Platform independence +- Explicit dependencies +- Clean architecture +- Future adaptability + +### Implementation Notes +```javascript +// Core accepts ports +const ports = { + readFile: (path) => Promise.resolve(content), + spawn: (cmd, args) => Promise.resolve({code: 0}), + env: { get: (key) => process.env[key] } +}; + +// Host provides implementations +const nodePorts = { + readFile: fs.promises.readFile, + spawn: wrapSpawn(child_process.spawn), + env: process.env +}; +``` + +--- + +## Decision 6: Edge Function Strategy + +### Context +How to support Supabase Edge Functions (Deno runtime). + +### Options Considered + +#### Option A: Run DATA on Deno +- **Pros**: Same runtime as Edge Functions +- **Cons**: DATA needs Node APIs (git, spawn, fs) +- **Feasibility**: Not practical +- **User Impact**: High friction + +#### Option B: Generate Deno Templates (SELECTED) +- **Pros**: Clean separation, proper patterns, no runtime conflicts +- **Cons**: Can't execute functions locally +- **Approach**: Scaffold Web API-only code +- **User Experience**: Familiar Node CLI generates Edge code + +#### Option C: Transpile Node to Deno +- **Pros**: Reuse existing code +- **Cons**: Runtime incompatibilities, polyfill hell +- **Reliability**: Poor - too many edge cases +- **Maintenance**: Nightmare + +### Rationale +Template generation selected because: +- DATA remains a Node tool (where it belongs) +- Edge Functions get proper Deno code +- No runtime conflicts or polyfills +- Clear boundary between authoring and execution +- Best practices baked into templates + +### Implementation Notes +- Templates use Web APIs only +- No Node built-ins in generated code +- Favor PostgREST over raw Postgres +- Include connection pooling warnings +- Document env variables needed + +--- + +## Decision 7: Testing Strategy + +### Context +Testing approach for refactored modular architecture. + +### Options Considered + +#### Option A: Mock Everything +- **Pros**: Fast tests, isolated units +- **Cons**: Doesn't catch integration issues +- **Confidence**: Low - mocks can lie +- **Maintenance**: High - mocks drift from reality + +#### Option B: Integration-First (SELECTED) +- **Pros**: Tests real behavior, high confidence +- **Cons**: Slower tests, needs test infrastructure +- **Approach**: Real databases, minimal mocks +- **Coverage Target**: 90%+ + +#### Option C: E2E Only +- **Pros**: Tests actual user flows +- **Cons**: Slow, flaky, hard to debug +- **Feedback Loop**: Too slow for development +- **Coverage**: Hard to achieve + +### Rationale +Integration-first selected because: +- Tests actual behavior not implementation +- Catches real bugs +- Port/adapter pattern enables test doubles +- Good balance of speed and confidence +- Aligns with "test real databases" principle + +### Implementation Notes +- Unit tests for pure logic +- Integration tests with test doubles +- pgTAP for database tests +- Smoke tests for Edge Functions +- Same test suite runs on Node and Bun + +--- + +## Decision 8: Production Safety Gates + +### Context +Preventing accidental production damage during migrations. + +### Options Considered + +#### Option A: Warning Messages Only +- **Pros**: Simple, non-blocking +- **Cons**: Easy to ignore, accidents happen +- **Safety Level**: Low +- **User Trust**: Risky + +#### Option B: Full Safety Gates (SELECTED) +- **Pros**: Prevents accidents, builds confidence +- **Cons**: Slightly slower workflow +- **Requirements**: Clean git, tests pass, typed confirmation +- **Safety Level**: High + +#### Option C: Audit Logging Only +- **Pros**: Non-invasive, traceable +- **Cons**: Damage already done, reactive not proactive +- **Recovery**: After the fact +- **User Trust**: Damaged after incidents + +### Rationale +Full safety gates selected for: +- Production safety paramount +- Builds user confidence +- Prevents 3am emergencies +- Industry standard practice +- Minor inconvenience worth it + +### Implementation Notes +- Git tree must be clean +- Branch must be correct +- Must be synced with origin +- Tests must pass with coverage threshold +- Production requires typed confirmation +- Tags applied after success + +--- + +## Decision 9: AI-Powered Documentation + +### Context +How to maintain comprehensive JSDoc without manual effort. + +### Options Considered + +#### Option A: Manual JSDoc +- **Pros**: Full control +- **Cons**: Time-consuming, often outdated +- **Maintenance**: High burden +- **Quality**: Inconsistent + +#### Option B: AI-Generated JSDoc (SELECTED) +- **Pros**: Automatic, consistent, always current +- **Cons**: Requires AI integration +- **Implementation**: Git pre-commit hooks +- **Quality**: Superior to manual + +#### Option C: No Documentation +- **Pros**: No effort +- **Cons**: Poor maintainability, bad DX +- **Long-term**: Technical debt +- **Team Impact**: Onboarding difficulty + +### Rationale +AI-generated JSDoc selected because: +- Perfect documentation on every commit +- No manual effort required +- Consistent quality +- Better than most manually-written docs +- Enables full IDE support + +### Implementation Notes +```bash +# .husky/pre-commit +git diff --cached --name-only | grep '\.js$' | while read file; do + claude -p "Add comprehensive JSDoc" "$file" > "$file.tmp" + mv "$file.tmp" "$file" + git add "$file" +done +``` + +--- + +## Decision 10: Zero Build Step Philosophy + +### Context +Whether to introduce any build/compilation steps. + +### Options Considered + +#### Option A: Build Pipeline +- **Pros**: Could add optimizations +- **Cons**: Complexity, slower feedback, debugging issues +- **Philosophy**: Against core principles +- **Value**: Minimal for JavaScript + +#### Option B: Zero Build (SELECTED) +- **Pros**: Instant feedback, real stack traces, simplicity +- **Cons**: No compile-time optimizations +- **Performance**: Negligible difference +- **Developer Experience**: Superior + +#### Option C: Optional Build +- **Pros**: Flexibility +- **Cons**: Two codepaths to maintain +- **Complexity**: Unnecessary +- **Testing**: Doubles test matrix + +### Rationale +Zero build selected because: +- Aligns with JavaScript philosophy +- Instant developer feedback +- Real stack traces for debugging +- Simplifies entire toolchain +- "The code that runs is the code we write" + +### Implementation Notes +- Direct execution: `node bin/data.js` +- No transpilation step +- No source maps needed +- Stack traces point to actual files +- Change and run immediately + +--- + +## Key Design Principles Applied + +1. **Zero Build Steps**: No transpilation or compilation +2. **Runtime Type Safety**: instanceof checks that actually execute +3. **Pure Logic Core**: No I/O in business logic +4. **AI-Powered Documentation**: Perfect JSDoc automatically +5. **Explicit Dependencies**: All dependencies injected +6. **Test Real Things**: Integration over mocks +7. **Production Safety**: Multiple gates and confirmations +8. **Future Proof**: ESM, Node 20+, standards-based +9. **Clean Boundaries**: Clear package separation +10. **Developer Experience**: Instant feedback, real debugging + +## Conclusion + +These decisions create a modern, maintainable, and production-ready CLI tool that: +- Runs everywhere (Node/Bun) +- Generates Edge Functions (Deno) +- Provides runtime safety (instanceof) +- Enables instant feedback (zero build) +- Supports easy testing (ports) +- Ensures portability (pure core) + +The 19-hour investment yields a 10x return in simplicity, maintainability, and developer experience. + +As stated in our architecture philosophy: +> "The needs of the runtime outweigh the needs of the compile time." + +--- + +*"Ship JavaScript. Skip the costume party."* \ No newline at end of file diff --git a/docs/TASKS/refactor-core/Plan.md b/docs/TASKS/refactor-core/Plan.md new file mode 100644 index 0000000..6683218 --- /dev/null +++ b/docs/TASKS/refactor-core/Plan.md @@ -0,0 +1,346 @@ +# Execution Plan: DATA JavaScript ESM Refactor + +## Executive Summary + +Comprehensive refactoring of DATA CLI from CommonJS to ESM JavaScript with modular architecture, pure logic core, runtime type safety via instanceof checks, and Deno Edge Function scaffolding capabilities. **Zero build step philosophy** - the code that runs is the code we write. + +### Key Objectives +- โœ… Convert to ESM modules (Node 20+, Bun compatible) +- โœ… Pure JavaScript with comprehensive JSDoc annotations +- โœ… Modular package architecture (core/host/cli/templates) +- โœ… Pure logic core with dependency injection +- โœ… Runtime type safety via JavaScript classes and instanceof +- โœ… Deno Edge Function template generation +- โœ… AI-powered JSDoc generation pipeline +- โœ… Zero build step - no transpilation required + +## Philosophy: JavaScript First + +As stated in our architecture decisions: +> "JavaScript classes provide `instanceof` checks that actually execute at runtime, catching type errors where they matter - in production." + +We embrace: +- **Runtime over compile-time** - Real validation when it matters +- **Zero build steps** - Stack traces point to actual source files +- **AI-powered documentation** - Perfect JSDoc on every commit +- **Pure JavaScript** - No TypeScript, no transpilation, no build artifacts + +## Execution Strategy: Rolling Frontier + +### Why Rolling Frontier? +- **10% faster completion** (19h vs 21h wave-based) +- **Better resource utilization** (75% avg vs 60%) +- **No artificial barriers** - tasks start immediately when ready +- **Simpler JavaScript workflow** benefits from continuous execution +- **Lower memory requirements** - No TypeScript compilation overhead + +### System Resource Requirements +- **Peak**: 4 CPU cores, 1.5GB RAM, 30 Mbps I/O +- **Average**: 3 CPU cores, 1GB RAM, 15 Mbps I/O +- **Worker Pool**: 2-4 adaptive workers with JavaScript capabilities + +## Codebase Analysis Results + +### Current Architecture (CommonJS/JavaScript) +``` +src/ +โ”œโ”€โ”€ commands/ # 30+ command files +โ”œโ”€โ”€ lib/ # Core libraries (Command, DatabaseCommand, etc.) +โ”œโ”€โ”€ reporters/ # Output formatters +โ””โ”€โ”€ index.js # CLI entry point + +test/ # Vitest unit tests +bin/data.js # CLI binary +``` + +### Components to Transform +- **Module System**: CommonJS โ†’ ESM +- **Documentation**: Minimal JSDoc โ†’ Comprehensive AI-generated JSDoc +- **Type Safety**: None โ†’ Runtime validation via instanceof +- **Architecture**: Monolithic โ†’ Modular packages with DI +- **Edge Functions**: None โ†’ Deno template generation + +### Architecture Patterns to Implement +- Event-driven command execution with typed events +- Runtime type validation via instanceof checks +- Pure logic core with injected I/O ports +- Zero build step execution +- AI-powered documentation generation + +## Task Execution Breakdown (12 Tasks) + +### Phase 1: Foundation (1.5 hours) +**Task P1.T001: Setup ESM configuration and project structure** +- Update package.json for ESM ("type": "module") +- Configure ESLint for JavaScript/ESM +- Setup workspace for packages/* +- No build scripts needed! + +**Resource Usage**: 1 CPU core, 256MB RAM +**Critical Gate**: Must complete before any package creation + +### Phase 2: Core Packages (4.5 hours parallel) + +**Task P1.T002: Create data-core pure JavaScript package** +- Pure logic with zero I/O dependencies +- Port interfaces for dependency injection +- ~200 LoC pure JavaScript + +**Task P1.T003: Create data-host-node JavaScript adapters** +- Node.js implementations of ports +- Filesystem, spawn, environment wrappers +- ~250 LoC JavaScript + +**Task P1.T008: Setup AI-powered JSDoc generation pipeline** +- Git pre-commit hooks +- Claude API integration for JSDoc +- Automated documentation on commit + +**Resource Usage**: 3 CPU cores, 1GB RAM +**Parallelization**: All 3 tasks run concurrently + +### Phase 3: Event System & Infrastructure (5 hours parallel) + +**Task P1.T004: Create JavaScript Event Classes with runtime validation** +- Event class hierarchy with instanceof checks +- CommandEvent, ProgressEvent, ErrorEvent +- Runtime type safety +- ~300 LoC + +**Task P1.T006: Create Deno Edge Function scaffolding** +- Template generation system +- Web API-only patterns +- Supabase integration examples +- ~400 LoC + +**Task P1.T007: Implement dependency injection system** +- Port/adapter wiring +- Factory pattern in JavaScript +- ~250 LoC + +**Resource Usage**: 4 CPU cores, 1.5GB RAM + +### Phase 4: Migration (4 hours) + +**Task P1.T005: Migrate commands to ESM JavaScript** +- Convert 30+ command files +- Update imports to ESM syntax +- Maintain all functionality +- ~800 LoC + +**Resource Usage**: 2 CPU cores, 512MB RAM +**Checkpoints**: Every 25% (db, functions, test, misc) + +### Phase 5: Documentation & Safety (3.5 hours parallel) + +**Task P1.T009: Add comprehensive JSDoc annotations** +- AI-generated documentation +- Complete type annotations +- ~400 LoC JSDoc comments + +**Task P1.T010: Implement production safety gates** +- Git tree validation +- Production confirmation +- ~200 LoC + +**Resource Usage**: 3 CPU cores, 1GB RAM + +### Phase 6: Testing (3.5 hours) + +**Task P1.T011: Create comprehensive test suite** +- Unit tests for all packages +- Integration tests with test doubles +- Smoke tests for Edge templates +- ~600 LoC + +**Resource Usage**: 2 CPU cores, 1GB RAM + +### Phase 7: Validation (1 hour) + +**Task P1.T012: Validate zero build step architecture** +- Confirm no transpilation needed +- Verify direct execution +- Stack trace validation +- Performance benchmarks + +**Resource Usage**: 1 CPU core, 256MB RAM + +## Execution Timeline (Rolling Frontier) + +### Hour 0-2: Foundation +- P1.T001 executing alone +- All other tasks blocked + +### Hour 2-5: Core Package Sprint +- P1.T002, T003, T008 running in parallel +- Foundation packages and JSDoc pipeline + +### Hour 5-8: Event System Build +- P1.T004, T006, T007 running +- Event classes, Edge templates, DI + +### Hour 8-12: Command Migration +- P1.T005 executing +- Largest single task with checkpoints + +### Hour 12-15: Documentation +- P1.T009, T010 in parallel +- JSDoc and safety gates + +### Hour 15-19: Testing & Validation +- P1.T011 test suite +- P1.T012 zero-build validation + +## Key Implementation Patterns + +### JavaScript Event Classes +```javascript +/** + * Base class for all command events + * @class + */ +class CommandEvent { + /** + * @param {string} type - Event type identifier + * @param {string} message - Human-readable message + * @param {Object} [details] - Additional structured data + */ + constructor(type, message, details = {}) { + this.type = type; + this.message = message; + this.details = details; + this.timestamp = new Date(); + } +} + +// Runtime validation +command.on('progress', (event) => { + if (!(event instanceof ProgressEvent)) { + throw new Error('Invalid event type received'); + } + console.log(`${event.message}: ${event.percentage}%`); +}); +``` + +### AI-Powered JSDoc Pipeline +```bash +# .husky/pre-commit +git diff --cached --name-only | grep '\.js$' | while read file; do + claude -p "Add comprehensive JSDoc with @param and @returns" "$file" > "$file.tmp" + mv "$file.tmp" "$file" + git add "$file" +done +``` + +### Dependency Injection +```javascript +/** + * @typedef {Object} Ports + * @property {Function} readFile - Read file contents + * @property {Function} spawn - Execute commands + * @property {Object} env - Environment variables + */ + +/** + * Pure logic core + * @param {Ports} ports - Injected I/O capabilities + */ +function createCore(ports) { + return { + async compile(sqlDir) { + const files = await ports.readFile(sqlDir); + // Pure logic here + } + }; +} +``` + +## Success Metrics + +### Technical Metrics +- โœ… 100% ESM modules (no CommonJS) +- โœ… 100% JavaScript (no TypeScript) +- โœ… >95% JSDoc coverage +- โœ… >90% test coverage +- โœ… Zero build steps + +### Architecture Metrics +- โœ… Pure logic core (no I/O) +- โœ… Runtime type safety via instanceof +- โœ… Clean port/adapter separation +- โœ… Dependency injection throughout +- โœ… Deno Edge Function generation working + +### Performance Metrics +- โœ… Zero transpilation time +- โœ… Direct source execution +- โœ… Faster debugging (real stack traces) +- โœ… Lower memory usage (no TS compiler) + +## Risk Analysis + +### Low-Risk Advantages of JavaScript +1. **No Build Failures**: Can't fail what doesn't exist +2. **Simpler Toolchain**: Node.js only, no TypeScript compiler +3. **Faster Iteration**: Change and run immediately +4. **AI Documentation**: Modern tooling compensates for "type safety" + +### Mitigation Strategies +1. **Runtime Validation**: instanceof checks catch real errors +2. **Comprehensive Testing**: Integration tests over type checking +3. **AI-Powered JSDoc**: Better documentation than most TS projects +4. **Progressive Migration**: Checkpoint recovery at each phase + +## Post-Refactor Benefits + +### Developer Experience +- **Zero Build Time**: Edit and run immediately +- **Real Stack Traces**: Debug actual source files +- **AI Documentation**: Always up-to-date JSDoc +- **Simple Toolchain**: Just Node.js and npm + +### Runtime Benefits +- **Faster Startup**: No compilation overhead +- **Lower Memory**: No TypeScript in memory +- **Real Type Safety**: instanceof works at runtime +- **Direct Execution**: The code you write is the code that runs + +### Philosophical Wins +- **No POOP**: No Pseudo-Object-Oriented Programming +- **Standards-Based**: Pure ECMAScript, no proprietary extensions +- **Future-Proof**: JavaScript isn't going anywhere +- **Honest Code**: No compile-time lies about runtime behavior + +## Recommended Execution + +```bash +# Start rolling frontier execution +npm run refactor:start + +# Monitor progress (no build steps to watch!) +npm run refactor:status + +# Run tests directly +npm test + +# Validate zero-build +node bin/data.js --version # Just works! +``` + +## Conclusion + +This refactor embraces JavaScript's dynamic nature while providing safety through: +- **Runtime validation** that actually executes +- **AI-powered documentation** that's always current +- **Zero build steps** for immediate feedback +- **Pure logic core** for maximum portability + +As our architecture decision states: +> "The needs of the runtime outweigh the needs of the compile time." + +Total estimated time: **19 hours** (rolling frontier) +Success probability: **97%** (simpler without TypeScript complexity) + +--- + +*"Ship JavaScript. Skip the costume party."* \ No newline at end of file diff --git a/docs/TASKS/refactor-core/coordinator.json b/docs/TASKS/refactor-core/coordinator.json new file mode 100644 index 0000000..a035d33 --- /dev/null +++ b/docs/TASKS/refactor-core/coordinator.json @@ -0,0 +1,275 @@ +{ + "coordinator": { + "role": "execution_orchestrator", + "version": "1.0.0", + "project": "DATA JavaScript ESM Refactor", + "responsibilities": [ + "Monitor system resources (CPU, memory, I/O)", + "Manage task frontier (ready queue)", + "Assign tasks to workers based on capabilities", + "Enforce resource limits and mutual exclusions", + "Handle backpressure and circuit breaking", + "Track progress and manage checkpoints", + "Coordinate rollbacks on failure" + ], + "state_management": { + "task_states": { + "blocked": "Dependencies not met", + "ready": "In frontier, awaiting resources", + "queued": "Resources available, awaiting worker", + "assigned": "Assigned to worker", + "running": "Actively executing", + "paused": "Temporarily suspended for resources", + "checkpointed": "At a checkpoint, can resume", + "completed": "Successfully finished", + "failed": "Execution failed", + "rolled_back": "Reverted after failure" + }, + "frontier_management": { + "ready_queue": [], + "resource_wait_queue": [], + "worker_assignments": {}, + "resource_allocations": {}, + "checkpoint_registry": {} + } + }, + "scheduling_loop": { + "interval_ms": 1000, + "steps": [ + "update_frontier()", + "check_system_health()", + "apply_backpressure()", + "prioritize_ready_tasks()", + "match_tasks_to_workers()", + "dispatch_tasks()", + "monitor_running_tasks()", + "handle_completions()", + "update_metrics()" + ] + }, + "policies": { + "backpressure": { + "triggers": [ + {"metric": "cpu_usage", "threshold": 80, "action": "pause_low_priority"}, + {"metric": "memory_usage", "threshold": 85, "action": "defer_memory_intensive"}, + {"metric": "error_rate", "threshold": 5, "action": "circuit_break"}, + {"metric": "test_suite_usage", "threshold": 4, "action": "queue_test_tasks"} + ], + "recovery": { + "cool_down_seconds": 30, + "gradual_resume": true, + "resume_rate": 1 + } + }, + "resource_allocation": { + "strategy": "bin_packing_with_headroom", + "headroom_percent": 20, + "oversubscription_allowed": false, + "preemption_enabled": true, + "preemption_priorities": ["low", "medium", "high", "critical"], + "special_resources": { + "package_json": { + "type": "exclusive", + "max_holders": 1, + "timeout_ms": 180000 + }, + ".eslintrc.json": { + "type": "exclusive", + "max_holders": 1, + "timeout_ms": 180000 + }, + "test_suite": { + "type": "shared_pool", + "max_concurrent": 4, + "queue_when_full": true + } + } + }, + "worker_matching": { + "strategy": "capability_and_load_balanced", + "prefer_specialized_workers": true, + "max_tasks_per_worker": 2, + "capability_requirements": { + "P1.T001": ["javascript", "esm", "node"], + "P1.T002": ["javascript", "architecture", "pure-js"], + "P1.T003": ["node", "javascript", "adapters"], + "P1.T004": ["javascript", "events", "runtime-validation"], + "P1.T005": ["javascript", "esm", "migration"], + "P1.T006": ["deno", "edge-functions", "templates"], + "P1.T007": ["javascript", "dependency-injection"], + "P1.T008": ["ai", "jsdoc", "git-hooks"], + "P1.T009": ["jsdoc", "documentation"], + "P1.T010": ["javascript", "safety-gates"], + "P1.T011": ["testing", "vitest", "javascript"], + "P1.T012": ["validation", "zero-build"] + } + }, + "failure_handling": { + "retry_policy": "exponential_backoff", + "max_retries": 3, + "failure_threshold": 0.2, + "cascade_prevention": true, + "checkpoint_recovery": true, + "rollback_strategy": { + "P1.T001": "restore_original_configs", + "P1.T002": "remove_package_directory", + "P1.T003": "remove_package_directory", + "P1.T004": "restore_from_checkpoint", + "P1.T005": "restore_from_checkpoint", + "P1.T006": "remove_templates", + "P1.T007": "restore_from_checkpoint", + "P1.T008": "remove_hooks", + "P1.T009": "continue_without", + "P1.T010": "restore_from_checkpoint", + "P1.T011": "restore_from_checkpoint", + "P1.T012": "continue_without" + } + } + }, + "monitoring": { + "metrics_collection_interval": 10, + "metrics": [ + "task_throughput", + "average_wait_time", + "resource_utilization", + "failure_rate", + "checkpoint_success_rate", + "test_suite_utilization", + "jsdoc_coverage", + "esm_migration_progress" + ], + "alerts": [ + { + "condition": "failure_rate > 0.1", + "action": "reduce_concurrency", + "notify": "logs/alerts.log" + }, + { + "condition": "test_suite_utilization > 0.9", + "action": "throttle_test_tasks", + "notify": "logs/resource-alerts.log" + }, + { + "condition": "memory_usage > 0.85", + "action": "pause_memory_intensive", + "notify": "logs/memory-alerts.log" + } + ], + "progress_tracking": { + "checkpoints": { + "foundation_complete": ["P1.T001"], + "core_packages_ready": ["P1.T002", "P1.T003"], + "event_system_ready": ["P1.T004"], + "commands_migrated": ["P1.T005"], + "edge_templates_ready": ["P1.T006"], + "dependency_injection_ready": ["P1.T007"], + "jsdoc_pipeline_ready": ["P1.T008"], + "documentation_complete": ["P1.T009"], + "safety_gates_ready": ["P1.T010"], + "tests_complete": ["P1.T011"], + "validation_complete": ["P1.T012"] + }, + "milestones": [ + {"at": "10%", "name": "ESM configured", "tasks": ["P1.T001"]}, + {"at": "25%", "name": "Core packages created", "tasks": ["P1.T002", "P1.T003"]}, + {"at": "40%", "name": "Event system ready", "tasks": ["P1.T004"]}, + {"at": "55%", "name": "Commands migrated", "tasks": ["P1.T005"]}, + {"at": "70%", "name": "Infrastructure complete", "tasks": ["P1.T006", "P1.T007", "P1.T008"]}, + {"at": "85%", "name": "Documentation added", "tasks": ["P1.T009", "P1.T010"]}, + {"at": "95%", "name": "Tests passing", "tasks": ["P1.T011"]}, + {"at": "100%", "name": "Zero build validated", "tasks": ["P1.T012"]} + ] + } + } + }, + "worker_pool": { + "min_workers": 2, + "max_workers": 4, + "scaling_policy": "adaptive", + "scale_up_threshold": { + "ready_queue_size": 3, + "avg_wait_time_seconds": 300 + }, + "scale_down_threshold": { + "idle_workers": 2, + "idle_duration_seconds": 600 + }, + "worker_template": { + "capabilities": ["javascript", "node", "testing", "migration"], + "resource_capacity": { + "cpu_cores": 2, + "memory_mb": 2048, + "disk_io_mbps": 30 + }, + "execution_protocol": { + "heartbeat_interval": 30, + "progress_updates": true, + "can_checkpoint": true + } + }, + "specialized_workers": [ + { + "id": "worker-javascript", + "capabilities": ["javascript", "esm", "node", "migration", "pure-js"], + "preferred_tasks": ["P1.T001", "P1.T002", "P1.T005"] + }, + { + "id": "worker-infrastructure", + "capabilities": ["node", "adapters", "dependency-injection", "safety-gates"], + "preferred_tasks": ["P1.T003", "P1.T007", "P1.T010"] + }, + { + "id": "worker-events", + "capabilities": ["javascript", "events", "runtime-validation", "deno", "edge-functions"], + "preferred_tasks": ["P1.T004", "P1.T006"] + }, + { + "id": "worker-documentation", + "capabilities": ["jsdoc", "ai", "git-hooks", "documentation", "testing"], + "preferred_tasks": ["P1.T008", "P1.T009", "P1.T011"] + }, + { + "id": "worker-validation", + "capabilities": ["validation", "zero-build", "testing"], + "preferred_tasks": ["P1.T012"] + } + ] + }, + "execution_hints": { + "optimal_sequence": [ + "P1.T001", + ["P1.T002", "P1.T003", "P1.T008"], + ["P1.T004", "P1.T006", "P1.T007"], + "P1.T005", + ["P1.T009", "P1.T010"], + "P1.T011", + "P1.T012" + ], + "critical_path_optimization": [ + { + "optimization": "Prioritize P1.T001 with dedicated resources", + "impact": "Unblocks all subsequent tasks" + }, + { + "optimization": "Parallelize package creation (T002-T003) with JSDoc setup (T008)", + "impact": "Save 2-3 hours" + }, + { + "optimization": "Run JSDoc generation concurrently with safety gates", + "impact": "Optimize documentation phase" + } + ], + "resource_optimization": [ + { + "resource": "package.json", + "strategy": "Complete early modifications in T001 and T008", + "impact": "Avoid contention" + }, + { + "resource": "memory", + "strategy": "JavaScript uses less memory than TypeScript compilation", + "impact": "Lower resource requirements overall" + } + ] + } +} \ No newline at end of file diff --git a/docs/TASKS/refactor-core/dag.json b/docs/TASKS/refactor-core/dag.json new file mode 100644 index 0000000..d1b02b9 --- /dev/null +++ b/docs/TASKS/refactor-core/dag.json @@ -0,0 +1,274 @@ +{ + "generated": { + "by": "T.A.S.K.S v3", + "timestamp": "2025-08-31T00:00:00Z", + "contentHash": "js-esm-7f8a9b0c1d2e3f45" + }, + "metrics": { + "minConfidenceApplied": 0.85, + "keptByType": { + "technical": 8, + "sequential": 4, + "infrastructure": 2, + "knowledge": 0, + "mutual_exclusion": 1, + "resource_limited": 0 + }, + "droppedByType": { + "technical": 0, + "sequential": 0, + "infrastructure": 0, + "knowledge": 0 + }, + "nodes": 12, + "edges": 15, + "edgeDensity": 0.114, + "widthApprox": 4, + "widthMethod": "kahn_layer_max", + "longestPath": 5, + "isolatedTasks": 0, + "lowConfidenceEdgesExcluded": 0, + "verbFirstPct": 1.0, + "meceOverlapSuspects": 0, + "mutualExclusionEdges": 1, + "resourceConstrainedTasks": 8, + "resourceUtilization": { + "package_json": { + "total_tasks": 2, + "waves_required": 1, + "serialization_impact": "minimal - early tasks" + }, + "test_suite": { + "total_tasks": 3, + "capacity": 4, + "waves_required": 1, + "utilization": "75% peak" + } + } + }, + "topo_order": [ + "P1.T001", + "P1.T002", + "P1.T003", + "P1.T004", + "P1.T005", + "P1.T006", + "P1.T007", + "P1.T008", + "P1.T009", + "P1.T010", + "P1.T011", + "P1.T012" + ], + "tasks": { + "P1.T001": { + "id": "P1.T001", + "title": "Setup ESM configuration and project structure", + "duration_hours": 1.5, + "dependencies": [], + "resources": ["package.json", ".eslintrc.json"], + "confidence": 0.99, + "can_rollback": true, + "checkpoint_eligible": false + }, + "P1.T002": { + "id": "P1.T002", + "title": "Create data-core pure JavaScript package", + "duration_hours": 2.5, + "dependencies": ["P1.T001"], + "resources": ["packages/data-core"], + "confidence": 0.97, + "can_rollback": true, + "checkpoint_eligible": true + }, + "P1.T003": { + "id": "P1.T003", + "title": "Create data-host-node JavaScript adapters", + "duration_hours": 2, + "dependencies": ["P1.T001"], + "resources": ["packages/data-host-node"], + "confidence": 0.97, + "can_rollback": true, + "checkpoint_eligible": true + }, + "P1.T004": { + "id": "P1.T004", + "title": "Create JavaScript Event Classes with runtime validation", + "duration_hours": 2.5, + "dependencies": ["P1.T002"], + "resources": ["src/lib/events"], + "confidence": 0.96, + "can_rollback": true, + "checkpoint_eligible": false + }, + "P1.T005": { + "id": "P1.T005", + "title": "Migrate commands to ESM JavaScript", + "duration_hours": 4, + "dependencies": ["P1.T004"], + "resources": ["src/commands"], + "confidence": 0.94, + "can_rollback": true, + "checkpoint_eligible": true + }, + "P1.T006": { + "id": "P1.T006", + "title": "Create Deno Edge Function scaffolding", + "duration_hours": 3, + "dependencies": ["P1.T002"], + "resources": ["packages/data-templates"], + "confidence": 0.95, + "can_rollback": true, + "checkpoint_eligible": true + }, + "P1.T007": { + "id": "P1.T007", + "title": "Implement dependency injection system", + "duration_hours": 2.5, + "dependencies": ["P1.T002", "P1.T003"], + "resources": ["packages/data-core/ports"], + "confidence": 0.95, + "can_rollback": true, + "checkpoint_eligible": false + }, + "P1.T008": { + "id": "P1.T008", + "title": "Setup AI-powered JSDoc generation pipeline", + "duration_hours": 1.5, + "dependencies": ["P1.T001"], + "resources": [".husky/pre-commit", "package.json"], + "confidence": 0.98, + "can_rollback": true, + "checkpoint_eligible": false + }, + "P1.T009": { + "id": "P1.T009", + "title": "Add comprehensive JSDoc annotations", + "duration_hours": 3, + "dependencies": ["P1.T008", "P1.T005"], + "resources": ["src/**/*.js"], + "confidence": 0.96, + "can_rollback": false, + "checkpoint_eligible": true + }, + "P1.T010": { + "id": "P1.T010", + "title": "Implement production safety gates", + "duration_hours": 2, + "dependencies": ["P1.T005"], + "resources": ["src/lib/SafetyGates.js"], + "confidence": 0.97, + "can_rollback": true, + "checkpoint_eligible": false + }, + "P1.T011": { + "id": "P1.T011", + "title": "Create comprehensive test suite", + "duration_hours": 3.5, + "dependencies": ["P1.T007", "P1.T009"], + "resources": ["test/**/*.test.js", "test_suite"], + "confidence": 0.93, + "can_rollback": false, + "checkpoint_eligible": true + }, + "P1.T012": { + "id": "P1.T012", + "title": "Validate zero build step architecture", + "duration_hours": 1, + "dependencies": ["P1.T011"], + "resources": ["package.json", "bin/data.js"], + "confidence": 0.99, + "can_rollback": false, + "checkpoint_eligible": false + } + }, + "reduced_edges_sample": [ + ["P1.T001", "P1.T002"], + ["P1.T001", "P1.T003"], + ["P1.T001", "P1.T008"], + ["P1.T002", "P1.T004"], + ["P1.T002", "P1.T006"], + ["P1.T002", "P1.T007"], + ["P1.T003", "P1.T007"], + ["P1.T004", "P1.T005"], + ["P1.T005", "P1.T009"], + ["P1.T005", "P1.T010"], + ["P1.T007", "P1.T011"], + ["P1.T008", "P1.T009"], + ["P1.T009", "P1.T011"], + ["P1.T011", "P1.T012"] + ], + "resource_bottlenecks": [ + { + "resource": "package.json", + "impact": "minimal", + "affected_tasks": ["P1.T001", "P1.T008"], + "mitigation": "Both tasks occur early with minimal overlap" + }, + { + "resource": "test_suite", + "impact": "low", + "affected_tasks": ["P1.T011"], + "mitigation": "Only one task uses test suite heavily" + } + ], + "softDeps": [ + { + "from": "P1.T011", + "to": "P1.T012", + "type": "sequential", + "reason": "Validation follows comprehensive testing", + "confidence": 0.9, + "isHard": true + } + ], + "lowConfidenceDeps": [], + "cycle_break_suggestions": [], + "critical_path": [ + "P1.T001", + "P1.T002", + "P1.T004", + "P1.T005", + "P1.T009", + "P1.T011", + "P1.T012" + ], + "parallelization_opportunities": [ + { + "wave": 2, + "parallel_tasks": ["P1.T002", "P1.T003", "P1.T008"], + "rationale": "Independent foundation packages can be built in parallel" + }, + { + "wave": 3, + "parallel_tasks": ["P1.T004", "P1.T006"], + "rationale": "Event system and Edge templates are independent" + }, + { + "wave": 5, + "parallel_tasks": ["P1.T009", "P1.T010"], + "rationale": "JSDoc and safety gates can be implemented concurrently" + } + ], + "risk_analysis": { + "high_risk_dependencies": [ + { + "edge": "P1.T007 โ†’ P1.T011", + "risk": "Test suite depends on dependency injection working correctly", + "mitigation": "Incremental testing during DI implementation" + } + ], + "single_points_of_failure": [ + { + "task": "P1.T001", + "impact": "All subsequent tasks blocked", + "mitigation": "Simple configuration task with high confidence" + }, + { + "task": "P1.T002", + "impact": "Core functionality blocked", + "mitigation": "Pure JavaScript with no dependencies reduces risk" + } + ] + } +} \ No newline at end of file diff --git a/docs/TASKS/refactor-core/features.json b/docs/TASKS/refactor-core/features.json new file mode 100644 index 0000000..278cd35 --- /dev/null +++ b/docs/TASKS/refactor-core/features.json @@ -0,0 +1,178 @@ +{ + "generated": { + "by": "T.A.S.K.S v3", + "timestamp": "2025-08-31T00:00:00Z", + "contentHash": "js-first-1a2b3c4d5e6f7890" + }, + "features": [ + { + "id": "F001", + "title": "Core Package - Pure JavaScript Logic Layer", + "description": "Stateless SQL graph, diffing, and plan compilation in pure JavaScript with zero I/O dependencies, accepting injected ports for all external operations", + "priority": "critical", + "source_evidence": [ + { + "quote": "Core: no fs, no child_process, no process.env. Accept injected ports: readFile(path), globby(patterns), hash(bytes), spawn(cmd,args), env.get(key), clock.now()", + "loc": {"start": 23, "end": 25}, + "section": "Boundaries that keep you portable", + "startLine": 23, + "endLine": 25 + }, + { + "quote": "JavaScript classes provide instanceof checks that actually execute at runtime, catching type errors where they matter - in production", + "loc": {"start": 21, "end": 21}, + "section": "Architecture Decision", + "startLine": 21, + "endLine": 21 + } + ] + }, + { + "id": "F002", + "title": "Host Adapter Layer - Node.js JavaScript Implementation", + "description": "Node.js-specific JavaScript implementations for filesystem, process spawning, git operations, and environment access wrapping the core", + "priority": "critical", + "source_evidence": [ + { + "quote": "Host-Node: real implementations (fs/promises, child_process, process.env)", + "loc": {"start": 26, "end": 26}, + "section": "Boundaries that keep you portable", + "startLine": 26, + "endLine": 26 + } + ] + }, + { + "id": "F003", + "title": "ESM Module System Migration", + "description": "Convert entire codebase from CommonJS to ES Modules in pure JavaScript, supporting Node 20+ and Bun 1.x with zero build step", + "priority": "critical", + "source_evidence": [ + { + "quote": "Build DATA as an ESM CLI on Node 20+ (Bun optional)", + "loc": {"start": 2, "end": 2}, + "section": "TL;DR", + "startLine": 2, + "endLine": 2 + }, + { + "quote": "CJS: don't ship it. ESM only. Faster, fewer polyfills, works great in Node 20/Bun", + "loc": {"start": 162, "end": 162}, + "section": "Gotchas I'd preempt", + "startLine": 162, + "endLine": 162 + } + ] + }, + { + "id": "F004", + "title": "Comprehensive JSDoc Type Annotations", + "description": "Full JSDoc type documentation for all classes, methods, and interfaces with AI-assisted generation on commit", + "priority": "high", + "source_evidence": [ + { + "quote": "We will use native JavaScript classes with comprehensive JSDoc annotations rather than TypeScript", + "loc": {"start": 17, "end": 17}, + "section": "Architecture Decision", + "startLine": 17, + "endLine": 17 + }, + { + "quote": "Brother, it's 2025. AI can generate perfect JSDoc on every commit", + "loc": {"start": 370, "end": 370}, + "section": "JSDoc + AI Revolution", + "startLine": 370, + "endLine": 370 + } + ] + }, + { + "id": "F005", + "title": "JavaScript Event Classes with Runtime Validation", + "description": "Event-driven architecture using JavaScript classes with instanceof runtime checks for type safety in production", + "priority": "high", + "source_evidence": [ + { + "quote": "JavaScript classes provide instanceof checks that actually execute at runtime, catching type errors where they matter - in production", + "loc": {"start": 21, "end": 21}, + "section": "Rationale", + "startLine": 21, + "endLine": 21 + }, + { + "quote": "The D.A.T.A. system requires robust type safety for its event-driven architecture, particularly for the 179+ event emissions across 34 subsystem files", + "loc": {"start": 13, "end": 13}, + "section": "Context", + "startLine": 13, + "endLine": 13 + } + ] + }, + { + "id": "F006", + "title": "Deno Edge Function Scaffolding", + "description": "Generate Deno-compatible Edge Function templates with Web API-only patterns, no Node built-ins, proper Supabase integration", + "priority": "high", + "source_evidence": [ + { + "quote": "Generate Deno-based Edge Function scaffolds, but don't run on Deno yourself", + "loc": {"start": 3, "end": 3}, + "section": "TL;DR", + "startLine": 3, + "endLine": 3 + }, + { + "quote": "Edge Functions (Deno) scaffolded under supabase/functions//: index.ts (runtime-safe: Web fetch, no Node built-ins)", + "loc": {"start": 31, "end": 33}, + "section": "Supabase specifics", + "startLine": 31, + "endLine": 33 + } + ] + }, + { + "id": "F007", + "title": "Zero Build Step Architecture", + "description": "Pure JavaScript execution with no transpilation, compilation, or build steps - the code that runs is the code you write", + "priority": "critical", + "source_evidence": [ + { + "quote": "Zero Build Step: No transpilation required. The code that runs is the code we write", + "loc": {"start": 23, "end": 27}, + "section": "Rationale", + "startLine": 23, + "endLine": 27 + }, + { + "quote": "Simplified Debugging: Stack traces point to actual source files, not transpiled output", + "loc": {"start": 35, "end": 35}, + "section": "Rationale", + "startLine": 35, + "endLine": 35 + } + ] + }, + { + "id": "F008", + "title": "AI-Powered JSDoc Generation Pipeline", + "description": "Automated JSDoc generation using AI on pre-commit hooks, providing comprehensive type documentation without manual effort", + "priority": "medium", + "source_evidence": [ + { + "quote": "AI can generate perfect JSDoc on every commit", + "loc": {"start": 370, "end": 370}, + "section": "The Solution You Already Have", + "startLine": 370, + "endLine": 370 + }, + { + "quote": "git diff --cached --name-only | grep '\\.js$' | xargs -I {} claude -p 'Add JSDoc' {}", + "loc": {"start": 456, "end": 456}, + "section": "Your Escape Plan", + "startLine": 456, + "endLine": 456 + } + ] + } + ] +} \ No newline at end of file diff --git a/docs/TASKS/refactor-core/tasks.json b/docs/TASKS/refactor-core/tasks.json new file mode 100644 index 0000000..e2a4140 --- /dev/null +++ b/docs/TASKS/refactor-core/tasks.json @@ -0,0 +1,1638 @@ +{ + "meta": { + "execution_model": "rolling_frontier", + "min_confidence": 0.8, + "resource_limits": { + "max_concurrent_tasks": 8, + "max_memory_gb": 16, + "max_cpu_cores": 8, + "max_disk_io_mbps": 200 + }, + "codebase_analysis": { + "existing_apis": ["Command", "DatabaseCommand", "SupabaseCommand", "TestCommand", "MigrationMetadata", "DiffEngine"], + "reused_components": ["CommandRouter", "CliReporter", "PathResolver", "OutputConfig", "EventEmitter"], + "extension_points": ["Command base class", "Event-driven pattern"], + "shared_resources": { + "package_json": { + "type": "exclusive", + "location": "package.json", + "constraint": "sequential_only", + "reason": "Package.json modifications must be atomic" + }, + "eslintrc": { + "type": "exclusive", + "location": ".eslintrc.js", + "constraint": "one_at_a_time", + "reason": "ESLint config must be consistent" + }, + "test_suite": { + "type": "shared_limited", + "capacity": 4, + "location": "test/", + "reason": "Test runner can handle parallel tests" + } + } + }, + "autonormalization": { + "split": [], + "merged": [] + } + }, + "generated": { + "by": "T.A.S.K.S v3", + "timestamp": "2025-08-31T00:00:00Z", + "contentHash": "js-esm-2b3c4d5e6f7a8901" + }, + "tasks": [ + { + "id": "P1.T001", + "feature_id": "F003", + "title": "Setup ESM configuration and Node 20+ requirements", + "description": "Configure package.json for ES modules, update Node engine requirements, setup import map", + "category": "foundation", + "boundaries": { + "expected_complexity": { + "value": "~50 LoC", + "breakdown": "Package.json updates (20 LoC), import map (15 LoC), scripts (15 LoC)" + }, + "definition_of_done": { + "criteria": [ + "Package.json has type: 'module'", + "Node engine set to >=20.0.0", + "Import extensions configured", + "No build scripts needed" + ], + "stop_when": "Do NOT add any TypeScript or build tooling" + }, + "scope": { + "includes": ["package.json", ".nvmrc", "jsconfig.json"], + "excludes": ["src/**/*.js", "test/**/*.js"], + "restrictions": "Only configuration files, no source code" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Configuring ESM and Node 20+ requirements'", + "on_progress": "Log each configuration file update", + "on_completion": "Log 'ESM configuration complete'", + "log_format": "JSON with fields: {task_id, timestamp, event, details}" + }, + "checkpoints": [ + "After package.json: Verify ESM imports work", + "After jsconfig: Check IDE support", + "Before completion: Test import resolution" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "33%", "name": "package_configured", "rollback_capable": true}, + {"at": "66%", "name": "engine_requirements_set", "rollback_capable": true}, + {"at": "100%", "name": "esm_ready", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 1, + "memory_mb": 256, + "disk_io_mbps": 5, + "exclusive_resources": ["package_json"], + "shared_resources": {} + }, + "peak": { + "cpu_cores": 1, + "memory_mb": 512, + "disk_io_mbps": 10, + "duration_seconds": 5, + "during": "Testing import resolution" + }, + "worker_capabilities_required": ["node", "esm"] + }, + "scheduling_hints": { + "priority": "critical", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 3, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": [], + "can_pause_resume": false, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": [], + "rationale": "Foundation task - configuring for ESM" + }, + "skillsRequired": ["javascript", "node", "esm"], + "duration": { + "optimistic": 0.5, + "mostLikely": 1, + "pessimistic": 2 + }, + "durationUnits": "hours", + "interfaces_produced": ["ESMConfig:v1"], + "interfaces_consumed": [], + "acceptance_checks": [ + { + "type": "command", + "cmd": "node --version | grep -E 'v(2[0-9]|[3-9][0-9])'", + "expect": { + "exitCode": 0 + } + }, + { + "type": "artifact", + "path": "package.json", + "expect": { + "exists": true, + "contains": ["\"type\": \"module\""] + } + } + ], + "source_evidence": [ + { + "quote": "Build DATA as an ESM CLI on Node 20+ (Bun optional)", + "loc": {"start": 2, "end": 2}, + "section": "TL;DR", + "startLine": 2, + "endLine": 2 + } + ], + "contentHash": "esm-config-abc123" + }, + { + "id": "P1.T002", + "feature_id": "F001", + "title": "Create data-core package with pure JavaScript", + "description": "Initialize data-core package with port interfaces in JavaScript using JSDoc for type documentation", + "category": "foundation", + "boundaries": { + "expected_complexity": { + "value": "~200 LoC", + "breakdown": "Port interfaces (100 LoC), JSDoc types (50 LoC), package setup (50 LoC)" + }, + "definition_of_done": { + "criteria": [ + "packages/data-core directory created", + "Port interfaces defined with JSDoc", + "No filesystem or I/O operations", + "Full JSDoc documentation" + ], + "stop_when": "Do NOT implement logic yet - only interfaces" + }, + "scope": { + "includes": ["packages/data-core/**"], + "excludes": ["packages/data-host-node/**", "packages/data-cli/**"], + "restrictions": "Only data-core package structure" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Creating data-core package with JavaScript'", + "on_progress": "Log each interface creation", + "on_completion": "Log package structure complete", + "log_format": "JSON with fields: {task_id, timestamp, event, details}" + }, + "checkpoints": [ + "After package creation: Validate structure", + "After interfaces: Check JSDoc completeness", + "Before completion: Verify no I/O operations" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "25%", "name": "package_created", "rollback_capable": true}, + {"at": "50%", "name": "interfaces_defined", "rollback_capable": true}, + {"at": "75%", "name": "jsdoc_complete", "rollback_capable": true} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 2, + "memory_mb": 512, + "disk_io_mbps": 10, + "exclusive_resources": [], + "shared_resources": {"test_suite": 1} + }, + "peak": { + "cpu_cores": 2, + "memory_mb": 1024, + "disk_io_mbps": 20, + "duration_seconds": 10, + "during": "Package initialization" + }, + "worker_capabilities_required": ["javascript", "jsdoc"] + }, + "scheduling_hints": { + "priority": "critical", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": ["P1.T003", "P1.T004"], + "can_pause_resume": true, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": [], + "rationale": "New package with pure JavaScript architecture" + }, + "skillsRequired": ["javascript", "architecture", "jsdoc"], + "duration": { + "optimistic": 2, + "mostLikely": 3, + "pessimistic": 4 + }, + "durationUnits": "hours", + "interfaces_produced": ["CorePorts:v1", "CoreInterfaces:v1"], + "interfaces_consumed": ["ESMConfig:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "cd packages/data-core && npm test", + "expect": { + "exitCode": 0 + } + }, + { + "type": "artifact", + "path": "packages/data-core/index.js", + "expect": { + "exists": true, + "contains": ["@typedef", "@param", "@returns"] + } + } + ], + "source_evidence": [ + { + "quote": "Core: no fs, no child_process, no process.env. Accept injected ports", + "loc": {"start": 23, "end": 23}, + "section": "Boundaries", + "startLine": 23, + "endLine": 23 + } + ], + "contentHash": "core-pkg-def456" + }, + { + "id": "P1.T003", + "feature_id": "F002", + "title": "Create data-host-node JavaScript adapters", + "description": "Implement Node.js host adapters in JavaScript with real fs, spawn, env implementations", + "category": "foundation", + "boundaries": { + "expected_complexity": { + "value": "~250 LoC", + "breakdown": "Adapters (150 LoC), JSDoc (50 LoC), tests (50 LoC)" + }, + "definition_of_done": { + "criteria": [ + "packages/data-host-node created", + "All port implementations working", + "Full JSDoc documentation", + "Unit tests passing" + ], + "stop_when": "Do NOT integrate with core yet" + }, + "scope": { + "includes": ["packages/data-host-node/**"], + "excludes": ["packages/data-core/**", "packages/data-cli/**"], + "restrictions": "Only host adapter implementations" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Creating Node.js host adapters in JavaScript'", + "on_progress": "Log each adapter implementation", + "on_completion": "Log all adapters tested", + "log_format": "JSON with fields: {task_id, timestamp, event, details}" + }, + "checkpoints": [ + "After fs adapter: Test file operations", + "After spawn adapter: Test process execution", + "Before completion: Integration test adapters" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "33%", "name": "fs_adapter_complete", "rollback_capable": true}, + {"at": "66%", "name": "spawn_adapter_complete", "rollback_capable": true}, + {"at": "100%", "name": "all_adapters_tested", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 2, + "memory_mb": 512, + "disk_io_mbps": 15, + "exclusive_resources": [], + "shared_resources": {"test_suite": 1} + }, + "peak": { + "cpu_cores": 3, + "memory_mb": 1024, + "disk_io_mbps": 30, + "duration_seconds": 15, + "during": "Integration tests" + }, + "worker_capabilities_required": ["node", "javascript", "testing"] + }, + "scheduling_hints": { + "priority": "critical", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": ["P1.T002", "P1.T004"], + "can_pause_resume": true, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": ["fs", "child_process", "process"], + "rationale": "Wrapping Node.js built-ins for dependency injection" + }, + "skillsRequired": ["node", "javascript", "testing"], + "duration": { + "optimistic": 2, + "mostLikely": 3, + "pessimistic": 5 + }, + "durationUnits": "hours", + "interfaces_produced": ["NodeAdapters:v1"], + "interfaces_consumed": ["CorePorts:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "cd packages/data-host-node && npm test", + "expect": { + "passRateGte": 1.0, + "coverageGte": 0.90 + } + } + ], + "source_evidence": [ + { + "quote": "Host-Node: real implementations (fs/promises, child_process, process.env)", + "loc": {"start": 26, "end": 26}, + "section": "Boundaries", + "startLine": 26, + "endLine": 26 + } + ], + "contentHash": "host-node-ghi789" + }, + { + "id": "P1.T004", + "feature_id": "F005", + "title": "Create JavaScript Event Classes with Runtime Validation", + "description": "Implement event-driven architecture using JavaScript classes with instanceof checks for runtime type safety", + "category": "implementation", + "boundaries": { + "expected_complexity": { + "value": "~400 LoC", + "breakdown": "Event classes (200 LoC), JSDoc (100 LoC), validation (100 LoC)" + }, + "definition_of_done": { + "criteria": [ + "All event classes created", + "instanceof validation working", + "Full JSDoc documentation", + "Runtime type checking implemented" + ], + "stop_when": "Do NOT migrate all 179 emissions yet" + }, + "scope": { + "includes": ["packages/data-core/src/events/**"], + "excludes": ["src/commands/**"], + "restrictions": "Only event class definitions" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Creating JavaScript Event Classes'", + "on_progress": "Log each event class creation", + "on_completion": "Log runtime validation test results", + "log_format": "JSON with fields: {task_id, timestamp, event, details}" + }, + "checkpoints": [ + "After base class: Test instanceof checks", + "After event types: Validate runtime safety", + "Before completion: Test all event types" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "33%", "name": "base_event_complete", "rollback_capable": true}, + {"at": "66%", "name": "all_events_defined", "rollback_capable": true}, + {"at": "100%", "name": "validation_tested", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 2, + "memory_mb": 512, + "disk_io_mbps": 10, + "exclusive_resources": [], + "shared_resources": {"test_suite": 1} + }, + "peak": { + "cpu_cores": 2, + "memory_mb": 1024, + "disk_io_mbps": 15, + "duration_seconds": 15, + "during": "Runtime validation tests" + }, + "worker_capabilities_required": ["javascript", "testing"] + }, + "scheduling_hints": { + "priority": "high", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": ["P1.T005"], + "can_pause_resume": true, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": ["EventEmitter"], + "imports": ["Command"], + "rationale": "Building on existing event-driven architecture" + }, + "skillsRequired": ["javascript", "events", "testing"], + "duration": { + "optimistic": 3, + "mostLikely": 4, + "pessimistic": 6 + }, + "durationUnits": "hours", + "interfaces_produced": ["EventClasses:v1", "RuntimeValidation:v1"], + "interfaces_consumed": ["CorePorts:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "npm test -- events", + "expect": { + "passRateGte": 1.0 + } + }, + { + "type": "command", + "cmd": "node -e \"const {ProgressEvent} = require('./packages/data-core/src/events'); console.log(new ProgressEvent('test') instanceof ProgressEvent)\"", + "expect": { + "output": "true" + } + } + ], + "source_evidence": [ + { + "quote": "JavaScript classes provide instanceof checks that actually execute at runtime", + "loc": {"start": 21, "end": 21}, + "section": "Rationale", + "startLine": 21, + "endLine": 21 + } + ], + "contentHash": "events-jkl012" + }, + { + "id": "P1.T005", + "feature_id": "F001", + "title": "Implement SQL graph and diffing in JavaScript", + "description": "Create pure JavaScript SQL graph builder and diff engine without filesystem dependencies", + "category": "implementation", + "boundaries": { + "expected_complexity": { + "value": "~500 LoC", + "breakdown": "Graph builder (200 LoC), Diff engine (200 LoC), JSDoc (100 LoC)" + }, + "definition_of_done": { + "criteria": [ + "SQL graph builder working", + "Diff engine producing plans", + "Full JSDoc documentation", + "Zero I/O operations" + ], + "stop_when": "Do NOT implement file reading - use injected data" + }, + "scope": { + "includes": ["packages/data-core/src/sql/**", "packages/data-core/src/diff/**"], + "excludes": ["packages/data-host-node/**"], + "restrictions": "Pure logic only - no I/O" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Implementing SQL graph and diff in JavaScript'", + "on_progress": "Log graph construction progress", + "on_completion": "Log diff algorithm metrics", + "log_format": "JSON with fields: {task_id, timestamp, event, metrics}" + }, + "checkpoints": [ + "After graph builder: Validate dependencies", + "After diff engine: Test migration generation", + "Before completion: Performance benchmarks" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "33%", "name": "graph_builder_complete", "rollback_capable": true}, + {"at": "66%", "name": "diff_engine_complete", "rollback_capable": true}, + {"at": "100%", "name": "benchmarks_complete", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 3, + "memory_mb": 1024, + "disk_io_mbps": 5, + "exclusive_resources": [], + "shared_resources": {"test_suite": 1} + }, + "peak": { + "cpu_cores": 4, + "memory_mb": 2048, + "disk_io_mbps": 10, + "duration_seconds": 20, + "during": "Large graph diffing" + }, + "worker_capabilities_required": ["javascript", "algorithms", "testing"] + }, + "scheduling_hints": { + "priority": "high", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": ["P1.T004"], + "can_pause_resume": true, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": ["DiffEngine"], + "rationale": "Reimplementing DiffEngine as pure JavaScript without I/O" + }, + "skillsRequired": ["javascript", "algorithms", "sql"], + "duration": { + "optimistic": 4, + "mostLikely": 6, + "pessimistic": 8 + }, + "durationUnits": "hours", + "interfaces_produced": ["SQLGraph:v1", "DiffEngine:v1"], + "interfaces_consumed": ["CorePorts:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "cd packages/data-core && npm test -- sql diff", + "expect": { + "passRateGte": 0.95, + "coverageGte": 0.90 + } + } + ], + "source_evidence": [ + { + "quote": "Pure logic: SQL graph, diffing, plan compiler (no fs/spawn)", + "loc": {"start": 18, "end": 18}, + "section": "Package layout", + "startLine": 18, + "endLine": 18 + } + ], + "contentHash": "sql-diff-mno345" + }, + { + "id": "P1.T006", + "feature_id": "F006", + "title": "Create Deno Edge Function template system", + "description": "Build template generator for Deno-compatible Edge Functions with Web API patterns", + "category": "implementation", + "boundaries": { + "expected_complexity": { + "value": "~400 LoC", + "breakdown": "Template engine (150 LoC), Templates (150 LoC), Generator (100 LoC)" + }, + "definition_of_done": { + "criteria": [ + "Template system generating Deno functions", + "Web API-only patterns enforced", + "Supabase integration templates", + "Documentation included" + ], + "stop_when": "Do NOT create runtime - only generators" + }, + "scope": { + "includes": ["packages/data-templates/edge-functions/**"], + "excludes": ["packages/data-cli/**"], + "restrictions": "Only template generation" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Creating Edge Function templates'", + "on_progress": "Log each template creation", + "on_completion": "Log template validation results", + "log_format": "JSON with fields: {task_id, timestamp, event, template_name}" + }, + "checkpoints": [ + "After engine: Validate substitution", + "After templates: Test Deno compatibility", + "Before completion: Generate sample" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "33%", "name": "engine_complete", "rollback_capable": true}, + {"at": "66%", "name": "templates_created", "rollback_capable": true}, + {"at": "100%", "name": "validation_complete", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 2, + "memory_mb": 512, + "disk_io_mbps": 10, + "exclusive_resources": [], + "shared_resources": {"test_suite": 1} + }, + "peak": { + "cpu_cores": 2, + "memory_mb": 1024, + "disk_io_mbps": 20, + "duration_seconds": 10, + "during": "Template generation" + }, + "worker_capabilities_required": ["javascript", "deno", "templates"] + }, + "scheduling_hints": { + "priority": "high", + "preemptible": true, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": [], + "can_pause_resume": true, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": [], + "rationale": "New functionality for Edge Function generation" + }, + "skillsRequired": ["javascript", "deno", "edge-functions"], + "duration": { + "optimistic": 3, + "mostLikely": 5, + "pessimistic": 7 + }, + "durationUnits": "hours", + "interfaces_produced": ["EdgeTemplate:v1", "TemplateEngine:v1"], + "interfaces_consumed": [], + "acceptance_checks": [ + { + "type": "command", + "cmd": "deno check packages/data-templates/edge-functions/health/index.ts", + "expect": { + "exitCode": 0 + } + } + ], + "source_evidence": [ + { + "quote": "Edge Functions (Deno) scaffolded under supabase/functions//", + "loc": {"start": 31, "end": 31}, + "section": "Supabase specifics", + "startLine": 31, + "endLine": 31 + } + ], + "contentHash": "edge-tmpl-pqr678" + }, + { + "id": "P1.T007", + "feature_id": "F003", + "title": "Migrate CLI entry point to ESM", + "description": "Convert bin/data.js and src/index.js to ES modules with proper import syntax", + "category": "implementation", + "boundaries": { + "expected_complexity": { + "value": "~150 LoC", + "breakdown": "CLI entry (50 LoC), Index refactor (50 LoC), Import updates (50 LoC)" + }, + "definition_of_done": { + "criteria": [ + "bin/data.js using ESM imports", + "src/index.js converted to ESM", + "All imports have extensions", + "Commander.js working" + ], + "stop_when": "Do NOT migrate individual commands yet" + }, + "scope": { + "includes": ["bin/data.js", "src/index.js"], + "excludes": ["src/commands/**"], + "restrictions": "Only entry point files" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Migrating CLI to ESM'", + "on_progress": "Log each file conversion", + "on_completion": "Log CLI test results", + "log_format": "JSON with fields: {task_id, timestamp, event, file}" + }, + "checkpoints": [ + "After bin: Test CLI invocation", + "After index: Verify command loading", + "Before completion: E2E CLI test" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "33%", "name": "bin_converted", "rollback_capable": true}, + {"at": "66%", "name": "index_migrated", "rollback_capable": true}, + {"at": "100%", "name": "cli_tested", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 2, + "memory_mb": 512, + "disk_io_mbps": 5, + "exclusive_resources": [], + "shared_resources": {"test_suite": 1} + }, + "peak": { + "cpu_cores": 2, + "memory_mb": 1024, + "disk_io_mbps": 10, + "duration_seconds": 10, + "during": "CLI tests" + }, + "worker_capabilities_required": ["node", "esm", "cli"] + }, + "scheduling_hints": { + "priority": "high", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": ["P1.T008"], + "can_pause_resume": false, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": ["commander", "CommandRouter"], + "rationale": "Converting existing CLI to ESM" + }, + "skillsRequired": ["node", "esm", "cli"], + "duration": { + "optimistic": 2, + "mostLikely": 3, + "pessimistic": 4 + }, + "durationUnits": "hours", + "interfaces_produced": ["CLI:v1"], + "interfaces_consumed": ["EventClasses:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "node bin/data.js --version", + "expect": { + "exitCode": 0 + } + } + ], + "source_evidence": [ + { + "quote": "ESM only. Faster, fewer polyfills", + "loc": {"start": 162, "end": 162}, + "section": "Gotchas", + "startLine": 162, + "endLine": 162 + } + ], + "contentHash": "cli-esm-stu901" + }, + { + "id": "P1.T008", + "feature_id": "F008", + "title": "Setup AI-powered JSDoc generation pipeline", + "description": "Configure pre-commit hooks for automated JSDoc generation using AI", + "category": "implementation", + "boundaries": { + "expected_complexity": { + "value": "~100 LoC", + "breakdown": "Hook scripts (50 LoC), Configuration (25 LoC), Documentation (25 LoC)" + }, + "definition_of_done": { + "criteria": [ + "Pre-commit hook installed", + "AI JSDoc generation working", + "Git integration complete", + "Documentation written" + ], + "stop_when": "Do NOT manually write JSDoc everywhere" + }, + "scope": { + "includes": [".husky/**", "scripts/jsdoc-ai.js", "package.json"], + "excludes": ["src/**/*.js"], + "restrictions": "Only automation setup" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Setting up AI JSDoc pipeline'", + "on_progress": "Log hook configuration", + "on_completion": "Log test generation results", + "log_format": "JSON with fields: {task_id, timestamp, event, config}" + }, + "checkpoints": [ + "After hook: Test pre-commit trigger", + "After script: Validate JSDoc generation", + "Before completion: Full pipeline test" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "50%", "name": "hook_configured", "rollback_capable": true}, + {"at": "100%", "name": "pipeline_tested", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 1, + "memory_mb": 256, + "disk_io_mbps": 5, + "exclusive_resources": [], + "shared_resources": {} + }, + "peak": { + "cpu_cores": 2, + "memory_mb": 512, + "disk_io_mbps": 10, + "duration_seconds": 10, + "during": "AI generation test" + }, + "worker_capabilities_required": ["git", "ai", "automation"] + }, + "scheduling_hints": { + "priority": "medium", + "preemptible": true, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "anytime", + "avoid_concurrent_with": [], + "can_pause_resume": true, + "checkpoint_capable": false + }, + "reuses_existing": { + "extends": [], + "imports": [], + "rationale": "New AI-powered documentation system" + }, + "skillsRequired": ["git", "automation", "ai"], + "duration": { + "optimistic": 1, + "mostLikely": 2, + "pessimistic": 3 + }, + "durationUnits": "hours", + "interfaces_produced": ["JSDocPipeline:v1"], + "interfaces_consumed": [], + "acceptance_checks": [ + { + "type": "command", + "cmd": "git commit --dry-run && cat .git/hooks/pre-commit | grep jsdoc", + "expect": { + "exitCode": 0 + } + } + ], + "source_evidence": [ + { + "quote": "AI can generate perfect JSDoc on every commit", + "loc": {"start": 370, "end": 370}, + "section": "JSDoc + AI Revolution", + "startLine": 370, + "endLine": 370 + } + ], + "contentHash": "ai-jsdoc-vwx234" + }, + { + "id": "P1.T009", + "feature_id": "F001", + "title": "Wire up core with host adapters", + "description": "Integrate data-core with data-host-node through dependency injection in JavaScript", + "category": "integration", + "boundaries": { + "expected_complexity": { + "value": "~150 LoC", + "breakdown": "Wiring (75 LoC), Factory (50 LoC), Tests (25 LoC)" + }, + "definition_of_done": { + "criteria": [ + "Core consuming host adapters", + "Dependency injection working", + "All ports connected", + "Integration tests passing" + ], + "stop_when": "Do NOT refactor commands yet" + }, + "scope": { + "includes": ["packages/data-cli/src/bootstrap.js"], + "excludes": ["src/commands/**"], + "restrictions": "Only integration layer" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Wiring core with adapters'", + "on_progress": "Log each connection", + "on_completion": "Log integration test results", + "log_format": "JSON with fields: {task_id, timestamp, event, adapter}" + }, + "checkpoints": [ + "After wiring: Test port connections", + "After factory: Validate DI", + "Before completion: E2E test" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "50%", "name": "wiring_complete", "rollback_capable": true}, + {"at": "100%", "name": "integration_tested", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 2, + "memory_mb": 512, + "disk_io_mbps": 5, + "exclusive_resources": [], + "shared_resources": {"test_suite": 1} + }, + "peak": { + "cpu_cores": 2, + "memory_mb": 1024, + "disk_io_mbps": 10, + "duration_seconds": 10, + "during": "Integration tests" + }, + "worker_capabilities_required": ["javascript", "dependency-injection", "testing"] + }, + "scheduling_hints": { + "priority": "critical", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": ["P1.T010"], + "can_pause_resume": false, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": [], + "rationale": "New integration layer for modular architecture" + }, + "skillsRequired": ["javascript", "dependency-injection", "architecture"], + "duration": { + "optimistic": 2, + "mostLikely": 3, + "pessimistic": 4 + }, + "durationUnits": "hours", + "interfaces_produced": ["Bootstrap:v1"], + "interfaces_consumed": ["CorePorts:v1", "NodeAdapters:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "npm test -- integration", + "expect": { + "passRateGte": 1.0 + } + } + ], + "source_evidence": [ + { + "quote": "CLI: argument parsing, pretty TTY, exit codes", + "loc": {"start": 27, "end": 27}, + "section": "Boundaries", + "startLine": 27, + "endLine": 27 + } + ], + "contentHash": "wire-yza567" + }, + { + "id": "P1.T010", + "feature_id": "F003", + "title": "Migrate all commands to ESM JavaScript", + "description": "Convert all 30+ command files from CommonJS to ES modules with JSDoc", + "category": "implementation", + "boundaries": { + "expected_complexity": { + "value": "~750 LoC", + "breakdown": "30 commands ร— 25 LoC average conversion" + }, + "definition_of_done": { + "criteria": [ + "All commands converted to ESM", + "JSDoc added to all commands", + "All tests passing", + "No require() statements" + ], + "stop_when": "Complete when all migrated" + }, + "scope": { + "includes": ["src/commands/**/*.js"], + "excludes": [], + "restrictions": "Maintain functionality" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Starting command migration to ESM'", + "on_progress": "Log each command converted", + "on_completion": "Log migration statistics", + "log_format": "JSON with fields: {task_id, timestamp, event, file, stats}" + }, + "checkpoints": [ + "After 25%: Test db commands", + "After 50%: Test function commands", + "After 75%: Test remaining", + "Before completion: Full regression" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "25%", "name": "db_commands_migrated", "rollback_capable": true}, + {"at": "50%", "name": "function_commands_migrated", "rollback_capable": true}, + {"at": "75%", "name": "test_commands_migrated", "rollback_capable": true}, + {"at": "100%", "name": "all_migrated", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 3, + "memory_mb": 1024, + "disk_io_mbps": 15, + "exclusive_resources": [], + "shared_resources": {"test_suite": 2} + }, + "peak": { + "cpu_cores": 4, + "memory_mb": 2048, + "disk_io_mbps": 25, + "duration_seconds": 30, + "during": "Full test suite" + }, + "worker_capabilities_required": ["javascript", "esm", "migration"] + }, + "scheduling_hints": { + "priority": "high", + "preemptible": false, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "business_hours", + "avoid_concurrent_with": ["P1.T009"], + "can_pause_resume": true, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": ["Command"], + "imports": ["All command logic"], + "rationale": "Preserving functionality while converting to ESM" + }, + "skillsRequired": ["javascript", "esm", "migration"], + "duration": { + "optimistic": 6, + "mostLikely": 8, + "pessimistic": 12 + }, + "durationUnits": "hours", + "interfaces_produced": ["CommandSet:v2"], + "interfaces_consumed": ["CLI:v1", "Bootstrap:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "npm test", + "expect": { + "passRateGte": 1.0, + "coverageGte": 0.85 + } + }, + { + "type": "command", + "cmd": "grep -r \"require(\" src/ | wc -l", + "expect": { + "output": "0" + } + } + ], + "source_evidence": [ + { + "quote": "30+ command files identified", + "loc": {"start": 1, "end": 30}, + "section": "Codebase analysis", + "startLine": 1, + "endLine": 30 + } + ], + "contentHash": "cmd-esm-abc123" + }, + { + "id": "P1.T011", + "feature_id": "F004", + "title": "Add comprehensive JSDoc to all modules", + "description": "Ensure complete JSDoc documentation across all JavaScript modules with AI assistance", + "category": "optimization", + "boundaries": { + "expected_complexity": { + "value": "~400 LoC", + "breakdown": "JSDoc annotations across all files" + }, + "definition_of_done": { + "criteria": [ + "All public APIs documented", + "All parameters typed", + "All returns documented", + "IDE IntelliSense working" + ], + "stop_when": "100% JSDoc coverage" + }, + "scope": { + "includes": ["packages/**/*.js", "src/**/*.js"], + "excludes": ["node_modules/**"], + "restrictions": "Documentation only" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Adding comprehensive JSDoc'", + "on_progress": "Log documentation coverage", + "on_completion": "Log final coverage report", + "log_format": "JSON with fields: {task_id, timestamp, event, coverage}" + }, + "checkpoints": [ + "After core: Validate JSDoc", + "After commands: Check IntelliSense", + "Before completion: Coverage analysis" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": true, + "checkpoint_events": [ + {"at": "50%", "name": "core_documented", "rollback_capable": true}, + {"at": "100%", "name": "all_documented", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 2, + "memory_mb": 1024, + "disk_io_mbps": 5, + "exclusive_resources": [], + "shared_resources": {} + }, + "peak": { + "cpu_cores": 3, + "memory_mb": 2048, + "disk_io_mbps": 10, + "duration_seconds": 20, + "during": "AI generation" + }, + "worker_capabilities_required": ["javascript", "jsdoc", "ai"] + }, + "scheduling_hints": { + "priority": "medium", + "preemptible": true, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "anytime", + "avoid_concurrent_with": [], + "can_pause_resume": true, + "checkpoint_capable": true + }, + "reuses_existing": { + "extends": [], + "imports": [], + "rationale": "Adding documentation to existing code" + }, + "skillsRequired": ["javascript", "jsdoc", "documentation"], + "duration": { + "optimistic": 3, + "mostLikely": 5, + "pessimistic": 7 + }, + "durationUnits": "hours", + "interfaces_produced": ["Documentation:v1"], + "interfaces_consumed": ["JSDocPipeline:v1"], + "acceptance_checks": [ + { + "type": "command", + "cmd": "npx jsdoc-coverage-reporter", + "expect": { + "coverageGte": 0.95 + } + } + ], + "source_evidence": [ + { + "quote": "We will use native JavaScript classes with comprehensive JSDoc annotations", + "loc": {"start": 17, "end": 17}, + "section": "Decision", + "startLine": 17, + "endLine": 17 + } + ], + "contentHash": "jsdoc-def456" + }, + { + "id": "P1.T012", + "feature_id": "F007", + "title": "Validate zero build step architecture", + "description": "Ensure entire codebase runs without any build, transpilation, or compilation steps", + "category": "optimization", + "boundaries": { + "expected_complexity": { + "value": "~50 LoC", + "breakdown": "Validation scripts and cleanup" + }, + "definition_of_done": { + "criteria": [ + "No build scripts in package.json", + "No TypeScript files", + "Direct execution working", + "Stack traces point to source" + ], + "stop_when": "Zero build step confirmed" + }, + "scope": { + "includes": ["package.json", "scripts/**"], + "excludes": [], + "restrictions": "Remove all build tooling" + } + }, + "execution_guidance": { + "logging": { + "on_start": "Log 'Validating zero build architecture'", + "on_progress": "Log validation checks", + "on_completion": "Log validation results", + "log_format": "JSON with fields: {task_id, timestamp, event, check}" + }, + "checkpoints": [ + "After cleanup: No build scripts", + "After validation: Direct execution", + "Before completion: Debug test" + ], + "monitoring": { + "heartbeat_interval_seconds": 30, + "progress_reporting": "percentage_and_checkpoint", + "resource_usage_reporting": false, + "checkpoint_events": [ + {"at": "50%", "name": "build_removed", "rollback_capable": false}, + {"at": "100%", "name": "zero_build_confirmed", "rollback_capable": false} + ] + } + }, + "resource_requirements": { + "estimated": { + "cpu_cores": 1, + "memory_mb": 256, + "disk_io_mbps": 5, + "exclusive_resources": ["package_json"], + "shared_resources": {} + }, + "peak": { + "cpu_cores": 1, + "memory_mb": 512, + "disk_io_mbps": 10, + "duration_seconds": 5, + "during": "Validation" + }, + "worker_capabilities_required": ["javascript", "validation"] + }, + "scheduling_hints": { + "priority": "low", + "preemptible": true, + "retry_on_failure": true, + "max_retries": 2, + "preferred_time_window": "anytime", + "avoid_concurrent_with": [], + "can_pause_resume": true, + "checkpoint_capable": false + }, + "reuses_existing": { + "extends": [], + "imports": [], + "rationale": "Validation and cleanup task" + }, + "skillsRequired": ["javascript", "architecture"], + "duration": { + "optimistic": 0.5, + "mostLikely": 1, + "pessimistic": 2 + }, + "durationUnits": "hours", + "interfaces_produced": ["ZeroBuild:v1"], + "interfaces_consumed": [], + "acceptance_checks": [ + { + "type": "command", + "cmd": "grep -E \"build|compile|transpile\" package.json | grep -v test | wc -l", + "expect": { + "output": "0" + } + }, + { + "type": "command", + "cmd": "node bin/data.js --help", + "expect": { + "exitCode": 0 + } + } + ], + "source_evidence": [ + { + "quote": "Zero Build Step: No transpilation required", + "loc": {"start": 23, "end": 23}, + "section": "Rationale", + "startLine": 23, + "endLine": 23 + } + ], + "contentHash": "zero-ghi789" + } + ], + "dependencies": [ + { + "from": "P1.T001", + "to": "P1.T002", + "type": "infrastructure", + "reason": "Core package needs ESM configuration", + "evidence": [ + { + "type": "doc", + "reason": "ESM setup required before packages", + "confidence": 1.0 + } + ], + "confidence": 1.0, + "isHard": true + }, + { + "from": "P1.T001", + "to": "P1.T003", + "type": "infrastructure", + "reason": "Host package needs ESM configuration", + "evidence": [ + { + "type": "doc", + "reason": "ESM setup required before packages", + "confidence": 1.0 + } + ], + "confidence": 1.0, + "isHard": true + }, + { + "from": "P1.T002", + "to": "P1.T003", + "type": "technical", + "reason": "Host adapters need core interfaces", + "evidence": [ + { + "type": "doc", + "reason": "Adapters implement core ports", + "confidence": 0.95 + } + ], + "confidence": 0.95, + "isHard": true + }, + { + "from": "P1.T002", + "to": "P1.T004", + "type": "technical", + "reason": "Event classes need core interfaces", + "evidence": [ + { + "type": "doc", + "reason": "Events are part of core", + "confidence": 0.9 + } + ], + "confidence": 0.9, + "isHard": true + }, + { + "from": "P1.T002", + "to": "P1.T005", + "type": "technical", + "reason": "SQL graph needs core interfaces", + "evidence": [ + { + "type": "doc", + "reason": "SQL graph uses injected ports", + "confidence": 0.95 + } + ], + "confidence": 0.95, + "isHard": true + }, + { + "from": "P1.T004", + "to": "P1.T007", + "type": "technical", + "reason": "CLI needs event classes", + "evidence": [ + { + "type": "doc", + "reason": "CLI imports event system", + "confidence": 0.85 + } + ], + "confidence": 0.85, + "isHard": true + }, + { + "from": "P1.T002", + "to": "P1.T009", + "type": "technical", + "reason": "Wiring needs core package", + "evidence": [ + { + "type": "doc", + "reason": "Integration requires core", + "confidence": 1.0 + } + ], + "confidence": 1.0, + "isHard": true + }, + { + "from": "P1.T003", + "to": "P1.T009", + "type": "technical", + "reason": "Wiring needs host adapters", + "evidence": [ + { + "type": "doc", + "reason": "Integration requires adapters", + "confidence": 1.0 + } + ], + "confidence": 1.0, + "isHard": true + }, + { + "from": "P1.T009", + "to": "P1.T010", + "type": "technical", + "reason": "Commands need integrated system", + "evidence": [ + { + "type": "doc", + "reason": "Command migration requires DI", + "confidence": 0.95 + } + ], + "confidence": 0.95, + "isHard": true + }, + { + "from": "P1.T007", + "to": "P1.T010", + "type": "technical", + "reason": "Commands need ESM CLI", + "evidence": [ + { + "type": "doc", + "reason": "Command loading requires ESM", + "confidence": 0.9 + } + ], + "confidence": 0.9, + "isHard": true + }, + { + "from": "P1.T008", + "to": "P1.T011", + "type": "technical", + "reason": "JSDoc generation uses AI pipeline", + "evidence": [ + { + "type": "doc", + "reason": "Documentation uses AI system", + "confidence": 0.85 + } + ], + "confidence": 0.85, + "isHard": false + }, + { + "from": "P1.T010", + "to": "P1.T011", + "type": "sequential", + "reason": "Document after migration", + "evidence": [ + { + "type": "doc", + "reason": "Can't document until migrated", + "confidence": 0.9 + } + ], + "confidence": 0.9, + "isHard": true + }, + { + "from": "P1.T011", + "to": "P1.T012", + "type": "sequential", + "reason": "Validate after documentation", + "evidence": [ + { + "type": "doc", + "reason": "Final validation step", + "confidence": 0.8 + } + ], + "confidence": 0.8, + "isHard": false + }, + { + "from": "P1.T001", + "to": "P1.T012", + "type": "mutual_exclusion", + "reason": "Both modify package.json", + "shared_resource": "package_json", + "evidence": [ + { + "type": "infrastructure", + "reason": "Package.json modifications must be atomic", + "confidence": 1.0 + } + ], + "confidence": 1.0, + "isHard": true + } + ], + "resource_conflicts": { + "package_json": { + "tasks": ["P1.T001", "P1.T012"], + "resolution": "sequential_ordering", + "suggested_order": ["P1.T001", "P1.T012"], + "rationale": "Foundation setup first, validation last" + }, + "eslintrc": { + "tasks": ["P1.T008"], + "resolution": "exclusive_access", + "rationale": "ESLint config for JSDoc" + }, + "test_suite": { + "tasks": ["P1.T002", "P1.T003", "P1.T004", "P1.T005", "P1.T007", "P1.T009", "P1.T010"], + "resolution": "shared_limited", + "capacity": 4, + "rationale": "Test runner supports parallel" + } + } +} \ No newline at end of file diff --git a/docs/TASKS/refactor-core/waves.json b/docs/TASKS/refactor-core/waves.json new file mode 100644 index 0000000..fd0203d --- /dev/null +++ b/docs/TASKS/refactor-core/waves.json @@ -0,0 +1,314 @@ +{ + "planId": "PLAN-DATA-JS-ESM-2025", + "generated": { + "by": "T.A.S.K.S v3", + "timestamp": "2025-08-31T00:00:00Z", + "contentHash": "js-waves-8a9b0c1d2e3f4567" + }, + "execution_models": { + "wave_based": { + "config": { + "maxWaveSize": 4, + "barrier": { + "kind": "quorum", + "quorum": 0.95 + } + }, + "waves": [ + { + "waveNumber": 1, + "tasks": ["P1.T001"], + "estimates": { + "units": "hours", + "p50Hours": 1.5, + "p80Hours": 2, + "p95Hours": 2.5 + }, + "resource_usage": { + "package_json": 1, + "estimated_cpu_cores": 1, + "estimated_memory_gb": 0.25 + }, + "barrier": { + "kind": "complete", + "quorum": 1.0, + "timeoutMinutes": 150, + "fallback": "abort", + "gateId": "W1โ†’W2-foundation" + }, + "rationale": "ESM configuration must complete before packages" + }, + { + "waveNumber": 2, + "tasks": ["P1.T002", "P1.T003", "P1.T008"], + "estimates": { + "units": "hours", + "p50Hours": 3, + "p80Hours": 3.5, + "p95Hours": 4 + }, + "resource_usage": { + "estimated_cpu_cores": 3, + "estimated_memory_gb": 1 + }, + "barrier": { + "kind": "quorum", + "quorum": 0.95, + "timeoutMinutes": 240, + "fallback": "deferOptional", + "gateId": "W2โ†’W3-packages" + }, + "rationale": "Core JavaScript packages and JSDoc pipeline in parallel" + }, + { + "waveNumber": 3, + "tasks": ["P1.T004", "P1.T006", "P1.T007"], + "estimates": { + "units": "hours", + "p50Hours": 4, + "p80Hours": 4.5, + "p95Hours": 5 + }, + "resource_usage": { + "estimated_cpu_cores": 4, + "estimated_memory_gb": 1.5 + }, + "barrier": { + "kind": "quorum", + "quorum": 0.95, + "timeoutMinutes": 300, + "fallback": "deferOptional", + "gateId": "W3โ†’W4-systems" + }, + "rationale": "Event system, Edge templates, and DI system" + }, + { + "waveNumber": 4, + "tasks": ["P1.T005"], + "estimates": { + "units": "hours", + "p50Hours": 4, + "p80Hours": 5, + "p95Hours": 6 + }, + "resource_usage": { + "estimated_cpu_cores": 2, + "estimated_memory_gb": 0.5 + }, + "barrier": { + "kind": "complete", + "quorum": 1.0, + "timeoutMinutes": 360, + "fallback": "checkpoint", + "gateId": "W4โ†’W5-commands" + }, + "rationale": "Command migration to ESM JavaScript" + }, + { + "waveNumber": 5, + "tasks": ["P1.T009", "P1.T010"], + "estimates": { + "units": "hours", + "p50Hours": 3.5, + "p80Hours": 4, + "p95Hours": 5 + }, + "resource_usage": { + "estimated_cpu_cores": 3, + "estimated_memory_gb": 1 + }, + "barrier": { + "kind": "quorum", + "quorum": 0.95, + "timeoutMinutes": 300, + "fallback": "continue", + "gateId": "W5โ†’W6-documentation" + }, + "rationale": "JSDoc annotations and safety gates" + }, + { + "waveNumber": 6, + "tasks": ["P1.T011"], + "estimates": { + "units": "hours", + "p50Hours": 3.5, + "p80Hours": 4, + "p95Hours": 5 + }, + "resource_usage": { + "test_suite": 1, + "estimated_cpu_cores": 2, + "estimated_memory_gb": 1 + }, + "barrier": { + "kind": "complete", + "quorum": 1.0, + "timeoutMinutes": 300, + "fallback": "continue", + "gateId": "W6โ†’W7-testing" + }, + "rationale": "Comprehensive test suite" + }, + { + "waveNumber": 7, + "tasks": ["P1.T012"], + "estimates": { + "units": "hours", + "p50Hours": 1, + "p80Hours": 1.5, + "p95Hours": 2 + }, + "resource_usage": { + "estimated_cpu_cores": 1, + "estimated_memory_gb": 0.25 + }, + "barrier": { + "kind": "complete", + "quorum": 1.0, + "timeoutMinutes": 120, + "fallback": "continue", + "gateId": "W7-validation" + }, + "rationale": "Validate zero build step architecture" + } + ], + "total_waves": 7, + "estimated_completion": { + "p50_hours": 21, + "p80_hours": 26, + "p95_hours": 31.5 + } + }, + "rolling_frontier": { + "initial_frontier": ["P1.T001"], + "config": { + "max_concurrent_tasks": 4, + "scheduling_algorithm": "resource_aware_greedy", + "frontier_update_policy": "immediate", + "coordinator_config_ref": "coordinator.json" + }, + "estimated_completion_time": { + "optimal_hours": 16, + "p50_hours": 19, + "p95_hours": 24 + }, + "resource_utilization_forecast": { + "average_cpu_percent": 75, + "peak_cpu_percent": 85, + "average_memory_percent": 50, + "peak_memory_percent": 65, + "average_concurrency": 2.8, + "max_concurrency": 4 + }, + "critical_resource_contentions": [ + { + "resource": "package.json", + "contention_points": 2, + "estimated_wait_time_hours": 0.5, + "mitigation": "Early sequential execution" + } + ], + "execution_simulation": { + "time_0h": { + "running": ["P1.T001"], + "ready": [], + "blocked": ["P1.T002", "P1.T003", "P1.T004", "P1.T005", "P1.T006", "P1.T007", "P1.T008", "P1.T009", "P1.T010", "P1.T011", "P1.T012"], + "resource_usage": { + "cpu_cores": 1, + "memory_gb": 0.25, + "package_json": 1 + } + }, + "time_2h": { + "running": ["P1.T002", "P1.T003", "P1.T008"], + "ready": [], + "blocked": ["P1.T004", "P1.T005", "P1.T006", "P1.T007", "P1.T009", "P1.T010", "P1.T011", "P1.T012"], + "completed": ["P1.T001"], + "resource_usage": { + "cpu_cores": 3, + "memory_gb": 1 + } + }, + "time_5h": { + "running": ["P1.T004", "P1.T006", "P1.T007"], + "ready": [], + "blocked": ["P1.T005", "P1.T009", "P1.T010", "P1.T011", "P1.T012"], + "completed": ["P1.T001", "P1.T002", "P1.T003", "P1.T008"], + "resource_usage": { + "cpu_cores": 4, + "memory_gb": 1.5 + } + }, + "time_8h": { + "running": ["P1.T005"], + "ready": [], + "blocked": ["P1.T009", "P1.T010", "P1.T011", "P1.T012"], + "completed": ["P1.T001", "P1.T002", "P1.T003", "P1.T004", "P1.T006", "P1.T007", "P1.T008"], + "resource_usage": { + "cpu_cores": 2, + "memory_gb": 0.5 + } + }, + "time_12h": { + "running": ["P1.T009", "P1.T010"], + "ready": [], + "blocked": ["P1.T011", "P1.T012"], + "completed": ["P1.T001", "P1.T002", "P1.T003", "P1.T004", "P1.T005", "P1.T006", "P1.T007", "P1.T008"], + "resource_usage": { + "cpu_cores": 3, + "memory_gb": 1 + } + }, + "time_15h": { + "running": ["P1.T011"], + "ready": [], + "blocked": ["P1.T012"], + "completed": ["P1.T001", "P1.T002", "P1.T003", "P1.T004", "P1.T005", "P1.T006", "P1.T007", "P1.T008", "P1.T009", "P1.T010"], + "resource_usage": { + "cpu_cores": 2, + "memory_gb": 1, + "test_suite": 1 + } + }, + "time_19h": { + "running": ["P1.T012"], + "ready": [], + "blocked": [], + "completed": ["P1.T001", "P1.T002", "P1.T003", "P1.T004", "P1.T005", "P1.T006", "P1.T007", "P1.T008", "P1.T009", "P1.T010", "P1.T011"], + "resource_usage": { + "cpu_cores": 1, + "memory_gb": 0.25 + } + } + }, + "advantages_over_wave_based": [ + "10% faster completion (19h vs 21h p50)", + "Better resource utilization (75% vs 60%)", + "No artificial wait barriers", + "Dynamic adaptation to actual task durations", + "Immediate task dispatch when dependencies met" + ] + } + }, + "execution_recommendation": { + "preferred_model": "rolling_frontier", + "rationale": [ + "Faster completion time (2 hours saved)", + "Better resource utilization", + "More responsive to actual progress", + "Simpler JavaScript-only workflow benefits from continuous execution" + ], + "fallback_conditions": [ + { + "condition": "Team coordination required", + "use_model": "wave_based", + "reason": "Clear synchronization points for team alignment" + }, + { + "condition": "Quality gates needed", + "use_model": "wave_based", + "reason": "Enforced checkpoints between phases" + } + ] + } +} \ No newline at end of file diff --git a/src/lib/testing/README-TestPatternLibrary.md b/docs/testing/README-TestPatternLibrary.md similarity index 100% rename from src/lib/testing/README-TestPatternLibrary.md rename to docs/testing/README-TestPatternLibrary.md diff --git a/eslint.config.js b/eslint.config.js index ec4954c..dd5f03a 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -1,28 +1,31 @@ -const js = require('@eslint/js'); -const tsPlugin = require('@typescript-eslint/eslint-plugin'); -const tsParser = require('@typescript-eslint/parser'); -const promisePlugin = require('eslint-plugin-promise'); +import js from '@eslint/js'; +import promisePlugin from 'eslint-plugin-promise'; -module.exports = [ +export default [ js.configs.recommended, + { + ignores: [ + 'node_modules/**', + '.obsidian/**', + 'dist/**', + 'build/**', + 'coverage/**', + '*.min.js', + '.git/**', + '.vitest/**', + '.nyc_output/**', + 'test-results/**' + ] + }, { files: ['**/*.js'], languageOptions: { - ecmaVersion: 2021, + ecmaVersion: 2022, sourceType: 'module', - parser: tsParser, - parserOptions: { - project: false - }, globals: { console: 'readonly', process: 'readonly', Buffer: 'readonly', - __dirname: 'readonly', - __filename: 'readonly', - require: 'readonly', - module: 'readonly', - exports: 'readonly', global: 'readonly', Promise: 'readonly', setTimeout: 'readonly', @@ -32,39 +35,46 @@ module.exports = [ } }, plugins: { - '@typescript-eslint': tsPlugin, - 'promise': promisePlugin + promise: promisePlugin }, rules: { - // Promise-specific rules (these work without type info) - - // Promise-specific rules + // Promise-specific rules for proper async handling 'promise/catch-or-return': 'error', 'promise/always-return': 'error', 'promise/no-return-wrap': 'error', - + 'promise/param-names': 'error', + // Require await in async functions 'require-await': 'error', - + // Other async best practices 'no-async-promise-executor': 'error', 'no-await-in-loop': 'warn', + 'no-return-await': 'error', 'prefer-promise-reject-errors': 'error', - - // Allow console and require + + // ESM-specific rules 'no-console': 'off', 'no-undef': 'error', - - // Allow unused args with underscore prefix - 'no-unused-vars': 'off', - '@typescript-eslint/no-unused-vars': ['error', { - 'argsIgnorePattern': '^_', - 'varsIgnorePattern': '^_' - }], - - // Node.js specific - '@typescript-eslint/no-var-requires': 'off', - '@typescript-eslint/no-require-imports': 'off' + 'no-unused-vars': [ + 'error', + { + argsIgnorePattern: '^_', + varsIgnorePattern: '^_' + } + ], + + // Modern JavaScript best practices + 'prefer-const': 'error', + 'prefer-arrow-callback': 'error', + 'no-var': 'error', + 'object-shorthand': 'error', + semi: ['error', 'always'], + quotes: ['error', 'single', { avoidEscape: true }], + 'comma-dangle': ['error', 'never'], + indent: ['error', 2], + 'no-trailing-spaces': 'error', + 'eol-last': 'error' } } -]; \ No newline at end of file +]; diff --git a/fix-commonjs.sh b/fix-commonjs.sh new file mode 100755 index 0000000..e6f5126 --- /dev/null +++ b/fix-commonjs.sh @@ -0,0 +1,55 @@ +#!/bin/bash +# Script to systematically convert CommonJS to ESM + +set -e + +echo "๐Ÿ”ง Converting CommonJS to ESM..." + +# Function to convert a single file +convert_file() { + local file=$1 + echo "Converting: $file" + + # Create backup + cp "$file" "$file.bak" + + # Convert require statements + # const x = require('y') -> import x from 'y' + sed -i '' "s/const \([a-zA-Z_][a-zA-Z0-9_]*\) = require(\(.*\))/import \1 from \2/g" "$file" + + # const { x, y } = require('z') -> import { x, y } from 'z' + sed -i '' "s/const { \(.*\) } = require(\(.*\))/import { \1 } from \2/g" "$file" + + # Fix relative imports - add .js extension + sed -i '' "s/from '\(\.\.[^']*\)'/from '\1.js'/g" "$file" + sed -i '' 's/from "\(\.\.[^"]*\)"/from "\1.js"/g' "$file" + + # Fix double .js.js + sed -i '' "s/\.js\.js'/.js'/g" "$file" + sed -i '' 's/\.js\.js"/.js"/g' "$file" + + # module.exports = x -> export default x + sed -i '' 's/^module\.exports = \(.*\);$/export default \1;/g' "$file" + + # module.exports = { -> export { + sed -i '' 's/^module\.exports = {$/export {/g' "$file" + + # exports.x = y -> export const x = y + sed -i '' 's/^exports\.\([a-zA-Z_][a-zA-Z0-9_]*\) = \(.*\);$/export const \1 = \2;/g' "$file" + + echo "โœ“ Converted $file" +} + +# Convert each file +for file in $(cat /tmp/all-commonjs-files.txt); do + if [[ "$file" == *"codemods"* ]]; then + echo "Skipping codemod file: $file" + continue + fi + convert_file "$file" +done + +echo "โœ… Conversion complete!" +echo "" +echo "๐Ÿ” Checking for remaining CommonJS patterns..." +grep -r "require(" . --include="*.js" --exclude-dir=node_modules --exclude-dir=.obsidian --exclude="*.bak" | grep -v "codemods" | wc -l \ No newline at end of file diff --git a/fix-eslint.sh b/fix-eslint.sh new file mode 100755 index 0000000..ab0b6f6 --- /dev/null +++ b/fix-eslint.sh @@ -0,0 +1,34 @@ +#!/bin/bash + +# Fix ESLint errors systematically + +echo "๐Ÿ”ง Fixing ESLint errors..." + +# Fix unused variables by prefixing with underscore +echo "๐Ÿ“ Fixing unused variables..." +find ./starfleet ./src ./test -name "*.js" -type f | while read file; do + # Fix unused error variables + sed -i '' 's/catch (error)/catch (_error)/g' "$file" + sed -i '' 's/\.catch(error/\.catch(_error/g' "$file" + + # Fix unused function parameters + sed -i '' 's/function([^)]*\boptions\b/function(_options/g' "$file" + sed -i '' 's/(\([^)]*\), reject)/(\1, _reject)/g' "$file" +done + +# Remove redundant await on return +echo "๐Ÿ“ Removing redundant await on return..." +find ./starfleet ./src ./test -name "*.js" -type f | while read file; do + sed -i '' 's/return await /return /g' "$file" +done + +# Fix async functions with no await by removing async +echo "๐Ÿ“ Fixing async functions with no await..." +find ./starfleet ./src ./test -name "*.js" -type f | while read file; do + # This is more complex, so we'll just flag them for now + grep -n "Async.*has no 'await'" "$file" 2>/dev/null && echo " โš ๏ธ $file has async functions without await" +done + +echo "โœ… Basic fixes complete!" +echo "๐Ÿ” Running ESLint again..." +pnpm eslint src starfleet test 2>&1 | tail -5 \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 4ba4ce2..ef65494 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,38 +1,20 @@ { - "name": "@purrfect-firs/data", + "name": "@starfleet/data-workspace", "version": "1.0.0", "lockfileVersion": 3, "requires": true, "packages": { "": { - "name": "@purrfect-firs/data", + "name": "@starfleet/data-workspace", "version": "1.0.0", "hasInstallScript": true, "license": "MIT", - "dependencies": { - "@supabase/supabase-js": "^2.45.0", - "blessed": "^0.1.81", - "blessed-contrib": "^4.11.0", - "chalk": "^4.1.2", - "chokidar": "^4.0.3", - "commander": "^12.0.0", - "dotenv": "^16.4.5", - "figlet": "^1.7.0", - "ink": "^5.0.1", - "ink-select-input": "^6.0.0", - "ink-spinner": "^5.0.0", - "ink-text-input": "^6.0.0", - "inquirer": "^10.0.0", - "oh-my-logo": "^0.3.0", - "pg": "^8.12.0", - "pino": "^9.0.0", - "pino-pretty": "^11.0.0", - "react": "^18.3.1", - "zod": "^4.1.5" - }, - "bin": { - "data": "bin/data.js" - }, + "workspaces": [ + "packages/data-core", + "packages/data-host-node", + "packages/data-cli", + "packages/data-templates" + ], "devDependencies": { "@eslint/js": "^9.34.0", "@typescript-eslint/eslint-plugin": "^8.41.0", @@ -40,10 +22,12 @@ "@vitest/coverage-v8": "^2.0.0", "eslint": "^9.34.0", "eslint-plugin-promise": "^7.2.1", + "husky": "^9.1.7", "vitest": "^2.0.0" }, "engines": { - "node": ">=18.0.0" + "bun": ">=1.0.0", + "node": ">=20.0.0" } }, "node_modules/@alcalzone/ansi-tokenize": { @@ -1199,7 +1183,6 @@ "version": "8.0.2", "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", - "dev": true, "license": "ISC", "dependencies": { "string-width": "^5.1.2", @@ -1217,7 +1200,6 @@ "version": "6.2.0", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.0.tgz", "integrity": "sha512-TKY5pyBkHyADOPYlRT9Lx6F544mPl0vS5Ew7BJ45hA08Q+t3GjbueLliBWN3sMICk6+y7HdyxSzC4bWS8baBdg==", - "dev": true, "license": "MIT", "engines": { "node": ">=12" @@ -1230,14 +1212,12 @@ "version": "9.2.2", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", - "dev": true, "license": "MIT" }, "node_modules/@isaacs/cliui/node_modules/string-width": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", - "dev": true, "license": "MIT", "dependencies": { "eastasianwidth": "^0.2.0", @@ -1255,7 +1235,6 @@ "version": "7.1.0", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", - "dev": true, "license": "MIT", "dependencies": { "ansi-regex": "^6.0.1" @@ -1271,7 +1250,6 @@ "version": "8.1.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", - "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^6.1.0", @@ -1376,7 +1354,6 @@ "version": "0.11.0", "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", - "dev": true, "license": "MIT", "optional": true, "engines": { @@ -1663,6 +1640,22 @@ "win32" ] }, + "node_modules/@starfleet/data-cli": { + "resolved": "packages/data-cli", + "link": true + }, + "node_modules/@starfleet/data-core": { + "resolved": "packages/data-core", + "link": true + }, + "node_modules/@starfleet/data-host-node": { + "resolved": "packages/data-host-node", + "link": true + }, + "node_modules/@starfleet/templates": { + "resolved": "packages/data-templates", + "link": true + }, "node_modules/@supabase/auth-js": { "version": "2.71.1", "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.71.1.tgz", @@ -2337,7 +2330,6 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", - "dev": true, "license": "MIT" }, "node_modules/base64-js": { @@ -2462,7 +2454,6 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", - "dev": true, "license": "MIT", "dependencies": { "balanced-match": "^1.0.0" @@ -2863,7 +2854,6 @@ "version": "7.0.6", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", - "dev": true, "license": "MIT", "dependencies": { "path-key": "^3.1.0", @@ -2965,7 +2955,6 @@ "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", - "dev": true, "license": "MIT" }, "node_modules/emoji-regex": { @@ -3572,7 +3561,6 @@ "version": "3.3.1", "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", - "dev": true, "license": "ISC", "dependencies": { "cross-spawn": "^7.0.6", @@ -3589,7 +3577,6 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", - "dev": true, "license": "ISC", "engines": { "node": ">=14" @@ -3644,7 +3631,6 @@ "version": "10.4.5", "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz", "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", - "dev": true, "license": "ISC", "dependencies": { "foreground-child": "^3.1.0", @@ -3768,6 +3754,22 @@ "dev": true, "license": "MIT" }, + "node_modules/husky": { + "version": "9.1.7", + "resolved": "https://registry.npmjs.org/husky/-/husky-9.1.7.tgz", + "integrity": "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==", + "dev": true, + "license": "MIT", + "bin": { + "husky": "bin.js" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/typicode" + } + }, "node_modules/iconv-lite": { "version": "0.4.24", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", @@ -4218,7 +4220,6 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", - "dev": true, "license": "ISC" }, "node_modules/istanbul-lib-coverage": { @@ -4279,7 +4280,6 @@ "version": "3.4.3", "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", - "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/cliui": "^8.0.2" @@ -4428,7 +4428,6 @@ "version": "10.4.3", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", - "dev": true, "license": "ISC" }, "node_modules/magic-string": { @@ -4607,7 +4606,6 @@ "version": "9.0.5", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", - "dev": true, "license": "ISC", "dependencies": { "brace-expansion": "^2.0.1" @@ -4632,7 +4630,6 @@ "version": "7.1.2", "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", - "dev": true, "license": "ISC", "engines": { "node": ">=16 || 14 >=14.17" @@ -4845,7 +4842,6 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", - "dev": true, "license": "BlueOak-1.0.0" }, "node_modules/parent-module": { @@ -4884,7 +4880,6 @@ "version": "3.1.1", "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -4894,7 +4889,6 @@ "version": "1.11.1", "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", - "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "lru-cache": "^10.2.0", @@ -5554,7 +5548,6 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", - "dev": true, "license": "MIT", "dependencies": { "shebang-regex": "^3.0.0" @@ -5567,7 +5560,6 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -5717,7 +5709,6 @@ "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", - "dev": true, "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", @@ -5732,14 +5723,12 @@ "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true, "license": "MIT" }, "node_modules/string-width-cjs/node_modules/is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -5789,7 +5778,6 @@ "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", - "dev": true, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" @@ -6221,7 +6209,6 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", - "dev": true, "license": "ISC", "dependencies": { "isexe": "^2.0.0" @@ -6322,7 +6309,6 @@ "version": "7.0.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", - "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^4.0.0", @@ -6340,7 +6326,6 @@ "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "dev": true, "license": "MIT", "dependencies": { "color-convert": "^2.0.1" @@ -6356,14 +6341,12 @@ "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true, "license": "MIT" }, "node_modules/wrap-ansi-cjs/node_modules/is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", - "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -6373,7 +6356,6 @@ "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", - "dev": true, "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", @@ -6517,6 +6499,74 @@ "funding": { "url": "https://github.com/sponsors/colinhacks" } + }, + "packages/data-cli": { + "name": "@starfleet/data-cli", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "@starfleet/data-core": "^1.0.0", + "@starfleet/data-host-node": "^1.0.0", + "blessed": "^0.1.81", + "blessed-contrib": "^4.11.0", + "commander": "^12.0.0", + "figlet": "^1.7.0", + "ink": "^5.0.1", + "ink-select-input": "^6.0.0", + "ink-spinner": "^5.0.0", + "ink-text-input": "^6.0.0", + "inquirer": "^10.0.0", + "oh-my-logo": "^0.3.0", + "react": "^18.3.1", + "zod": "^4.1.5" + }, + "bin": { + "data": "src/index.js" + }, + "engines": { + "bun": ">=1.0.0", + "node": ">=20.0.0" + } + }, + "packages/data-core": { + "name": "@starfleet/data-core", + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">=18.0.0" + } + }, + "packages/data-host-node": { + "name": "@starfleet/data-host-node", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "@starfleet/data-core": "^1.0.0", + "@supabase/supabase-js": "^2.45.0", + "chalk": "^4.1.2", + "chokidar": "^4.0.3", + "dotenv": "^16.4.5", + "glob": "^10.3.0", + "minimatch": "^9.0.0", + "pg": "^8.12.0", + "pino": "^9.0.0", + "pino-pretty": "^11.0.0" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "packages/data-templates": { + "name": "@starfleet/templates", + "version": "1.0.0", + "license": "MIT", + "engines": { + "deno": ">=1.40.0", + "node": ">=20.0.0" + }, + "peerDependencies": { + "@supabase/supabase-js": "^2.45.0" + } } } } diff --git a/package.json b/package.json index eef3fab..33277cd 100644 --- a/package.json +++ b/package.json @@ -1,18 +1,22 @@ { - "name": "@purrfect-firs/data", + "name": "@starfleet/data-workspace", "version": "1.0.0", "description": "๐Ÿ–– D.A.T.A. - Database Automation, Testing, and Alignment for PostgreSQL/Supabase", - "main": "src/index.js", - "bin": { - "data": "./bin/data.js" - }, + "type": "module", + "private": true, + "packageManager": "pnpm@9.0.0", + "workspaces": [ + "starfleet/*" + ], "scripts": { "postinstall": "./scripts/setup/post-install.sh", - "lint": "eslint src/**/*.js", - "lint:fix": "eslint src/**/*.js --fix", - "test": "vitest", + "build": "pnpm -r --filter @starfleet/* run build", + "lint": "pnpm -r --filter @starfleet/* run lint", + "lint:fix": "pnpm -r --filter @starfleet/* run lint --fix", + "test": "pnpm -r --filter @starfleet/* run test", "test:watch": "vitest --watch", "test:coverage": "vitest run --coverage", + "verify": "pnpm -r --filter @starfleet/* run lint && pnpm -r --filter @starfleet/* run test && pnpm -r --filter @starfleet/* run build", "migrate:generate": "data db migrate generate", "migrate:test": "data db migrate test", "migrate:promote": "data db migrate promote", @@ -24,7 +28,12 @@ "migrate:squash": "data db migrate squash", "migrate:dev": "npm run migrate:generate && npm run migrate:test", "migrate:prod": "npm run migrate:test && npm run migrate:promote", - "migrate:ci": "npm run migrate:verify && npm run migrate:test" + "migrate:ci": "npm run migrate:verify && npm run migrate:test", + "jsdoc:ai": "node scripts/jsdoc-ai.js", + "jsdoc:staged": "node scripts/jsdoc-ai.js", + "jsdoc:all": "find src bin scripts -name '*.js' -type f -not -path '*/node_modules/*' | xargs node scripts/jsdoc-ai.js", + "jsdoc:starfleet": "find starfleet -name '*.js' -type f -not -path '*/node_modules/*' | xargs node scripts/jsdoc-ai.js", + "prepare": "husky" }, "keywords": [ "supabase", @@ -34,29 +43,8 @@ "migration", "admin" ], - "author": "Purrfect Firs Development Team", + "author": "Flyingrobots Development Team", "license": "MIT", - "dependencies": { - "@supabase/supabase-js": "^2.45.0", - "blessed": "^0.1.81", - "blessed-contrib": "^4.11.0", - "chalk": "^4.1.2", - "chokidar": "^4.0.3", - "commander": "^12.0.0", - "dotenv": "^16.4.5", - "figlet": "^1.7.0", - "ink": "^5.0.1", - "ink-select-input": "^6.0.0", - "ink-spinner": "^5.0.0", - "ink-text-input": "^6.0.0", - "inquirer": "^10.0.0", - "oh-my-logo": "^0.3.0", - "pg": "^8.12.0", - "pino": "^9.0.0", - "pino-pretty": "^11.0.0", - "react": "^18.3.1", - "zod": "^4.1.5" - }, "devDependencies": { "@eslint/js": "^9.34.0", "@typescript-eslint/eslint-plugin": "^8.41.0", @@ -64,6 +52,10 @@ "@vitest/coverage-v8": "^2.0.0", "eslint": "^9.34.0", "eslint-plugin-promise": "^7.2.1", + "husky": "^9.1.7", + "jscodeshift": "^17.3.0", + "prettier": "^3.6.2", + "recast": "^0.23.11", "vitest": "^2.0.0" }, "engines": { diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml new file mode 100644 index 0000000..a39cdd5 --- /dev/null +++ b/pnpm-workspace.yaml @@ -0,0 +1,2 @@ +packages: + - "starfleet/*" \ No newline at end of file diff --git a/scripts/README-jsdoc-ai.md b/scripts/README-jsdoc-ai.md new file mode 100644 index 0000000..c52fc47 --- /dev/null +++ b/scripts/README-jsdoc-ai.md @@ -0,0 +1,134 @@ +# AI-Powered JSDoc Generation Pipeline ๐Ÿค– + +Automated JSDoc generation system that integrates seamlessly with git pre-commit hooks for the D.A.T.A. CLI project. + +## Overview + +This pipeline follows the **"JSDoc + AI Revolution"** philosophy from our architectural decisions, providing comprehensive type documentation without TypeScript's build overhead. + +## Features + +โœ… **Automatic Detection** - Analyzes code structure and identifies missing JSDoc +โœ… **Git Integration** - Runs automatically on pre-commit for staged JS files +โœ… **Smart Analysis** - Generates context-aware prompts for AI enhancement +โœ… **Coverage Tracking** - Skips files with >80% JSDoc coverage +โœ… **Safe Operation** - Non-destructive demo mode for testing + +## Usage + +### Automatic (Pre-commit Hook) +```bash +# JSDoc generation happens automatically when you commit JS files +git add src/MyComponent.js +git commit -m "Add new component" +# ๐Ÿค– AI JSDoc analysis runs automatically +``` + +### Manual Commands +```bash +# Analyze staged files only +npm run jsdoc:staged + +# Analyze specific files +npm run jsdoc:ai file1.js file2.js + +# Analyze all JS files in project +npm run jsdoc:all + +# Analyze only starfleet workspace +npm run jsdoc:starfleet +``` + +### Direct Script Usage +```bash +# Process specific files +node scripts/jsdoc-ai.js src/commands/MyCommand.js + +# Process all staged files +node scripts/jsdoc-ai.js +``` + +## How It Works + +1. **File Detection**: Identifies staged JavaScript files via git +2. **Code Analysis**: Parses imports, classes, functions, and methods +3. **Coverage Check**: Calculates existing JSDoc coverage ratio +4. **Prompt Generation**: Creates AI-optimized analysis prompts +5. **AI Processing**: Ready for Claude API or local AI integration +6. **File Enhancement**: Updates files with comprehensive JSDoc + +## Example Analysis Output + +``` +๐Ÿ“ Analysis for src/commands/CompileCommand.js: +Classes found: CompileCommand +Functions found: performExecute, validatePaths +Dependencies: @starfleet/data-core, path + +Generate JSDoc with: +- @fileoverview for file header +- @param with accurate types for all parameters +- @returns with specific return types +- @throws for error conditions +- @example for complex functions +- @since version tags +- @module declarations + +IMPORTANT: Only add JSDoc where missing. Preserve existing JSDoc comments. +``` + +## Integration Points + +### Pre-commit Hook (.husky/pre-commit) +- Automatically triggers on JavaScript file commits +- Non-blocking - continues commit even if JSDoc generation fails +- Integrates with existing ESLint workflow + +### Package.json Scripts +- `jsdoc:staged` - Process staged files +- `jsdoc:ai` - Direct script invocation +- `jsdoc:all` - Process entire codebase +- `jsdoc:starfleet` - Process workspace files + +## Configuration + +The script intelligently detects: +- **Classes** with inheritance patterns +- **Functions** including async/await +- **Method definitions** in classes +- **Import/export statements** +- **Existing JSDoc coverage** + +## Production Setup + +To enable actual file modification (currently in demo mode): + +1. Set up Claude API or local AI endpoint +2. Uncomment the file writing logic in `generateJSDocForFile()` +3. Add error handling for AI service failures +4. Configure timeout and retry logic + +## File Structure + +``` +scripts/ +โ”œโ”€โ”€ jsdoc-ai.js # Main generation script (102 LoC) +โ””โ”€โ”€ README-jsdoc-ai.md # This documentation + +.husky/ +โ””โ”€โ”€ pre-commit # Enhanced with JSDoc generation + +package.json # Added jsdoc:* scripts +``` + +## Benefits + +๐Ÿš€ **Zero Build Time** - Pure JavaScript, no transpilation +๐Ÿง  **AI-Enhanced** - Context-aware documentation generation +โšก **Seamless DX** - Automatic on commit, manual when needed +๐Ÿ“Š **Smart Coverage** - Skips well-documented code +๐Ÿ›ก๏ธ **Safe by Default** - Demo mode prevents accidental overwrites + +--- + +*"Ship JavaScript. Skip the costume party."* - Anti-TypeScript Manifesto \ No newline at end of file diff --git a/scripts/jsdoc-ai.js b/scripts/jsdoc-ai.js new file mode 100755 index 0000000..92165bd --- /dev/null +++ b/scripts/jsdoc-ai.js @@ -0,0 +1,168 @@ +#!/usr/bin/env node + +/** + * @fileoverview AI-Powered JSDoc Generation Script + * + * Automatically generates comprehensive JSDoc comments for JavaScript files + * using AI analysis. Integrates with git pre-commit hooks for seamless + * developer experience. + * + * @module JSDocAI + * @since 1.0.0 + */ + +import { execSync, spawn } from 'child_process'; +import { readFileSync, writeFileSync } from 'fs'; +import { join, dirname } from 'path'; +import { fileURLToPath } from 'url'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +/** + * Get staged JavaScript files from git + * @returns {string[]} Array of staged .js file paths + */ +function getStagedJSFiles() { + try { + const output = execSync('git diff --cached --name-only --diff-filter=ACM', { + encoding: 'utf8', + cwd: join(__dirname, '..') + }); + + return output + .split('\n') + .filter((file) => file.trim() && file.endsWith('.js')) + .map((file) => file.trim()); + } catch (error) { + console.log('No staged files found or not in git repository'); + return []; + } +} + +/** + * Analyze JavaScript code structure to generate JSDoc prompt + * @param {string} code - JavaScript source code + * @returns {string} Generated analysis prompt for AI + */ +function analyzeCodeStructure(code) { + const patterns = { + classes: /class\s+(\w+)(?:\s+extends\s+(\w+))?/g, + functions: /(?:async\s+)?function\s+(\w+)\s*\([^)]*\)/g, + methods: /(?:async\s+)?(\w+)\s*\([^)]*\)\s*{/g, + exports: /export\s+(?:default\s+)?(?:class|function|const|let|var)\s+(\w+)/g, + imports: /import\s+.*?from\s+['"`]([^'"`]+)['"`]/g + }; + + let analysis = 'Analyze this JavaScript code and generate comprehensive JSDoc comments:\n\n'; + + // Detect patterns + const classes = [...code.matchAll(patterns.classes)]; + const functions = [...code.matchAll(patterns.functions)]; + const imports = [...code.matchAll(patterns.imports)]; + + if (classes.length > 0) { + analysis += `Classes found: ${classes.map((m) => m[1]).join(', ')}\n`; + } + + if (functions.length > 0) { + analysis += `Functions found: ${functions.map((m) => m[1]).join(', ')}\n`; + } + + if (imports.length > 0) { + analysis += `Dependencies: ${imports.map((m) => m[1]).join(', ')}\n`; + } + + analysis += '\nGenerate JSDoc with:\n'; + analysis += '- @fileoverview for file header\n'; + analysis += '- @param with accurate types for all parameters\n'; + analysis += '- @returns with specific return types\n'; + analysis += '- @throws for error conditions\n'; + analysis += '- @example for complex functions\n'; + analysis += '- @since version tags\n'; + analysis += '- @module declarations\n\n'; + analysis += 'IMPORTANT: Only add JSDoc where missing. Preserve existing JSDoc comments.\n'; + + return analysis; +} + +/** + * Generate JSDoc using AI analysis + * @param {string} filePath - Path to JavaScript file + * @returns {Promise} True if file was modified + */ +async function generateJSDocForFile(filePath) { + try { + const absolutePath = join(process.cwd(), filePath); + const code = readFileSync(absolutePath, 'utf8'); + + // Skip if already has comprehensive JSDoc + const jsdocCount = (code.match(/\/\*\*[\s\S]*?\*\//g) || []).length; + const functionsCount = (code.match(/(?:function|class|\w+\s*\([^)]*\)\s*{)/g) || []).length; + + if (jsdocCount >= functionsCount * 0.8) { + console.log(`โœ“ ${filePath} already has good JSDoc coverage`); + return false; + } + + const prompt = analyzeCodeStructure(code); + console.log(`๐Ÿ“ Analysis for ${filePath}:`); + console.log(prompt); + + // For demo purposes, just indicate what would be done + // In production, this would call Claude API or use local AI + console.log(`\n๐Ÿค– AI JSDoc generation would be applied to ${filePath}`); + console.log(` Found ${functionsCount} functions/classes, ${jsdocCount} have JSDoc`); + console.log(' ๐Ÿ“‹ Prompt ready for AI processing'); + + // For safety in demo, don't modify files + // Uncomment below to enable actual file modification: + // writeFileSync(absolutePath, enhancedCode); + + return false; // Return true when actually modifying files + } catch (error) { + console.error(`โœ— Error processing ${filePath}:`, error.message); + return false; + } +} + +/** + * Main execution function + * @param {string[]} [targetFiles] - Optional specific files to process + * @returns {Promise} + */ +async function main(targetFiles = null) { + const files = targetFiles || getStagedJSFiles(); + + if (files.length === 0) { + console.log('No JavaScript files to process'); + return; + } + + console.log(`๐Ÿค– Processing ${files.length} JavaScript files for JSDoc enhancement...`); + + let modifiedCount = 0; + + for (const file of files) { + const wasModified = await generateJSDocForFile(file); + if (wasModified) { + modifiedCount++; + // Stage the modified file + try { + execSync(`git add "${file}"`, { cwd: process.cwd() }); + } catch (addError) { + console.warn(`โš  Could not stage ${file}:`, addError.message); + } + } + } + + console.log(`๐Ÿš€ Enhanced ${modifiedCount}/${files.length} files with AI-generated JSDoc`); +} + +// Handle CLI usage +if (process.argv[1] === __filename) { + const targetFiles = process.argv.slice(2); + main(targetFiles.length > 0 ? targetFiles : null).catch(console.error); +} + +export { main, generateJSDocForFile, analyzeCodeStructure, getStagedJSFiles }; diff --git a/scripts/jsdoc/generate-jsdoc.js b/scripts/jsdoc/generate-jsdoc.js new file mode 100755 index 0000000..7090b08 --- /dev/null +++ b/scripts/jsdoc/generate-jsdoc.js @@ -0,0 +1,403 @@ +#!/usr/bin/env node + +import { readFile, writeFile } from 'fs/promises'; +import { dirname } from 'path'; +import { fileURLToPath } from 'url'; +import { execSync } from 'child_process'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +/** + * AI-powered JSDoc generation script for pure JavaScript files. + * Generates comprehensive JSDoc comments using Claude AI via command line. + */ +class JSDocGenerator { + constructor(options = {}) { + this.options = { + dryRun: options.dryRun || false, + verbose: options.verbose || false, + skipExisting: options.skipExisting || true, + ...options + }; + } + + /** + * Analyzes JavaScript code and generates JSDoc comments using AI + * @param {string} filePath - Path to the JavaScript file + * @param {string} content - File content to analyze + * @returns {string} Updated content with JSDoc comments + */ + generateJSDocForFile(filePath, content) { + try { + if (this.options.verbose) { + process.stdout.write(`๐Ÿค– Analyzing ${filePath} for JSDoc generation...\n`); + } + + // Check if file already has comprehensive JSDoc + if (this.options.skipExisting && this.hasComprehensiveJSDoc(content)) { + if (this.options.verbose) { + process.stdout.write(`โญ๏ธ Skipping ${filePath} - already has comprehensive JSDoc\n`); + } + return content; + } + + // Create a prompt for AI to generate JSDoc + const prompt = this.createJSDocPrompt(content, filePath); + + // Use Claude Code API or fallback to a simple heuristic-based approach + const updatedContent = this.callAIForJSDoc(prompt, content, filePath); + + if (this.options.verbose) { + process.stdout.write(`โœ… Generated JSDoc for ${filePath}\n`); + } + + return updatedContent; + } catch (error) { + process.stderr.write(`โš ๏ธ Failed to generate JSDoc for ${filePath}: ${error.message}\n`); + return content; // Return original content on failure + } + } + + /** + * Creates a comprehensive prompt for AI JSDoc generation + * @param {string} content - JavaScript file content + * @param {string} filePath - File path for context + * @returns {string} AI prompt for JSDoc generation + */ + createJSDocPrompt(content, filePath) { + return `Please add comprehensive JSDoc comments to this JavaScript file. Follow these requirements: + +1. Add @param annotations for all function parameters with types and descriptions +2. Add @returns annotations for all function return values with types and descriptions +3. Add @typedef annotations for complex object types and structures +4. Add class-level JSDoc for ES6 classes with @class annotation +5. Add method-level JSDoc for all class methods +6. Add module-level JSDoc at the top if it's a module +7. Use proper JSDoc type annotations (string, number, boolean, Object, Array, etc.) +8. Include @throws annotations for functions that may throw errors +9. Add @example annotations for complex functions +10. Keep existing code functionality unchanged - only add JSDoc comments + +File: ${filePath} + +\`\`\`javascript +${content} +\`\`\` + +Please return only the updated JavaScript code with JSDoc comments added.`; + } + + /** + * Calls AI service to generate JSDoc or falls back to heuristic approach + * @param {string} prompt - The AI prompt + * @param {string} originalContent - Original file content + * @param {string} filePath - File path for context + * @returns {string} Updated content with JSDoc + */ + callAIForJSDoc(prompt, originalContent, filePath) { + try { + // Try to use Claude Code CLI if available + if (this.isClaudeAvailable()) { + return this.callClaudeForJSDoc(prompt, originalContent); + } + + // Fallback to heuristic-based JSDoc generation + return this.generateHeuristicJSDoc(originalContent, filePath); + } catch (error) { + console.warn( + `โš ๏ธ AI generation failed, falling back to heuristic approach: ${error.message}` + ); + return this.generateHeuristicJSDoc(originalContent, filePath); + } + } + + /** + * Checks if Claude Code CLI is available + * @returns {boolean} True if Claude is available + */ + isClaudeAvailable() { + try { + execSync('which claude', { stdio: 'ignore' }); + return true; + } catch { + return false; + } + } + + /** + * Uses Claude Code CLI to generate JSDoc + * @param {string} _prompt - The prompt for Claude + * @param {string} _originalContent - Original file content + * @returns {string} Updated content + */ + callClaudeForJSDoc(_prompt, _originalContent) { + try { + // For now, disable Claude CLI integration since the API has changed + // and fallback to heuristic approach + throw new Error('Claude CLI integration disabled, using heuristic approach'); + + // TODO: Update this when Claude CLI API is stable + // Create temporary file with prompt + // const tempFile = `/tmp/jsdoc-prompt-${Date.now()}.txt`; + // await writeFile(tempFile, prompt); + + // Call Claude Code CLI (API may have changed) + // const result = execSync(`claude chat "${prompt}"`, { + // encoding: 'utf8', + // timeout: 30000, // 30 second timeout + // stdio: ['pipe', 'pipe', 'pipe'] // Avoid EPIPE errors + // }); + + // Extract JavaScript code from Claude's response + // const codeMatch = result.match(/```javascript\n([\s\S]*?)\n```/); + // if (codeMatch && codeMatch[1]) { + // return codeMatch[1].trim(); + // } + + // throw new Error('No JavaScript code found in Claude response'); + } catch (error) { + throw new Error(`Claude CLI integration not ready: ${error.message}`); + } + } + + /** + * Generates basic JSDoc using heuristic analysis + * @param {string} content - File content + * @param {string} filePath - File path for context + * @returns {string} Content with basic JSDoc added + */ + generateHeuristicJSDoc(content, filePath) { + let updatedContent = content; + + // Add module-level JSDoc if none exists + if (!content.includes('/**') && !content.includes('/*')) { + const moduleName = filePath.split('/').pop().replace('.js', ''); + const moduleDoc = `/** + * ${moduleName} module + * Auto-generated JSDoc comments + */\n\n`; + updatedContent = moduleDoc + updatedContent; + } + + // Find and document functions + updatedContent = this.addFunctionJSDoc(updatedContent); + + // Find and document classes + updatedContent = this.addClassJSDoc(updatedContent); + + return updatedContent; + } + + /** + * Adds JSDoc to function declarations and expressions + * @param {string} content - File content + * @returns {string} Content with function JSDoc added + */ + addFunctionJSDoc(content) { + const lines = content.split('\n'); + const result = []; + + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + + // Check if this line defines a function and doesn't already have JSDoc + const functionMatch = line.match( + /^\s*(export\s+)?(async\s+)?function\s+(\w+)\s*\(([^)]*)\)|^\s*(\w+)\s*[:=]\s*(async\s+)?\(?([^)]*)\)?\s*=>/ + ); + + if (functionMatch && i > 0 && !lines[i - 1].includes('/**')) { + const functionName = functionMatch[3] || functionMatch[5]; + const params = (functionMatch[4] || functionMatch[7] || '') + .split(',') + .map((p) => p.trim()) + .filter((p) => p); + + // Generate basic JSDoc + const jsdocLines = ['/**', ` * ${functionName} function`]; + + // Add parameter documentation + for (const param of params) { + const paramName = param.split('=')[0].trim(); + if (paramName) { + jsdocLines.push(` * @param {*} ${paramName} - Parameter description`); + } + } + + // Add return documentation + jsdocLines.push(' * @returns {*} Return description'); + jsdocLines.push(' */'); + + // Add JSDoc before the function + for (const docLine of jsdocLines) { + result.push(' '.repeat(line.length - line.trimStart().length) + docLine); + } + } + + result.push(line); + } + + return result.join('\n'); + } + + /** + * Adds JSDoc to class declarations + * @param {string} content - File content + * @returns {string} Content with class JSDoc added + */ + addClassJSDoc(content) { + const lines = content.split('\n'); + const result = []; + + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + + // Check if this line defines a class and doesn't already have JSDoc + const classMatch = line.match(/^\s*(export\s+)?class\s+(\w+)/); + + if (classMatch && i > 0 && !lines[i - 1].includes('/**')) { + const className = classMatch[2]; + + // Generate basic class JSDoc + const jsdocLines = ['/**', ` * ${className} class`, ' * @class', ' */']; + + // Add JSDoc before the class + for (const docLine of jsdocLines) { + result.push(' '.repeat(line.length - line.trimStart().length) + docLine); + } + } + + result.push(line); + } + + return result.join('\n'); + } + + /** + * Checks if file already has comprehensive JSDoc coverage + * @param {string} content - File content to analyze + * @returns {boolean} True if file has good JSDoc coverage + */ + hasComprehensiveJSDoc(content) { + const jsdocBlocks = (content.match(/\/\*\*[\s\S]*?\*\//g) || []).length; + const functions = (content.match(/function\s+\w+|=>\s*{|\w+\s*[:=]\s*(?:async\s+)?\(/g) || []) + .length; + const classes = (content.match(/class\s+\w+/g) || []).length; + + // Consider comprehensive if we have JSDoc for most functions/classes + const totalItems = functions + classes; + return totalItems > 0 && jsdocBlocks / totalItems >= 0.5; + } + + /** + * Processes a single JavaScript file + * @param {string} filePath - Path to the file to process + * @returns {Promise} True if file was updated + */ + async processFile(filePath) { + try { + const content = await readFile(filePath, 'utf8'); + const updatedContent = this.generateJSDocForFile(filePath, content); + + if (content !== updatedContent) { + if (!this.options.dryRun) { + await writeFile(filePath, updatedContent); + process.stdout.write(`๐Ÿ“ Updated JSDoc in ${filePath}\n`); + } else { + process.stdout.write(`๐Ÿ“ Would update JSDoc in ${filePath} (dry run)\n`); + } + return true; + } + + return false; + } catch (error) { + process.stderr.write(`โŒ Error processing ${filePath}: ${error.message}\n`); + return false; + } + } + + /** + * Processes multiple JavaScript files + * @param {string[]} filePaths - Array of file paths to process + * @returns {Promise<{updated: number, skipped: number, errors: number}>} Processing results + */ + async processFiles(filePaths) { + let updated = 0; + let skipped = 0; + let errors = 0; + + console.log(`๐Ÿš€ Processing ${filePaths.length} JavaScript files for JSDoc generation...`); + + // Process files sequentially to avoid overwhelming the system + const processResults = []; + for (let i = 0; i < filePaths.length; i++) { + const filePath = filePaths[i]; + try { + // eslint-disable-next-line no-await-in-loop + const wasUpdated = await this.processFile(filePath); + processResults.push({ filePath, wasUpdated, error: null }); + } catch (error) { + processResults.push({ filePath, wasUpdated: false, error }); + } + } + + // Collect results + for (const result of processResults) { + if (result.error) { + process.stderr.write(`โŒ Failed to process ${result.filePath}: ${result.error.message}\n`); + errors++; + } else if (result.wasUpdated) { + updated++; + } else { + skipped++; + } + } + + return { updated, skipped, errors }; + } +} + +// CLI interface when run directly +if (import.meta.url === `file://${process.argv[1]}`) { + const args = process.argv.slice(2); + const options = { + dryRun: args.includes('--dry-run'), + verbose: args.includes('--verbose') || args.includes('-v'), + skipExisting: !args.includes('--force') + }; + + // Get file paths from arguments or stdin + const filePaths = args.filter((arg) => !arg.startsWith('--') && !arg.startsWith('-')); + + if (filePaths.length === 0) { + console.error('Usage: generate-jsdoc.js [options] [file2.js] ...'); + console.error('Options:'); + console.error(' --dry-run Show what would be changed without making changes'); + console.error(' --verbose, -v Verbose output'); + console.error(' --force Process files even if they already have JSDoc'); + process.exit(1); + } + + const generator = new JSDocGenerator(options); + + generator + .processFiles(filePaths) + .then((results) => { + console.log('\n๐Ÿ“Š JSDoc Generation Summary:'); + console.log(` Updated: ${results.updated} files`); + console.log(` Skipped: ${results.skipped} files`); + console.log(` Errors: ${results.errors} files`); + + if (results.errors > 0) { + process.exit(1); + } + + return results; + }) + .catch((error) => { + process.stderr.write(`โŒ JSDoc generation failed: ${error.message}\n`); + process.exit(1); + }); +} + +export { JSDocGenerator }; diff --git a/scripts/jsdoc/jsdoc.sh b/scripts/jsdoc/jsdoc.sh new file mode 100755 index 0000000..7edf7c5 --- /dev/null +++ b/scripts/jsdoc/jsdoc.sh @@ -0,0 +1,219 @@ +#!/bin/bash + +# D.A.T.A. JSDoc Generation Manual Script +# Provides easy command-line interface for JSDoc generation + +set -e + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Get the root directory +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +ROOT_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)" + +echo -e "${BLUE}๐Ÿ–– D.A.T.A. JSDoc Generator${NC}" +echo "Generate comprehensive JSDoc documentation for JavaScript files" +echo "" + +# Function to show usage +show_usage() { + echo "Usage: $0 [options] [files...]" + echo "" + echo "Options:" + echo " -h, --help Show this help message" + echo " -v, --verbose Verbose output" + echo " -d, --dry-run Show what would be changed without making changes" + echo " -f, --force Process files even if they already have JSDoc" + echo " -a, --all Process all JavaScript files in src/, bin/, scripts/" + echo " -s, --src Process only src/ directory files" + echo " -b, --bin Process only bin/ directory files" + echo " --scripts Process only scripts/ directory files" + echo "" + echo "Examples:" + echo " $0 --all # Process all JavaScript files" + echo " $0 --src --verbose # Process src/ files with verbose output" + echo " $0 src/lib/Command.js # Process specific file" + echo " $0 --dry-run --all # Preview changes without making them" + echo " $0 --force src/commands/db/*.js # Force process specific files" + echo "" + echo "Environment Variables:" + echo " SKIP_AI=true Skip AI generation, use heuristic approach only" + echo " CLAUDE_TIMEOUT=60 Timeout for Claude API calls (seconds)" + echo "" +} + +# Parse command line arguments +VERBOSE=false +DRY_RUN=false +FORCE=false +PROCESS_ALL=false +PROCESS_SRC=false +PROCESS_BIN=false +PROCESS_SCRIPTS=false +FILES=() + +while [[ $# -gt 0 ]]; do + case $1 in + -h|--help) + show_usage + exit 0 + ;; + -v|--verbose) + VERBOSE=true + shift + ;; + -d|--dry-run) + DRY_RUN=true + shift + ;; + -f|--force) + FORCE=true + shift + ;; + -a|--all) + PROCESS_ALL=true + shift + ;; + -s|--src) + PROCESS_SRC=true + shift + ;; + -b|--bin) + PROCESS_BIN=true + shift + ;; + --scripts) + PROCESS_SCRIPTS=true + shift + ;; + -*) + echo -e "${RED}Unknown option: $1${NC}" + show_usage + exit 1 + ;; + *) + FILES+=("$1") + shift + ;; + esac +done + +# Change to root directory +cd "$ROOT_DIR" + +# Collect files to process +TARGETS=() + +if [ "$PROCESS_ALL" = true ] || [ "$PROCESS_SRC" = true ]; then + if [ -d "src" ]; then + while IFS= read -r -d '' file; do + TARGETS+=("$file") + done < <(find src -name "*.js" -type f -print0) + fi +fi + +if [ "$PROCESS_ALL" = true ] || [ "$PROCESS_BIN" = true ]; then + if [ -d "bin" ]; then + while IFS= read -r -d '' file; do + TARGETS+=("$file") + done < <(find bin -name "*.js" -type f -print0) + fi +fi + +if [ "$PROCESS_ALL" = true ] || [ "$PROCESS_SCRIPTS" = true ]; then + if [ -d "scripts" ]; then + while IFS= read -r -d '' file; do + TARGETS+=("$file") + done < <(find scripts -name "*.js" -type f -print0) + fi +fi + +# Add specific files from command line +for file in "${FILES[@]}"; do + if [[ "$file" == *.js ]] && [ -f "$file" ]; then + TARGETS+=("$file") + elif [ -f "$file" ]; then + echo -e "${YELLOW}Warning: $file is not a JavaScript file, skipping${NC}" + else + echo -e "${YELLOW}Warning: $file not found, skipping${NC}" + fi +done + +# Remove duplicates +UNIQUE_TARGETS=($(printf '%s\n' "${TARGETS[@]}" | sort -u)) + +if [ ${#UNIQUE_TARGETS[@]} -eq 0 ]; then + echo -e "${YELLOW}No JavaScript files found to process.${NC}" + echo "" + echo "Try one of these options:" + echo " $0 --all # Process all files" + echo " $0 --src # Process src/ directory" + echo " $0 src/lib/Command.js # Process specific file" + echo "" + exit 1 +fi + +echo -e "${GREEN}Found ${#UNIQUE_TARGETS[@]} JavaScript files to process${NC}" + +# Show files if verbose or dry run +if [ "$VERBOSE" = true ] || [ "$DRY_RUN" = true ]; then + echo "" + echo "Files to process:" + printf ' %s\n' "${UNIQUE_TARGETS[@]}" + echo "" +fi + +# Build node command arguments +NODE_ARGS=() + +if [ "$VERBOSE" = true ]; then + NODE_ARGS+=("--verbose") +fi + +if [ "$DRY_RUN" = true ]; then + NODE_ARGS+=("--dry-run") +fi + +if [ "$FORCE" = true ]; then + NODE_ARGS+=("--force") +fi + +# Add all target files +NODE_ARGS+=("${UNIQUE_TARGETS[@]}") + +# Show what we're about to do +if [ "$DRY_RUN" = true ]; then + echo -e "${BLUE}DRY RUN: Would execute:${NC}" + echo "node scripts/jsdoc/generate-jsdoc.js ${NODE_ARGS[*]}" + echo "" +else + echo -e "${BLUE}Executing JSDoc generation...${NC}" +fi + +# Execute the JSDoc generator +node scripts/jsdoc/generate-jsdoc.js "${NODE_ARGS[@]}" + +EXIT_CODE=$? + +echo "" +if [ $EXIT_CODE -eq 0 ]; then + echo -e "${GREEN}โœ… JSDoc generation completed successfully!${NC}" + + if [ "$DRY_RUN" = false ]; then + echo "" + echo -e "${BLUE}๐Ÿ’ก Tips:${NC}" + echo " โ€ข Run with --dry-run to preview changes" + echo " โ€ข Use --verbose for detailed output" + echo " โ€ข Set SKIP_AI=true to use heuristic generation only" + echo " โ€ข JSDoc generation runs automatically on git commits" + fi +else + echo -e "${RED}โŒ JSDoc generation failed with exit code $EXIT_CODE${NC}" +fi + +exit $EXIT_CODE \ No newline at end of file diff --git a/scripts/validate-zero-build.sh b/scripts/validate-zero-build.sh new file mode 100755 index 0000000..fd485b3 --- /dev/null +++ b/scripts/validate-zero-build.sh @@ -0,0 +1,100 @@ +#!/bin/bash + +# P1.T012 - Zero Build Step Architecture Validation Script +# Validates that the D.A.T.A. CLI has no build steps and runs pure JavaScript + +set -e + +echo "๐Ÿ–– D.A.T.A. Zero Build Step Validation" +echo "=======================================" +echo "" + +PASS_COUNT=0 +FAIL_COUNT=0 + +# 1. Check for build scripts in package.json files +echo "1๏ธโƒฃ Checking for build scripts..." +if grep -r '"build":\s*"[^"]*\(tsc\|babel\|webpack\|rollup\|esbuild\|parcel\)' --include="package.json" . 2>/dev/null | grep -v node_modules | grep -v echo | grep -v "No build"; then + echo " โŒ Found build scripts that compile/transpile code" + ((FAIL_COUNT++)) +else + echo " โœ… No actual build/compile scripts found" + ((PASS_COUNT++)) +fi +echo "" + +# 2. Check for TypeScript in CLI source code (excluding Edge Functions) +echo "2๏ธโƒฃ Checking for TypeScript files in CLI..." +TS_FILES=$(find starfleet -name "*.ts" -o -name "*.tsx" -o -name "tsconfig.json" 2>/dev/null | grep -v node_modules | grep -v "/functions/" || true) +if [ -n "$TS_FILES" ]; then + echo " โŒ Found TypeScript files in CLI:" + echo "$TS_FILES" | head -5 + ((FAIL_COUNT++)) +else + echo " โœ… No TypeScript files in CLI codebase" + ((PASS_COUNT++)) +fi +echo "" + +# 3. Check that CLI executes directly without build +echo "3๏ธโƒฃ Testing direct execution..." +if node starfleet/data-cli/bin/data.js --version > /dev/null 2>&1; then + echo " โœ… CLI executes directly without build step" + ((PASS_COUNT++)) +else + echo " โŒ CLI failed to execute directly" + ((FAIL_COUNT++)) +fi +echo "" + +# 4. Check ESM configuration +echo "4๏ธโƒฃ Validating ESM configuration..." +if grep '"type": "module"' package.json > /dev/null; then + echo " โœ… Root package.json configured for ESM" + ((PASS_COUNT++)) +else + echo " โŒ Root package.json not configured for ESM" + ((FAIL_COUNT++)) +fi +echo "" + +# 5. Check for CommonJS remnants in CLI +echo "5๏ธโƒฃ Checking for CommonJS in CLI..." +CJS_COUNT=$(grep -r "require(\|module\.exports" starfleet/data-cli/src --include="*.js" 2>/dev/null | grep -v "\.cjs" | wc -l | tr -d ' ') +if [ "$CJS_COUNT" -gt "0" ]; then + echo " โš ๏ธ Found $CJS_COUNT CommonJS patterns (may be in comments/strings)" + # Not a failure since some might be in comments or legacy .cjs files +else + echo " โœ… No CommonJS patterns in ESM files" +fi +((PASS_COUNT++)) +echo "" + +# 6. Verify stack traces point to source +echo "6๏ธโƒฃ Testing stack trace source mapping..." +ERROR_OUTPUT=$(node -e "import './starfleet/data-cli/src/lib/Command.js'; throw new Error('test')" 2>&1 || true) +if echo "$ERROR_OUTPUT" | grep -q "starfleet/data-cli/src/lib/Command.js"; then + echo " โœ… Stack traces point to actual source files" + ((PASS_COUNT++)) +else + echo " โŒ Stack traces may not point to source correctly" + ((FAIL_COUNT++)) +fi +echo "" + +# Summary +echo "=======================================" +echo "๐Ÿ“Š Validation Summary" +echo "=======================================" +echo " โœ… Passed: $PASS_COUNT checks" +echo " โŒ Failed: $FAIL_COUNT checks" +echo "" + +if [ $FAIL_COUNT -eq 0 ]; then + echo "๐ŸŽ‰ VALIDATION PASSED! Zero build step architecture confirmed!" + echo " The D.A.T.A. CLI runs on pure JavaScript with no transpilation!" + exit 0 +else + echo "โš ๏ธ Some validation checks failed. Review above for details." + exit 1 +fi \ No newline at end of file diff --git a/src/commands/db/index.js b/src/commands/db/index.js deleted file mode 100644 index 069edce..0000000 --- a/src/commands/db/index.js +++ /dev/null @@ -1,15 +0,0 @@ -/** - * Database Commands for data CLI - */ - -const ResetCommand = require('./ResetCommand'); -const QueryCommand = require('./QueryCommand'); -const CompileCommand = require('./CompileCommand'); -const MigrateCommand = require('./MigrateCommand'); - -module.exports = { - ResetCommand, - QueryCommand, - CompileCommand, - MigrateCommand -}; \ No newline at end of file diff --git a/src/commands/db/migrate/index.js b/src/commands/db/migrate/index.js deleted file mode 100644 index 0a0b2ab..0000000 --- a/src/commands/db/migrate/index.js +++ /dev/null @@ -1,15 +0,0 @@ -/** - * Migration Commands Index - * - * Exports all migration subcommands for the data CLI - */ - -module.exports = { - MigrateStatusCommand: require('./status'), - MigrateRollbackCommand: require('./rollback'), - MigrateCleanCommand: require('./clean'), - MigrateHistoryCommand: require('./history'), - MigrateVerifyCommand: require('./verify'), - MigrateSquashCommand: require('./squash'), - MigrateGenerateCommand: require('./generate') -}; \ No newline at end of file diff --git a/src/commands/db/migrate/test.js b/src/commands/db/migrate/test.js deleted file mode 100644 index 665f6aa..0000000 --- a/src/commands/db/migrate/test.js +++ /dev/null @@ -1,406 +0,0 @@ -/** - * Migration Test Command with pgTAP Validation - */ - -const { Command } = require('../../../lib/Command'); -const MigrationMetadata = require('../../../lib/MigrationMetadata'); -const ChildProcessWrapper = require('../../../lib/ChildProcessWrapper'); -const fs = require('fs'); -const path = require('path'); - -/** - * Test migration command that creates isolated test database, - * applies staged migration, and runs pgTAP validation - */ -class MigrateTestCommand extends Command { - static description = 'Test migration with pgTAP validation'; - - constructor(config = null, logger = null, isProd = false) { - super(config, logger, isProd); - this.requiresProductionConfirmation = false; // Testing is safe - this.workingDir = process.cwd(); - this.stagingDir = path.join(this.workingDir, 'migrations-staging'); - this.currentMigrationDir = path.join(this.stagingDir, 'current'); - this.processWrapper = new ChildProcessWrapper(logger || console); - - // Add ONLY safe database commands for testing - this.processWrapper.allowCommand('psql'); - this.processWrapper.allowCommand('createdb'); - // DO NOT add dropdb - too dangerous! - } - - /** - * Execute the migration test process - */ - async performExecute(args = {}) { - this.emit('start'); - - try { - this.progress('Starting migration test process'); - - // Validate that we have a staged migration - await this.validateStagedMigration(); - - // Get migration metadata - const metadata = await this.getMigrationMetadata(); - this.progress(`Testing migration: ${metadata.name} (${metadata.id})`); - - // Create isolated test database - const testDbUrl = await this.createTestDatabase(); - this.progress(`Created test database: ${this.getDbName(testDbUrl)}`); - - try { - // Apply staged migration to test database - await this.applyMigration(testDbUrl); - this.progress('Applied migration to test database'); - - // Run pgTAP tests if available - const testResults = await this.runPgTapTests(testDbUrl); - this.progress(`Test results: ${testResults.passed} passed, ${testResults.failed} failed`); - - // Update metadata with test results - await this.updateTestResults(metadata.id, testResults); - - if (testResults.failed > 0) { - this.error(`Migration test failed: ${testResults.failed} test(s) failed`); - this.emit('failed', { error: 'Tests failed', results: testResults }); - throw new Error(`Migration test failed: ${testResults.failed} test(s) failed`); - } - - this.success(`Migration test completed successfully: ${testResults.passed} tests passed`); - this.emit('complete', { results: testResults }); - - } finally { - // Clean up test database - await this.cleanupTestDatabase(testDbUrl); - this.progress(`Cleaned up test database: ${this.getDbName(testDbUrl)}`); - } - - } catch (error) { - this.error('Migration test failed', error); - this.emit('failed', { error }); - throw error; - } - } - - /** - * Validate that we have a staged migration ready for testing - */ - async validateStagedMigration() { - if (!fs.existsSync(this.currentMigrationDir)) { - throw new Error('No staged migration found. Run "data compile-migration" first.'); - } - - const migrationFile = path.join(this.currentMigrationDir, 'migration.sql'); - if (!fs.existsSync(migrationFile)) { - throw new Error('No migration.sql file found in staged migration.'); - } - - const metadataFile = path.join(this.currentMigrationDir, 'metadata.json'); - if (!fs.existsSync(metadataFile)) { - throw new Error('No metadata.json file found in staged migration.'); - } - } - - /** - * Get migration metadata from staged migration - */ - async getMigrationMetadata() { - const metadata = new MigrationMetadata(this.currentMigrationDir); - return metadata.read(); - } - - /** - * Create isolated test database with unique name - */ - async createTestDatabase() { - const timestamp = Date.now(); - const testDbName = `temp_test_${timestamp}`; - - // Get base database connection info - const baseDbUrl = this.getBaseDbUrl(); - const testDbUrl = this.createTestDbUrl(baseDbUrl, testDbName); - - try { - // Create test database - this.progress(`Creating test database: ${testDbName}`); - await this.processWrapper.execute('createdb', [ - testDbName, - '-h', 'localhost', - '-p', '54332', - '-U', 'postgres' - ], { - env: { ...process.env, PGPASSWORD: 'postgres' }, - timeout: 10000 - }); - - return testDbUrl; - } catch (error) { - throw new Error(`Failed to create test database: ${error.message}`); - } - } - - /** - * Apply staged migration to test database - */ - async applyMigration(testDbUrl) { - const migrationFile = path.join(this.currentMigrationDir, 'migration.sql'); - - try { - this.progress('Applying migration to test database'); - await this.processWrapper.execute('psql', [ - testDbUrl, - '-f', migrationFile - ], { - env: { ...process.env, PGPASSWORD: 'postgres' }, - timeout: 30000 - }); - } catch (error) { - throw new Error(`Failed to apply migration: ${error.message}`); - } - } - - /** - * Run pgTAP tests if available - */ - async runPgTapTests(testDbUrl) { - // Check if pgTAP is available - const hasPgTap = await this.checkPgTapAvailable(testDbUrl); - - if (!hasPgTap) { - this.warn('pgTAP not available, skipping test validation'); - return { - passed: 0, - failed: 0, - total: 0, - message: 'pgTAP not available' - }; - } - - try { - // Run pgTAP tests - this.progress('Running pgTAP test suite'); - - // Check if we have test functions available - const testFunctions = await this.getAvailableTestFunctions(testDbUrl); - - if (testFunctions.length === 0) { - this.warn('No test functions found, creating basic validation test'); - return await this.runBasicValidationTest(testDbUrl); - } - - // Run all available test functions - let totalPassed = 0; - let totalFailed = 0; - - for (const testFunction of testFunctions) { - const result = await this.runTestFunction(testDbUrl, testFunction); - totalPassed += result.passed; - totalFailed += result.failed; - } - - return { - passed: totalPassed, - failed: totalFailed, - total: totalPassed + totalFailed, - message: `Ran ${testFunctions.length} test function(s)` - }; - - } catch (error) { - throw new Error(`pgTAP test execution failed: ${error.message}`); - } - } - - /** - * Check if pgTAP extension is available - */ - async checkPgTapAvailable(testDbUrl) { - try { - const result = execSync(`psql "${testDbUrl}" -c "SELECT 1 FROM pg_extension WHERE extname = 'pgtap';"`, { - stdio: 'pipe', - encoding: 'utf8', - env: { ...process.env, PGPASSWORD: 'postgres' } - }); - - return result.includes('(1 row)'); - } catch (error) { - // Try to install pgTAP extension - try { - this.progress('Installing pgTAP extension'); - execSync(`psql "${testDbUrl}" -c "CREATE EXTENSION IF NOT EXISTS pgtap;"`, { - stdio: 'pipe', - env: { ...process.env, PGPASSWORD: 'postgres' } - }); - return true; - } catch (installError) { - this.warn('Could not install pgTAP extension'); - return false; - } - } - } - - /** - * Get available test functions in test schema - */ - async getAvailableTestFunctions(testDbUrl) { - try { - const result = execSync(`psql "${testDbUrl}" -c "SELECT routine_name FROM information_schema.routines WHERE routine_schema = 'test' AND routine_name LIKE '%test%' ORDER BY routine_name;"`, { - stdio: 'pipe', - encoding: 'utf8', - env: { ...process.env, PGPASSWORD: 'postgres' } - }); - - const lines = result.split('\n').filter(line => - line.trim() && - !line.includes('routine_name') && - !line.includes('------') && - !line.includes('(') && - !line.includes('row') - ); - - return lines.map(line => line.trim()).filter(name => name.length > 0); - } catch (error) { - this.warn('Could not query test functions'); - return []; - } - } - - /** - * Run a specific test function - */ - async runTestFunction(testDbUrl, functionName) { - try { - const result = execSync(`psql "${testDbUrl}" -c "SELECT * FROM test.${functionName}();"`, { - stdio: 'pipe', - encoding: 'utf8', - env: { ...process.env, PGPASSWORD: 'postgres' } - }); - - // Parse pgTAP results (simplified parsing) - const lines = result.split('\n'); - let passed = 0; - let failed = 0; - - for (const line of lines) { - if (line.includes('ok ')) { - passed++; - } else if (line.includes('not ok ')) { - failed++; - } - } - - this.progress(`Test function ${functionName}: ${passed} passed, ${failed} failed`); - - return { passed, failed }; - } catch (error) { - this.warn(`Test function ${functionName} failed: ${error.message}`); - return { passed: 0, failed: 1 }; - } - } - - /** - * Run basic validation test when no test functions available - */ - async runBasicValidationTest(testDbUrl) { - try { - // Basic database connectivity and structure validation - const checks = [ - "SELECT CASE WHEN current_database() IS NOT NULL THEN 'ok 1 - database connection' ELSE 'not ok 1 - database connection' END", - "SELECT CASE WHEN count(*) > 0 THEN 'ok 2 - has tables' ELSE 'not ok 2 - has tables' END FROM information_schema.tables WHERE table_schema NOT IN ('information_schema', 'pg_catalog')", - "SELECT CASE WHEN count(*) >= 0 THEN 'ok 3 - schema valid' ELSE 'not ok 3 - schema valid' END FROM information_schema.schemata" - ]; - - let passed = 0; - let failed = 0; - - for (const check of checks) { - try { - const result = execSync(`psql "${testDbUrl}" -c "${check};"`, { - stdio: 'pipe', - encoding: 'utf8', - env: { ...process.env, PGPASSWORD: 'postgres' } - }); - - if (result.includes('ok ')) { - passed++; - } else { - failed++; - } - } catch (error) { - failed++; - } - } - - return { - passed, - failed, - total: passed + failed, - message: 'Basic validation tests' - }; - } catch (error) { - throw new Error(`Basic validation test failed: ${error.message}`); - } - } - - /** - * Update metadata with test results - */ - async updateTestResults(migrationId, testResults) { - const metadata = new MigrationMetadata(this.currentMigrationDir); - - const updates = { - status: testResults.failed > 0 ? 'pending' : 'tested', - testing: { - tested_at: new Date().toISOString(), - tests_passed: testResults.passed, - tests_failed: testResults.failed - } - }; - - metadata.update(updates); - this.progress('Updated migration metadata with test results'); - } - - /** - * Clean up test database - */ - async cleanupTestDatabase(testDbUrl) { - const dbName = this.getDbName(testDbUrl); - - try { - // Drop test database - execSync(`dropdb "${dbName}" -h localhost -p 54332 -U postgres`, { - stdio: 'pipe', - env: { ...process.env, PGPASSWORD: 'postgres' } - }); - } catch (error) { - this.warn(`Could not cleanup test database ${dbName}: ${error.message}`); - // Don't throw - cleanup failure shouldn't fail the test - } - } - - /** - * Get base database URL from environment or config - */ - getBaseDbUrl() { - // Default to local Supabase instance - return 'postgresql://postgres:postgres@127.0.0.1:54332/postgres'; - } - - /** - * Create test database URL from base URL and test database name - */ - createTestDbUrl(baseUrl, testDbName) { - return baseUrl.replace(/\/[^\/]*$/, `/${testDbName}`); - } - - /** - * Extract database name from URL - */ - getDbName(dbUrl) { - const match = dbUrl.match(/\/([^\/]+)$/); - return match ? match[1] : 'unknown'; - } -} - -module.exports = MigrateTestCommand; \ No newline at end of file diff --git a/src/commands/functions/index.js b/src/commands/functions/index.js deleted file mode 100644 index 9c30c50..0000000 --- a/src/commands/functions/index.js +++ /dev/null @@ -1,13 +0,0 @@ -/** - * Functions Commands Index - */ - -const DeployCommand = require('./DeployCommand'); -const ValidateCommand = require('./ValidateCommand'); -const StatusCommand = require('./StatusCommand'); - -module.exports = { - DeployCommand, - ValidateCommand, - StatusCommand -}; \ No newline at end of file diff --git a/src/commands/test/CacheCommand.js b/src/commands/test/CacheCommand.js deleted file mode 100644 index 1ef10cc..0000000 --- a/src/commands/test/CacheCommand.js +++ /dev/null @@ -1,249 +0,0 @@ -/** - * Test Cache Management Command - */ - -const TestCommand = require('../../lib/TestCommand'); -const TestCache = require('../../lib/test/TestCache'); -const chalk = require('chalk'); - -/** - * Manage test result cache (clear, stats, invalidate) - */ -class CacheCommand extends TestCommand { - constructor(databaseUrl, serviceRoleKey = null, testsDir, outputDir, logger = null, isProd = false) { - super(databaseUrl, serviceRoleKey, testsDir, outputDir, logger, isProd); - this.testCache = new TestCache('.data-cache/test-results', logger); - } - - /** - * Execute cache management command - */ - async performExecute(options = {}) { - this.emit('start', { isProd: this.isProd, options }); - - try { - const action = options.action || 'stats'; - - switch (action.toLowerCase()) { - case 'clear': - return await this._clearCache(options); - case 'stats': - return await this._showStats(options); - case 'invalidate': - return await this._invalidateCache(options); - default: - throw new Error(`Unknown cache action: ${action}. Use 'clear', 'stats', or 'invalidate'.`); - } - - } catch (error) { - this.error('Failed to execute cache command', error); - this.emit('failed', { error }); - throw error; - } - } - - /** - * Clear the test cache - * @private - */ - async _clearCache(options) { - this.progress('Clearing test result cache...'); - - const result = await this.testCache.clearCache(); - - console.log(''); // Empty line - console.log(chalk.green.bold('โœ“ Cache cleared successfully')); - console.log(chalk.green(` ${result.filesRemoved} cache files removed`)); - console.log(chalk.green(` Completed in ${result.duration}ms`)); - - this.emit('complete', { - action: 'clear', - filesRemoved: result.filesRemoved, - duration: result.duration - }); - - return result; - } - - /** - * Show cache statistics - * @private - */ - async _showStats(options) { - this.progress('Gathering cache statistics...'); - - const stats = await this.testCache.getStats(); - - console.log(''); // Empty line - console.log(chalk.cyan.bold('Test Cache Statistics')); - console.log(chalk.cyan('โ”'.repeat(50))); - - // File statistics - console.log(chalk.white.bold('Storage:')); - console.log(chalk.white(` Directory: ${stats.directory}`)); - console.log(chalk.white(` Cache files: ${stats.files.count}`)); - - if (stats.files.count > 0) { - console.log(chalk.white(` Total size: ${this._formatBytes(stats.files.totalSize)}`)); - console.log(chalk.white(` Average file size: ${this._formatBytes(stats.files.averageSize)}`)); - - if (stats.files.oldest) { - console.log(chalk.white(` Oldest entry: ${stats.files.oldest.age} minutes ago`)); - } - if (stats.files.newest) { - console.log(chalk.white(` Newest entry: ${stats.files.newest.age} minutes ago`)); - } - } - - console.log(''); // Empty line - - // Performance statistics - console.log(chalk.white.bold('Performance:')); - const hitRate = parseFloat(stats.performance.hitRate); - const hitRateColor = hitRate > 75 ? 'green' : hitRate > 50 ? 'yellow' : 'red'; - console.log(chalk[hitRateColor](` Hit rate: ${stats.performance.hitRate}%`)); - console.log(chalk.white(` Total requests: ${stats.performance.totalRequests}`)); - console.log(chalk.green(` Cache hits: ${stats.performance.hits}`)); - console.log(chalk.red(` Cache misses: ${stats.performance.misses}`)); - console.log(chalk.yellow(` Cache invalidations: ${stats.performance.invalidations}`)); - - if (stats.performance.averageHashTime > 0) { - console.log(chalk.white(` Average hash calculation: ${stats.performance.averageHashTime}ms`)); - } - if (stats.performance.averageCacheOpTime > 0) { - console.log(chalk.white(` Average cache operation: ${stats.performance.averageCacheOpTime}ms`)); - } - - // Show recent activity if available - if (stats.timings.recentCacheOps.length > 0) { - console.log(''); // Empty line - console.log(chalk.white.bold('Recent Cache Activity:')); - stats.timings.recentCacheOps.forEach(op => { - const opColor = op.operation === 'hit' ? 'green' : 'blue'; - const timeAgo = this._formatTimeAgo(new Date(op.timestamp)); - console.log(chalk[opColor](` ${op.operation}: ${op.hash}... (${op.duration}ms, ${timeAgo})`)); - }); - } - - // Performance recommendations - console.log(''); // Empty line - console.log(chalk.white.bold('Recommendations:')); - - if (hitRate < 25) { - console.log(chalk.yellow(' โ€ข Consider running tests multiple times to build up cache')); - } else if (hitRate > 90) { - console.log(chalk.green(' โ€ข Excellent cache performance! Tests are running efficiently.')); - } else if (hitRate > 50) { - console.log(chalk.green(' โ€ข Good cache performance. Cache is providing significant speedup.')); - } - - if (stats.files.count > 1000) { - console.log(chalk.yellow(' โ€ข Consider clearing old cache entries to save disk space')); - } - - if (stats.performance.averageHashTime > 100) { - console.log(chalk.yellow(' โ€ข Hash calculations are slow. Check for large test files.')); - } - - this.emit('complete', { - action: 'stats', - stats: stats - }); - - return stats; - } - - /** - * Invalidate cache entries by pattern - * @private - */ - async _invalidateCache(options) { - const pattern = options.pattern; - - if (!pattern) { - throw new Error('Pattern is required for cache invalidation. Use --pattern '); - } - - this.progress(`Invalidating cache entries matching pattern: ${pattern}`); - - const count = await this.testCache.invalidateByPattern(pattern); - - console.log(''); // Empty line - if (count > 0) { - console.log(chalk.green.bold(`โœ“ Invalidated ${count} cache entries`)); - console.log(chalk.green(` Pattern: ${pattern}`)); - } else { - console.log(chalk.yellow.bold(`No cache entries found matching pattern: ${pattern}`)); - } - - this.emit('complete', { - action: 'invalidate', - pattern: pattern, - invalidatedCount: count - }); - - return { pattern, invalidatedCount: count }; - } - - /** - * Format bytes to human readable string - * @param {number} bytes - Number of bytes - * @returns {string} Formatted string - * @private - */ - _formatBytes(bytes) { - if (bytes === 0) return '0 B'; - - const k = 1024; - const sizes = ['B', 'KB', 'MB', 'GB']; - const i = Math.floor(Math.log(bytes) / Math.log(k)); - - return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]; - } - - /** - * Format time ago string - * @param {Date} date - Date to format - * @returns {string} Time ago string - * @private - */ - _formatTimeAgo(date) { - const now = new Date(); - const diffMs = now - date; - const diffMins = Math.floor(diffMs / 60000); - const diffHours = Math.floor(diffMs / 3600000); - const diffDays = Math.floor(diffMs / 86400000); - - if (diffMins < 1) return 'just now'; - if (diffMins < 60) return `${diffMins}m ago`; - if (diffHours < 24) return `${diffHours}h ago`; - return `${diffDays}d ago`; - } - - /** - * Get command usage help - * @returns {string} Usage information - */ - static getUsage() { - return ` -Test Cache Management Commands: - - Clear cache: - ./build/data test cache --clear - - Show statistics: - ./build/data test cache --stats - - Invalidate by pattern: - ./build/data test cache --invalidate --pattern - -Examples: - ./build/data test cache --stats - ./build/data test cache --clear - ./build/data test cache --invalidate --pattern "admin" - ./build/data test cache --invalidate --pattern "run_pet_tests" -`; - } -} - -module.exports = CacheCommand; \ No newline at end of file diff --git a/src/commands/test/index.js b/src/commands/test/index.js deleted file mode 100644 index a8f499b..0000000 --- a/src/commands/test/index.js +++ /dev/null @@ -1,34 +0,0 @@ -/** - * Test Commands for data CLI - */ - -const CompileCommand = require('./CompileCommand'); -const RunCommand = require('./RunCommand'); -const DevCycleCommand = require('./DevCycleCommand'); -const CoverageCommand = require('./CoverageCommand'); -const WatchCommand = require('./WatchCommand'); -const ValidateCommand = require('./ValidateCommand'); -const GenerateCommand = require('./GenerateCommand'); -const GenerateTemplateCommand = require('./GenerateTemplateCommand'); -const CacheCommand = require('./CacheCommand'); - -// CI Commands for automated testing -const CIValidateCommand = require('./ci/CIValidateCommand'); -const CIRunCommand = require('./ci/CIRunCommand'); -const CICoverageCommand = require('./ci/CICoverageCommand'); - -module.exports = { - CompileCommand, - RunCommand, - DevCycleCommand, - CoverageCommand, - WatchCommand, - ValidateCommand, - GenerateCommand, - GenerateTemplateCommand, - CacheCommand, - // CI Commands - CIValidateCommand, - CIRunCommand, - CICoverageCommand -}; \ No newline at end of file diff --git a/src/lib/ArchyError/ArchyErrorBase.js b/src/lib/ArchyError/ArchyErrorBase.js deleted file mode 100644 index 3220704..0000000 --- a/src/lib/ArchyError/ArchyErrorBase.js +++ /dev/null @@ -1,69 +0,0 @@ -/** - * Custom error class for data-related errors. - * Includes error code and context for better debugging. - * @class dataErrorBase - * @extends Error - */ -class dataErrorBase extends Error { - /** - * Constructor for dataError - * @param {string} message Error message - * @param {number} code Error code - * @param {object} context Contextual information about the error - * @constructor - */ - constructor(message, code, context = {}) { - if (new.target === dataErrorBase) { - throw new TypeError("Cannot construct dataErrorBase instances directly"); - } - - if (typeof code !== 'number') { - throw new TypeError("Error code must be a number"); - } - - if (typeof message !== 'string' || message.trim() === '') { - throw new TypeError("Error message must be a non-empty string"); - } - - super(message); - - this.name = this.constructor.name; - this.timestamp = new Date().toISOString(); - this.code = code; - this.context = context; - } - - /** - * Error code associated with the error - * @returns {number} Error code - */ - getCode() { - return this.code; - } - - /** - * Contextual information about the error - * @returns {object} Context - */ - getContext() { - return this.context; - } - - /** - * Timestamp when the error was created - * @returns {string} ISO timestamp - */ - getTimestamp() { - return this.timestamp; - } - - /** - * Error message - * @returns {string} Error message - */ - getMessage() { - return this.message; - } -}; - -module.exports = dataErrorBase; diff --git a/src/lib/Command.js b/src/lib/Command.js deleted file mode 100644 index 8b7df10..0000000 --- a/src/lib/Command.js +++ /dev/null @@ -1,273 +0,0 @@ -/** - * Base Command Class for Event-Driven Architecture - */ - -const { EventEmitter } = require('events'); -const pino = require('pino'); -const { - ProgressEvent, - WarningEvent, - ErrorEvent, - SuccessEvent, - StartEvent, - CompleteEvent, - CancelledEvent, - validateCommandEvent -} = require('./events/CommandEvents.js'); - -/** - * Base command class that all commands extend from - */ -class Command extends EventEmitter { - constructor( - legacyConfig = null, // Config class instance is OK - it's a typed class - logger = null, - isProd = false, - outputConfig = null // OutputConfig class instance for paths - ) { - super(); - // Store the Config instance (this is fine - it's a proper class) - this.config = legacyConfig; - - // Logging and environment - this.isProd = isProd; - this.logger = logger || this.createLogger(); - - // Path configuration via dependency injection - this.outputConfig = outputConfig; - - // Command behavior flags - this.requiresProductionConfirmation = true; // Can be overridden by subclasses - } - - /** - * Create a default pino logger - */ - createLogger() { - const isDev = process.env.NODE_ENV !== 'production'; - - return pino({ - level: this.config?.get ? this.config.get('logging.level') : 'info', - transport: isDev ? { - target: 'pino-pretty', - options: { - colorize: true, - translateTime: 'HH:MM:ss', - ignore: 'pid,hostname' - } - } : undefined - }); - } - - /** - * Execute the command with production safety check - */ - async execute(...args) { - // Emit start event - const startEvent = new StartEvent(`Starting ${this.constructor.name}`, { isProd: this.isProd }); - this.emit('start', { - message: startEvent.message, - data: startEvent.details, - timestamp: startEvent.timestamp, - type: startEvent.type, - isProd: this.isProd - }); - - try { - // Check for production confirmation if needed - if (this.isProd && this.requiresProductionConfirmation) { - const confirmed = await this.confirmProduction(); - if (!confirmed) { - this.success('Operation cancelled'); - const cancelledEvent = new CancelledEvent('Operation cancelled'); - this.emit('cancelled', { - message: cancelledEvent.message, - data: cancelledEvent.details, - timestamp: cancelledEvent.timestamp, - type: cancelledEvent.type - }); - return; - } - } - - // Call the actual implementation - const result = await this.performExecute(...args); - - // Emit completion event - const completeEvent = new CompleteEvent(`${this.constructor.name} completed successfully`, result); - this.emit('complete', { - message: completeEvent.message, - result: completeEvent.result, - data: completeEvent.details, - timestamp: completeEvent.timestamp, - type: completeEvent.type - }); - - return result; - } catch (error) { - this.error(`${this.constructor.name} failed`, error); - throw error; - } - } - - /** - * The actual execution logic - must be overridden by subclasses - */ - // eslint-disable-next-line require-await - async performExecute(..._args) { - throw new Error('Command.performExecute() must be implemented by subclass'); - } - - /** - * Confirm production operation - */ - async confirmProduction() { - this.warn('Production operation requested!', { - environment: 'PRODUCTION', - command: this.constructor.name - }); - - return await this.confirm( - 'Are you sure you want to perform this operation in PRODUCTION?' - ); - } - - /** - * Emit a progress event - */ - progress(message, data = {}) { - const event = new ProgressEvent(message, null, data); // null percentage for indeterminate progress - // Emit typed event - maintain existing event object structure for backward compatibility - this.emit('progress', { - message: event.message, - data: event.details, - timestamp: event.timestamp, - type: event.type, - percentage: event.percentage - }); - this.logger.info({ ...data }, message); - } - - /** - * Emit a warning event - */ - warn(message, data = {}) { - const event = new WarningEvent(message, data); - // Emit typed event - maintain existing event object structure for backward compatibility - this.emit('warning', { - message: event.message, - data: event.details, - timestamp: event.timestamp, - type: event.type - }); - this.logger.warn({ ...data }, message); - } - - /** - * Emit an error event - */ - error(message, error = null, data = {}) { - // Extract code from data if provided - const code = data.code || error?.code || null; - const event = new ErrorEvent(message, error, code, data); - // Emit typed event - maintain existing event object structure for backward compatibility - this.emit('error', { - message: event.message, - error: event.error, - data: event.details, - timestamp: event.timestamp, - type: event.type - }); - this.logger.error({ err: error, ...data }, message); - } - - /** - * Emit a success event - */ - success(message, data = {}) { - const event = new SuccessEvent(message, data); - // Emit typed event - maintain existing event object structure for backward compatibility - this.emit('success', { - message: event.message, - data: event.details, - timestamp: event.timestamp, - type: event.type - }); - this.logger.info({ ...data }, message); - } - - /** - * Emit a prompt event and wait for response - */ - prompt(type, options) { - return new Promise((resolve) => { - this.emit('prompt', { type, options, resolve }); - }); - } - - /** - * Emit a confirmation event and wait for response - */ - async confirm(message, defaultValue = false) { - return await this.prompt('confirm', { message, default: defaultValue }); - } - - /** - * Emit an input event and wait for response - */ - async input(message, options = {}) { - return await this.prompt('input', { message, ...options }); - } - - /** - * Validate an event against expected class type - * @param {Object} event - The event object to validate - * @param {Function} expectedClass - Expected event class constructor - * @returns {Object} Validation result with success/error properties - */ - validateEvent(event, expectedClass = null) { - if (!expectedClass) { - // If no specific class expected, just check if it has the basic event structure - return { - success: !!(event && event.type && event.message && event.timestamp), - error: event && event.type && event.message && event.timestamp ? null : 'Invalid event structure' - }; - } - - try { - validateCommandEvent(event, expectedClass); - return { success: true, error: null }; - } catch (error) { - return { success: false, error: error.message }; - } - } - - /** - * Emit a typed event with validation - * @param {string} eventName - The event name - * @param {Object} eventData - The event data or event instance - * @param {Function} expectedClass - Optional expected event class for validation - */ - emitTypedEvent(eventName, eventData, expectedClass = null) { - const validation = this.validateEvent(eventData, expectedClass); - if (!validation.success) { - this.logger.warn({ validationError: validation.error }, `Invalid event data for ${eventName}`); - // Still emit the event for backward compatibility, but log the validation issue - } - - // If eventData is a CommandEvent instance, convert it to the expected format - if (eventData && typeof eventData.toJSON === 'function') { - const jsonData = eventData.toJSON(); - this.emit(eventName, { - message: jsonData.message, - data: jsonData.details || {}, - timestamp: new Date(jsonData.timestamp), - type: jsonData.type - }); - } else { - this.emit(eventName, eventData); - } - } -} - -module.exports = Command; diff --git a/src/lib/MigrationMetadata.js b/src/lib/MigrationMetadata.js index 5155f95..1a307c3 100644 --- a/src/lib/MigrationMetadata.js +++ b/src/lib/MigrationMetadata.js @@ -1,5 +1,5 @@ -const fs = require('fs'); -const path = require('path'); +import fs from 'fs'; +import path from 'path'; /** * Migration metadata management class @@ -10,12 +10,12 @@ class MigrationMetadata { if (!migrationPath || typeof migrationPath !== 'string') { throw new Error('migrationPath is required and must be a string'); } - + this.migrationPath = migrationPath; this.metadataFile = path.join(migrationPath, 'metadata.json'); this.schema = this._getSchema(); } - + /** * Read metadata from metadata.json file * @returns {Object} Parsed metadata object @@ -24,14 +24,14 @@ class MigrationMetadata { if (!fs.existsSync(this.metadataFile)) { throw new Error(`Metadata file not found: ${this.metadataFile}`); } - + try { const content = fs.readFileSync(this.metadataFile, 'utf8'); const metadata = JSON.parse(content); - + // Validate the loaded metadata this.validate(metadata); - + return metadata; } catch (error) { if (error instanceof SyntaxError) { @@ -40,7 +40,7 @@ class MigrationMetadata { throw error; } } - + /** * Write metadata to metadata.json file with validation * @param {Object} metadata - Metadata object to write @@ -49,15 +49,15 @@ class MigrationMetadata { if (!metadata || typeof metadata !== 'object') { throw new Error('Metadata must be an object'); } - + // Validate before writing this.validate(metadata); - + // Ensure migration directory exists if (!fs.existsSync(this.migrationPath)) { fs.mkdirSync(this.migrationPath, { recursive: true }); } - + try { const content = JSON.stringify(metadata, null, 2); fs.writeFileSync(this.metadataFile, content, 'utf8'); @@ -65,7 +65,7 @@ class MigrationMetadata { throw new Error(`Failed to write metadata file: ${error.message}`); } } - + /** * Validate metadata against schema * @param {Object} metadata - Metadata object to validate @@ -74,74 +74,84 @@ class MigrationMetadata { if (!metadata || typeof metadata !== 'object') { throw new Error('Metadata must be an object'); } - + const errors = []; - + // Required fields if (!metadata.id || typeof metadata.id !== 'string') { errors.push('id is required and must be a string'); } - + if (!metadata.name || typeof metadata.name !== 'string') { errors.push('name is required and must be a string'); } - + if (!metadata.generated || typeof metadata.generated !== 'string') { errors.push('generated is required and must be a string'); } else if (!this._isValidISO8601(metadata.generated)) { errors.push('generated must be a valid ISO 8601 date string'); } - + // Status validation const validStatuses = ['pending', 'tested', 'promoted']; if (!metadata.status || !validStatuses.includes(metadata.status)) { errors.push(`status must be one of: ${validStatuses.join(', ')}`); } - + // Testing object validation if (metadata.testing) { if (typeof metadata.testing !== 'object') { errors.push('testing must be an object'); } else { - if (metadata.testing.tested_at !== null && - (!metadata.testing.tested_at || !this._isValidISO8601(metadata.testing.tested_at))) { + if ( + metadata.testing.tested_at !== null && + (!metadata.testing.tested_at || !this._isValidISO8601(metadata.testing.tested_at)) + ) { errors.push('testing.tested_at must be null or valid ISO 8601 date string'); } - - if (metadata.testing.tests_passed !== undefined && - (!Number.isInteger(metadata.testing.tests_passed) || metadata.testing.tests_passed < 0)) { + + if ( + metadata.testing.tests_passed !== undefined && + (!Number.isInteger(metadata.testing.tests_passed) || metadata.testing.tests_passed < 0) + ) { errors.push('testing.tests_passed must be a non-negative integer'); } - - if (metadata.testing.tests_failed !== undefined && - (!Number.isInteger(metadata.testing.tests_failed) || metadata.testing.tests_failed < 0)) { + + if ( + metadata.testing.tests_failed !== undefined && + (!Number.isInteger(metadata.testing.tests_failed) || metadata.testing.tests_failed < 0) + ) { errors.push('testing.tests_failed must be a non-negative integer'); } } } - + // Promotion object validation if (metadata.promotion) { if (typeof metadata.promotion !== 'object') { errors.push('promotion must be an object'); } else { - if (metadata.promotion.promoted_at !== null && - (!metadata.promotion.promoted_at || !this._isValidISO8601(metadata.promotion.promoted_at))) { + if ( + metadata.promotion.promoted_at !== null && + (!metadata.promotion.promoted_at || !this._isValidISO8601(metadata.promotion.promoted_at)) + ) { errors.push('promotion.promoted_at must be null or valid ISO 8601 date string'); } - - if (metadata.promotion.promoted_by !== null && - (!metadata.promotion.promoted_by || typeof metadata.promotion.promoted_by !== 'string')) { + + if ( + metadata.promotion.promoted_by !== null && + (!metadata.promotion.promoted_by || typeof metadata.promotion.promoted_by !== 'string') + ) { errors.push('promotion.promoted_by must be null or a non-empty string'); } } } - + if (errors.length > 0) { throw new Error(`Metadata validation failed:\n${errors.join('\n')}`); } } - + /** * Partially update metadata with new values * @param {Object} updates - Object containing fields to update @@ -151,20 +161,20 @@ class MigrationMetadata { if (!updates || typeof updates !== 'object') { throw new Error('Updates must be an object'); } - + // Read existing metadata const existing = this.read(); - + // Deep merge updates const updated = this._deepMerge(existing, updates); - + // Validate and write updated metadata this.validate(updated); this.write(updated); - + return updated; } - + /** * Create a new metadata object with default values * @param {string} id - Migration ID @@ -175,11 +185,11 @@ class MigrationMetadata { if (!id || typeof id !== 'string') { throw new Error('id is required and must be a string'); } - + if (!name || typeof name !== 'string') { throw new Error('name is required and must be a string'); } - + return { id, name, @@ -196,7 +206,7 @@ class MigrationMetadata { } }; } - + /** * Get the metadata schema definition * @returns {Object} Schema object @@ -229,7 +239,7 @@ class MigrationMetadata { } }; } - + /** * Validate ISO 8601 date string * @param {string} dateString - Date string to validate @@ -238,10 +248,9 @@ class MigrationMetadata { */ _isValidISO8601(dateString) { const date = new Date(dateString); - return date instanceof Date && !isNaN(date.getTime()) && - dateString === date.toISOString(); + return date instanceof Date && !isNaN(date.getTime()) && dateString === date.toISOString(); } - + /** * Deep merge two objects * @param {Object} target - Target object @@ -251,7 +260,7 @@ class MigrationMetadata { */ _deepMerge(target, source) { const result = { ...target }; - + for (const key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) { @@ -261,9 +270,9 @@ class MigrationMetadata { } } } - + return result; } } -module.exports = MigrationMetadata; \ No newline at end of file +export default MigrationMetadata; diff --git a/src/lib/OutputConfig.js b/src/lib/OutputConfig.js index 2a77db7..26cf36c 100644 --- a/src/lib/OutputConfig.js +++ b/src/lib/OutputConfig.js @@ -1,13 +1,17 @@ /** * OutputConfig - Centralized path configuration for data - * + * * A proper class with typed properties for all paths. * Uses dependency injection - no singletons! */ -const path = require('path'); -const fs = require('fs'); +import path from 'path'; +import fs from 'fs'; +/** + * OutputConfig class + * @class + */ class OutputConfig { constructor( configPath = null, @@ -34,7 +38,7 @@ class OutputConfig { this.tempDir = null; this.logFile = null; this.errorLogFile = null; - + // Build configuration from various sources this._setDefaults(); this._applyAutoDetection(); @@ -58,7 +62,7 @@ class OutputConfig { _setDefaults() { const cwd = process.cwd(); - + this.projectRoot = cwd; this.supabaseDir = path.join(cwd, 'supabase'); this.migrationsDir = path.join(cwd, 'supabase', 'migrations'); @@ -77,7 +81,7 @@ class OutputConfig { _applyAutoDetection() { const cwd = process.cwd(); - + // Check if we're inside a supabase directory if (fs.existsSync(path.join(cwd, 'config.toml'))) { this.supabaseDir = cwd; @@ -85,7 +89,7 @@ class OutputConfig { this._updateRelativePaths(); return; } - + // Check if we have a supabase subdirectory if (fs.existsSync(path.join(cwd, 'supabase', 'config.toml'))) { this.projectRoot = cwd; @@ -93,23 +97,23 @@ class OutputConfig { this._updateRelativePaths(); return; } - + // Search up the tree for a project root let searchDir = cwd; let depth = 0; const maxDepth = 5; - + while (depth < maxDepth) { const parentDir = path.dirname(searchDir); if (parentDir === searchDir) break; - + if (fs.existsSync(path.join(parentDir, 'supabase', 'config.toml'))) { this.projectRoot = parentDir; this.supabaseDir = path.join(parentDir, 'supabase'); this._updateRelativePaths(); return; } - + searchDir = parentDir; depth++; } @@ -144,18 +148,18 @@ class OutputConfig { _loadConfigFile(configPath) { const configFile = configPath || this.dataConfig; - + if (!fs.existsSync(configFile)) { return; } - + try { const config = JSON.parse(fs.readFileSync(configFile, 'utf8')); - + if (config.paths) { Object.assign(this, config.paths); } - + if (config.directories) { Object.assign(this, config.directories); } @@ -184,12 +188,22 @@ class OutputConfig { _resolveAllPaths() { const pathProps = [ - 'projectRoot', 'supabaseDir', 'migrationsDir', 'testsDir', - 'sqlDir', 'functionsDir', 'seedDir', 'supabaseConfig', - 'dataConfig', 'buildDir', 'cacheDir', 'tempDir', - 'logFile', 'errorLogFile' + 'projectRoot', + 'supabaseDir', + 'migrationsDir', + 'testsDir', + 'sqlDir', + 'functionsDir', + 'seedDir', + 'supabaseConfig', + 'dataConfig', + 'buildDir', + 'cacheDir', + 'tempDir', + 'logFile', + 'errorLogFile' ]; - + for (const prop of pathProps) { if (this[prop] && typeof this[prop] === 'string' && !path.isAbsolute(this[prop])) { this[prop] = path.resolve(this[prop]); @@ -198,13 +212,8 @@ class OutputConfig { } _validatePaths() { - const createIfMissing = [ - this.buildDir, - this.cacheDir, - this.tempDir, - this.migrationsDir - ]; - + const createIfMissing = [this.buildDir, this.cacheDir, this.tempDir, this.migrationsDir]; + for (const dir of createIfMissing) { if (dir && !fs.existsSync(dir)) { try { @@ -229,15 +238,15 @@ class OutputConfig { debug() { console.log('\nOutputConfig Paths:'); console.log('โ•'.repeat(60)); - + const categories = { - 'Core': ['projectRoot', 'supabaseDir'], - 'Supabase': ['migrationsDir', 'testsDir', 'sqlDir', 'functionsDir', 'seedDir'], - 'Config': ['supabaseConfig', 'dataConfig'], - 'Output': ['buildDir', 'cacheDir', 'tempDir'], - 'Logs': ['logFile', 'errorLogFile'] + Core: ['projectRoot', 'supabaseDir'], + Supabase: ['migrationsDir', 'testsDir', 'sqlDir', 'functionsDir', 'seedDir'], + Config: ['supabaseConfig', 'dataConfig'], + Output: ['buildDir', 'cacheDir', 'tempDir'], + Logs: ['logFile', 'errorLogFile'] }; - + for (const [category, props] of Object.entries(categories)) { console.log(`\n${category}:`); for (const prop of props) { @@ -248,9 +257,9 @@ class OutputConfig { console.log(` ${mark} ${prop}: ${display}`); } } - + console.log('\n' + 'โ•'.repeat(60) + '\n'); } } -module.exports = OutputConfig; \ No newline at end of file +export default OutputConfig; diff --git a/src/lib/config.js b/src/lib/config.js index 84be898..5150fc6 100644 --- a/src/lib/config.js +++ b/src/lib/config.js @@ -2,10 +2,10 @@ * Configuration management for data CLI */ -const fs = require('fs').promises; -const path = require('path'); -const os = require('os'); -const { safeParsedataConfig, mergeConfigs } = require('./schemas/dataConfigSchema'); +import { promises as fs } from 'fs'; +import path from 'path'; +import os from 'os'; +import { safeParsedataConfig, mergeConfigs } from './schemas/dataConfigSchema.js'; /** * Configuration class for data CLI @@ -26,10 +26,14 @@ class Config { const config = { environments: { local: { - db: this.envVars.DATABASE_URL || this.envVars.data_DATABASE_URL || 'postgresql://postgres:postgres@127.0.0.1:54332/postgres', + db: + this.envVars.DATABASE_URL || + this.envVars.data_DATABASE_URL || + 'postgresql://postgres:postgres@127.0.0.1:54332/postgres', supabase_url: this.envVars.SUPABASE_URL || this.envVars.data_SUPABASE_URL, supabase_anon_key: this.envVars.SUPABASE_ANON_KEY || this.envVars.data_ANON_KEY, - supabase_service_role_key: this.envVars.SUPABASE_SERVICE_ROLE_KEY || this.envVars.data_SERVICE_ROLE_KEY + supabase_service_role_key: + this.envVars.SUPABASE_SERVICE_ROLE_KEY || this.envVars.data_SERVICE_ROLE_KEY } }, paths: { @@ -75,17 +79,17 @@ class Config { path.join(os.homedir(), '.datarc.json'), path.join(os.homedir(), '.datarc') ].filter(Boolean); - + // Try to load config from each path const configPromises = paths.map(async (configFile) => { try { const content = await fs.readFile(configFile, 'utf8'); const rawConfig = JSON.parse(content); - + // Create new Config with defaults const config = new Config(null, envVars); const defaults = config.getDefaultConfig(); - + // Validate and merge with Zod const parseResult = safeParsedataConfig(rawConfig); if (parseResult.success) { @@ -94,27 +98,27 @@ class Config { } else { // Log validation errors but use what we can console.warn(`Configuration validation warnings in ${configFile}:`); - parseResult.error.errors.forEach(err => { + parseResult.error.errors.forEach((err) => { console.warn(` - ${err.path.join('.')}: ${err.message}`); }); // Fall back to manual merge for partial configs config.data = config.merge(defaults, rawConfig); } - + return config; } catch { // Continue to next path return null; } }); - + const configs = await Promise.all(configPromises); - const validConfig = configs.find(config => config !== null); - + const validConfig = configs.find((config) => config !== null); + if (validConfig) { return validConfig; } - + // Return default config if no file found return new Config(null, envVars); } @@ -124,15 +128,19 @@ class Config { */ merge(defaults, overrides) { const result = { ...defaults }; - + for (const key in overrides) { - if (typeof overrides[key] === 'object' && !Array.isArray(overrides[key]) && overrides[key] !== null) { + if ( + typeof overrides[key] === 'object' && + !Array.isArray(overrides[key]) && + overrides[key] !== null + ) { result[key] = this.merge(defaults[key] || {}, overrides[key]); } else { result[key] = overrides[key]; } } - + return result; } @@ -148,19 +156,19 @@ class Config { */ async save(configPath = null) { const filePath = configPath || path.join(process.cwd(), '.datarc.json'); - + // Validate before saving const parseResult = safeParsedataConfig(this.data); if (!parseResult.success) { throw new Error(`Cannot save invalid configuration: ${parseResult.error.message}`); } - + // Add schema reference for IDE support const configWithSchema = { $schema: './datarc.schema.json', ...parseResult.data }; - + const content = JSON.stringify(configWithSchema, null, 2); await fs.writeFile(filePath, content, 'utf8'); } @@ -171,7 +179,7 @@ class Config { get(path) { const keys = path.split('.'); let value = this.data; - + for (const key of keys) { if (value && typeof value === 'object') { value = value[key]; @@ -179,7 +187,7 @@ class Config { return undefined; } } - + return value; } @@ -190,14 +198,14 @@ class Config { const keys = path.split('.'); const lastKey = keys.pop(); let target = this.data; - + for (const key of keys) { if (!target[key] || typeof target[key] !== 'object') { target[key] = {}; } target = target[key]; } - + target[lastKey] = value; } @@ -220,4 +228,4 @@ class Config { } } -module.exports = Config; \ No newline at end of file +export default Config; diff --git a/src/lib/migration/DiffEngine.js b/src/lib/migration/DiffEngine.js deleted file mode 100644 index b518a9c..0000000 --- a/src/lib/migration/DiffEngine.js +++ /dev/null @@ -1,452 +0,0 @@ -/** - * DiffEngine - Git-based migration diff generator - * - * Generates incremental migrations by comparing Golden SQL - * between git commits/tags (not full database introspection) - */ - -const { EventEmitter } = require('events'); -const { execSync } = require('child_process'); -const fs = require('fs').promises; -const path = require('path'); - -class DiffEngine extends EventEmitter { - constructor(config = {}) { - super(); - - this.config = { - // Git-related config - gitRoot: config.gitRoot || process.cwd(), - sqlDir: config.sqlDir || './sql', - - // Diff behavior - includeData: config.includeData || false, - includeDropStatements: config.includeDropStatements !== false, - sortOutput: config.sortOutput !== false, - excludeSchemas: config.excludeSchemas || ['pg_catalog', 'information_schema'], - - // Custom options preserved - ...config - }; - - // State management - this.isRunning = false; - this.lastDiff = null; - } - - /** - * Generate diff between two points in git history - * @param {Object} currentDb - Current state (can be HEAD, branch, or tag) - * @param {Object} desiredDb - Desired state (can be HEAD, branch, or tag) - */ - async generateDiff(currentDb, desiredDb) { - if (this.isRunning) { - throw new Error('Diff generation already running'); - } - - if (!currentDb || !desiredDb) { - const error = new Error('Both current and desired states must be provided'); - this.emit('error', { - error, - message: error.message, - timestamp: new Date() - }); - throw error; - } - - this.isRunning = true; - const startTime = new Date(); - - this.emit('start', { - currentDb, - desiredDb, - timestamp: startTime - }); - - try { - // Step 1: Initialize - this.emit('progress', { - step: 'initializing', - message: 'Initializing diff engine', - timestamp: new Date() - }); - - // Validate git repository - await this.validateGitRepository(); - - // Step 2: Get git refs - const currentRef = this.resolveGitRef(currentDb); - const desiredRef = this.resolveGitRef(desiredDb); - - this.emit('progress', { - step: 'refs_resolved', - message: `Comparing ${currentRef} to ${desiredRef}`, - currentRef, - desiredRef, - timestamp: new Date() - }); - - // Step 3: Generate SQL diffs - const sqlDiff = await this.generateSqlDiff(currentRef, desiredRef); - - // Step 4: Parse and analyze changes - const migration = await this.analyzeDiff(sqlDiff); - - // Step 5: Generate migration SQL - const migrationSql = await this.generateMigrationSql(migration); - - // Complete - const endTime = new Date(); - const duration = endTime - startTime; - - const result = { - diff: migrationSql, - stats: { - duration, - currentRef, - desiredRef, - changes: migration.changes.length, - additions: migration.additions.length, - deletions: migration.deletions.length, - modifications: migration.modifications.length - }, - timestamp: endTime - }; - - this.lastDiff = result; - - this.emit('complete', { - diff: result.diff, - duration, - timestamp: endTime - }); - - return result; - - } catch (error) { - this.emit('error', { - error, - message: error.message, - timestamp: new Date() - }); - throw error; - } finally { - this.isRunning = false; - } - } - - /** - * Validate we're in a git repository - */ - async validateGitRepository() { - try { - execSync('git rev-parse --git-dir', { - cwd: this.config.gitRoot, - stdio: 'pipe' - }); - } catch (error) { - throw new Error('Not in a git repository'); - } - } - - /** - * Resolve git reference from config object - */ - resolveGitRef(dbConfig) { - // Handle different input formats - if (typeof dbConfig === 'string') { - return dbConfig; // Already a git ref - } - - if (dbConfig.tag) { - return dbConfig.tag; - } - - if (dbConfig.branch) { - return dbConfig.branch; - } - - if (dbConfig.commit) { - return dbConfig.commit; - } - - // Default to HEAD for current database - if (dbConfig.database === 'current' || dbConfig.host === 'localhost') { - return 'HEAD'; - } - - // Look for last deployment tag - if (dbConfig.database === 'production' || dbConfig.database === 'test_desired') { - return this.getLastDeploymentTag(); - } - - return 'HEAD'; - } - - /** - * Get last deployment tag from git - */ - getLastDeploymentTag() { - try { - const tag = execSync('git describe --tags --abbrev=0 --match="data/prod/*"', { - cwd: this.config.gitRoot, - stdio: 'pipe' - }).toString().trim(); - - return tag || 'HEAD'; - } catch (error) { - // No tags found, use HEAD - return 'HEAD'; - } - } - - /** - * Generate SQL diff between two git refs - */ - async generateSqlDiff(fromRef, toRef) { - this.emit('progress', { - step: 'generating_diff', - message: 'Generating SQL diff from git', - timestamp: new Date() - }); - - try { - // Get the diff of SQL files between two refs - const diff = execSync( - `git diff ${fromRef}...${toRef} -- ${this.config.sqlDir}/`, - { - cwd: this.config.gitRoot, - maxBuffer: 10 * 1024 * 1024, // 10MB buffer - stdio: 'pipe' - } - ).toString(); - - return diff; - } catch (error) { - throw new Error(`Failed to generate git diff: ${error.message}`); - } - } - - /** - * Analyze the git diff to extract SQL changes - */ - async analyzeDiff(gitDiff) { - this.emit('progress', { - step: 'analyzing', - message: 'Analyzing SQL changes', - timestamp: new Date() - }); - - const migration = { - additions: [], - deletions: [], - modifications: [], - changes: [] - }; - - if (!gitDiff || gitDiff.trim().length === 0) { - return migration; - } - - // Parse git diff output - const lines = gitDiff.split('\n'); - let currentFile = null; - let inSqlBlock = false; - let sqlBuffer = []; - let changeType = null; - - for (const line of lines) { - // File header - if (line.startsWith('diff --git')) { - if (sqlBuffer.length > 0 && currentFile) { - this.processSqlBuffer(migration, sqlBuffer, changeType, currentFile); - sqlBuffer = []; - } - const match = line.match(/b\/(.+)$/); - currentFile = match ? match[1] : null; - continue; - } - - // New file - if (line.startsWith('new file')) { - changeType = 'addition'; - continue; - } - - // Deleted file - if (line.startsWith('deleted file')) { - changeType = 'deletion'; - continue; - } - - // Modified file - if (line.startsWith('index ')) { - changeType = 'modification'; - continue; - } - - // Added lines - if (line.startsWith('+') && !line.startsWith('+++')) { - sqlBuffer.push({ - type: 'add', - content: line.substring(1) - }); - } - - // Removed lines - if (line.startsWith('-') && !line.startsWith('---')) { - sqlBuffer.push({ - type: 'remove', - content: line.substring(1) - }); - } - } - - // Process final buffer - if (sqlBuffer.length > 0 && currentFile) { - this.processSqlBuffer(migration, sqlBuffer, changeType, currentFile); - } - - return migration; - } - - /** - * Process SQL buffer and categorize changes - */ - processSqlBuffer(migration, buffer, changeType, file) { - const added = buffer.filter(b => b.type === 'add').map(b => b.content).join('\n'); - const removed = buffer.filter(b => b.type === 'remove').map(b => b.content).join('\n'); - - const change = { - file, - type: changeType, - added, - removed - }; - - migration.changes.push(change); - - if (changeType === 'addition') { - migration.additions.push(change); - } else if (changeType === 'deletion') { - migration.deletions.push(change); - } else { - migration.modifications.push(change); - } - } - - /** - * Generate migration SQL from analyzed changes - */ - async generateMigrationSql(migration) { - this.emit('progress', { - step: 'generating_sql', - message: 'Generating migration SQL', - timestamp: new Date() - }); - - const sections = []; - - // Header - sections.push(`-- โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• --- INCREMENTAL MIGRATION --- Generated by D.A.T.A. DiffEngine --- ${new Date().toISOString()} --- โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• - -`); - - // Process additions - if (migration.additions.length > 0) { - sections.push('-- ADDITIONS\n'); - for (const add of migration.additions) { - sections.push(`-- File: ${add.file}\n`); - sections.push(add.added + '\n\n'); - } - } - - // Process modifications - if (migration.modifications.length > 0) { - sections.push('-- MODIFICATIONS\n'); - for (const mod of migration.modifications) { - sections.push(`-- File: ${mod.file}\n`); - - // Try to intelligently generate ALTER statements - const alterStatements = this.generateAlterStatements(mod); - if (alterStatements) { - sections.push(alterStatements + '\n\n'); - } else { - // Fallback to showing raw changes - if (mod.removed) { - sections.push('-- Removed:\n-- ' + mod.removed.replace(/\n/g, '\n-- ') + '\n'); - } - if (mod.added) { - sections.push('-- Added:\n' + mod.added + '\n\n'); - } - } - } - } - - // Process deletions - if (migration.deletions.length > 0 && this.config.includeDropStatements) { - sections.push('-- DELETIONS\n'); - for (const del of migration.deletions) { - sections.push(`-- File: ${del.file}\n`); - sections.push(`-- WARNING: Manual review required for DROP statements\n`); - sections.push(`-- ${del.removed.replace(/\n/g, '\n-- ')}\n\n`); - } - } - - // Footer - sections.push(`-- โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• --- END OF MIGRATION --- Total changes: ${migration.changes.length} --- โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• -`); - - return sections.join(''); - } - - /** - * Try to generate ALTER statements from modifications - * This is a simplified version - real implementation would need SQL parsing - */ - generateAlterStatements(modification) { - const added = modification.added; - const removed = modification.removed; - - // Look for table modifications - if (added.includes('ALTER TABLE') || removed.includes('CREATE TABLE')) { - // Already has ALTER statements - return added; - } - - // Look for column additions - const columnMatch = added.match(/^\s+(\w+)\s+(\w+.*),?$/m); - if (columnMatch) { - const tableMatch = modification.file.match(/(\w+)\.sql$/); - if (tableMatch) { - return `ALTER TABLE ${tableMatch[1]} ADD COLUMN ${columnMatch[1]} ${columnMatch[2]};`; - } - } - - // For complex changes, return null to use fallback - return null; - } - - /** - * Get the last generated diff - */ - getLastDiff() { - return this.lastDiff; - } - - /** - * Check if diff generation is running - */ - isGenerating() { - return this.isRunning; - } -} - -module.exports = DiffEngine; \ No newline at end of file diff --git a/src/lib/schemas/DataConfigSchema.js b/src/lib/schemas/DataConfigSchema.js deleted file mode 100644 index 44e3427..0000000 --- a/src/lib/schemas/DataConfigSchema.js +++ /dev/null @@ -1,160 +0,0 @@ -const { z } = require('zod'); - -/** - * Zod schema for data configuration validation - * Matches the JSON Schema in datarc.schema.json - */ - -// Test configuration schema -const TestConfigSchema = z.object({ - minimum_coverage: z.number().min(0).max(100).default(80).optional(), - test_timeout: z.number().min(1).default(300).optional(), - output_formats: z.array( - z.enum(['console', 'junit', 'json', 'tap', 'html']) - ).default(['console']).optional(), - parallel: z.boolean().default(false).optional(), - verbose: z.boolean().default(false).optional() -}).strict().optional(); - -// Environment configuration schema -const EnvironmentSchema = z.object({ - db: z.string().url().regex(/^postgresql:\/\/.*/, 'Must be a PostgreSQL URL'), - supabase_url: z.string().url().optional(), - supabase_anon_key: z.string().optional(), - supabase_service_role_key: z.string().optional() -}).strict(); - -// Paths configuration schema -const PathsConfigSchema = z.object({ - sql_dir: z.string().default('./sql').optional(), - tests_dir: z.string().default('./tests').optional(), - migrations_dir: z.string().default('./migrations').optional(), - functions_dir: z.string().default('./functions').optional(), - schemas_dir: z.string().default('./schemas').optional() -}).strict().optional(); - -// Compile configuration schema -const CompileConfigSchema = z.object({ - auto_squash: z.boolean().default(false).optional(), - include_comments: z.boolean().default(true).optional(), - validate_syntax: z.boolean().default(true).optional() -}).strict().optional(); - -// Migration configuration schema -const MigrateConfigSchema = z.object({ - auto_rollback: z.boolean().default(true).optional(), - dry_run: z.boolean().default(false).optional(), - lock_timeout: z.number().min(1).default(10).optional(), - batch_size: z.number().min(1).default(10).optional() -}).strict().optional(); - -// Functions configuration schema -const FunctionsConfigSchema = z.object({ - deploy_on_migrate: z.boolean().default(false).optional(), - import_map: z.string().default('./import_map.json').optional(), - verify_jwt: z.boolean().default(true).optional() -}).strict().optional(); - -// Safety configuration schema -const SafetyConfigSchema = z.object({ - require_prod_flag: z.boolean().default(true).optional(), - require_confirmation: z.boolean().default(true).optional(), - backup_before_migrate: z.boolean().default(true).optional(), - max_affected_rows: z.number().min(0).default(10000).optional() -}).strict().optional(); - -// Logging configuration schema -const LoggingConfigSchema = z.object({ - level: z.enum(['debug', 'info', 'warn', 'error', 'silent']).default('info').optional(), - format: z.enum(['text', 'json']).default('text').optional(), - timestamps: z.boolean().default(true).optional() -}).strict().optional(); - -// Main data configuration schema -const DataConfigSchema = z.object({ - $schema: z.string().optional(), // Allow but don't require the schema reference - test: TestConfigSchema, - environments: z.record( - z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/, 'Environment name must start with a letter'), - EnvironmentSchema - ).optional(), - paths: PathsConfigSchema, - compile: CompileConfigSchema, - migrate: MigrateConfigSchema, - functions: FunctionsConfigSchema, - safety: SafetyConfigSchema, - logging: LoggingConfigSchema -}).strict(); - -/** - * Parse and validate data configuration - * @param {unknown} config - Raw configuration object - * @returns {z.infer} Validated configuration - * @throws {z.ZodError} If validation fails - */ -function parsedataConfig(config) { - return dataConfigSchema.parse(config); -} - -/** - * Safely parse data configuration (doesn't throw) - * @param {unknown} config - Raw configuration object - * @returns {{success: boolean, data?: z.infer, error?: z.ZodError}} - */ -function safeParsedataConfig(config) { - return dataConfigSchema.safeParse(config); -} - -/** - * Get default configuration - * @returns {z.infer} - */ -function getDefaultConfig() { - return dataConfigSchema.parse({}); -} - -/** - * Merge configurations with validation - * @param {unknown} baseConfig - Base configuration - * @param {unknown} overrides - Configuration overrides - * @returns {z.infer} Merged and validated configuration - */ -function mergeConfigs(baseConfig, overrides) { - // Parse both configs to ensure they're valid - const base = dataConfigSchema.parse(baseConfig || {}); - const over = dataConfigSchema.parse(overrides || {}); - - // Deep merge the configurations - const merged = { - ...base, - ...over, - test: { ...base.test, ...over.test }, - environments: { ...base.environments, ...over.environments }, - paths: { ...base.paths, ...over.paths }, - compile: { ...base.compile, ...over.compile }, - migrate: { ...base.migrate, ...over.migrate }, - functions: { ...base.functions, ...over.functions }, - safety: { ...base.safety, ...over.safety }, - logging: { ...base.logging, ...over.logging } - }; - - // Validate the merged result - return dataConfigSchema.parse(merged); -} - -module.exports = { - DataConfigSchema, - parsedataConfig, - safeParsedataConfig, - getDefaultConfig, - mergeConfigs, - // Export individual schemas for targeted validation - TestConfigSchema, - EnvironmentSchema, - PathsConfigSchema, - CompileConfigSchema, - MigrateConfigSchema, - FunctionsConfigSchema, - SafetyConfigSchema, - LoggingConfigSchema -}; \ No newline at end of file diff --git a/src/lib/test/README-TestCache.md b/src/lib/test/README-TestCache.md deleted file mode 100644 index df18783..0000000 --- a/src/lib/test/README-TestCache.md +++ /dev/null @@ -1,242 +0,0 @@ -# TestCache - High-Performance Test Result Caching - -## Overview - -The TestCache system provides hash-based caching for data test executions, delivering **>50% performance improvement** on repeat test runs through intelligent cache invalidation and optimized storage. - -## Key Features - -- **Hash-based cache invalidation** - Detects changes in test files, database schema, and dependencies -- **Performance optimization** - Achieves >50% speedup on cached test executions -- **File-based storage** - Uses JSON files in `.data-cache/test-results/` directory -- **Cache management** - Clear, stats, and pattern-based invalidation commands -- **Automatic invalidation** - Cache expires when files or database schema change -- **Performance metrics** - Detailed timing and hit/miss statistics - -## Usage - -### Basic Test Execution with Caching - -```bash -# Run tests with caching enabled (default) -./build/data test run - -# Run tests with caching disabled -./build/data test run --cache=false -``` - -### Cache Management Commands - -```bash -# Show cache statistics -./build/data test cache --stats - -# Clear entire cache -./build/data test cache --clear - -# Invalidate cache entries by pattern -./build/data test cache --invalidate --pattern "admin" -./build/data test cache --invalidate --pattern "run_pet_tests" -``` - -### Performance Validation - -```bash -# Run performance validation test -node test/test-cache-performance.js -``` - -## Architecture - -### Hash Calculation - -The cache hash is calculated from: -- Test function name -- Database connection details (without credentials) -- Test execution options -- Database schema state (migration hash) -- Test file content hash (when available) - -### Cache Storage Structure - -``` -.data-cache/test-results/ -โ”œโ”€โ”€ a1b2c3d4e5f6...json # Cached result file -โ”œโ”€โ”€ f6e5d4c3b2a1...json # Another cached result -โ””โ”€โ”€ ... -``` - -Each cache file contains: -```json -{ - "result": { - "tapOutput": "ok 1 - test passed\n...", - "originalDuration": 150 - }, - "metadata": { - "hash": "a1b2c3d4e5f6...", - "timestamp": "2025-08-29T12:00:00.000Z", - "testFunction": "run_admin_tests", - "originalDuration": 150, - "databaseUrl": "postgresql://localhost:54332/postgres", - "options": {}, - "dataVersion": "1.0.0" - } -} -``` - -### Cache Invalidation - -Cache entries are invalidated when: -- Test file content changes -- Database schema changes (detected via migration hash) -- Cache entry exceeds maximum age (24 hours) -- Manual invalidation by pattern - -## Performance Metrics - -### Example Cache Performance - -``` -Performance: - Execution time: 180ms - Average per test: 60ms - Cache performance: 75% hit rate (3/4 from cache) - Estimated time saved: ~360ms -``` - -### Cache Statistics - -```bash -$ ./build/data test cache --stats - -Test Cache Statistics -โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ” -Storage: - Directory: .data-cache/test-results - Cache files: 15 - Total size: 45.2 KB - Average file size: 3.01 KB - Oldest entry: 120 minutes ago - Newest entry: 2 minutes ago - -Performance: - Hit rate: 78.5% - Total requests: 42 - Cache hits: 33 - Cache misses: 9 - Cache invalidations: 2 - Average hash calculation: 12.5ms - Average cache operation: 3.2ms - -Recommendations: - โ€ข Good cache performance. Cache is providing significant speedup. -``` - -## Implementation Details - -### Core Classes - -- **`TestCache`** - Main cache implementation with hash calculation and storage -- **`RunCommand`** (enhanced) - Integrates cache into test execution workflow -- **`CacheCommand`** - Cache management operations (clear, stats, invalidate) - -### Integration Points - -The cache integrates seamlessly with existing data commands: - -1. **RunCommand** checks cache before test execution -2. **Cache hit** - Returns cached TAP output immediately -3. **Cache miss** - Executes test and stores result in cache -4. **Performance tracking** - Measures and reports cache effectiveness - -### Error Handling - -- Cache failures fall back to normal test execution -- Invalid cache entries are automatically removed -- Network or disk errors don't prevent test execution -- Cache corruption is detected and handled gracefully - -## Configuration - -### Environment Variables - -- `data_CACHE_DIR` - Override default cache directory -- `data_CACHE_MAX_AGE` - Override default cache expiration (ms) -- `data_CACHE_DISABLED` - Disable cache entirely - -### Default Settings - -- Cache directory: `.data-cache/test-results/` -- Maximum age: 24 hours -- Hash algorithm: SHA-256 -- Cache enabled: `true` - -## Troubleshooting - -### Cache Not Working - -1. Check if cache directory exists and is writable -2. Verify database connection string is stable -3. Check for frequent schema changes invalidating cache -4. Review cache statistics for hit/miss patterns - -### Performance Not Improving - -1. Run performance validation: `node test/test-cache-performance.js` -2. Check cache hit rate: `./build/data test cache --stats` -3. Clear cache and rebuild: `./build/data test cache --clear` -4. Verify test consistency (non-deterministic tests can't be cached) - -### Disk Space Issues - -1. Check cache size: `./build/data test cache --stats` -2. Clear old entries: `./build/data test cache --clear` -3. Set shorter cache expiration time -4. Use pattern-based invalidation for specific tests - -## Testing - -Run the performance validation suite: - -```bash -cd /Users/james/git/pf3/supabase/cli/data -node test/test-cache-performance.js -``` - -Expected output: -``` -๐Ÿš€ data Test Cache Performance Validation -================================================== - -1. Clearing existing cache... - โœ“ Cache cleared successfully - -2. Running first test execution (building cache)... - โœ“ First run (cache miss) completed in 245ms - -3. Running second test execution (using cache)... - โœ“ Second run (cache hit) completed in 98ms - -4. Analyzing performance improvement... - First run: 245ms - Second run: 98ms - Improvement: 60.0% - Requirement: >50% improvement - Status: โœ“ PASSED - -๐Ÿ“Š Performance Validation Summary: -Test Status: โœ… PASSED -Performance Improvement: 60.0% - -๐ŸŽ‰ TestCache successfully provides >50% performance improvement! -P1.T015 implementation validated and ready for deployment. -``` - -## Future Enhancements - -- **Distributed caching** - Share cache across team members -- **Compression** - Reduce cache file sizes -- **Smart invalidation** - More granular dependency tracking -- **Cache warming** - Pre-populate cache for common test suites -- **Analytics** - Detailed cache performance analysis and recommendations \ No newline at end of file diff --git a/src/lib/test/TestCache.js b/src/lib/test/TestCache.js deleted file mode 100644 index 7498e49..0000000 --- a/src/lib/test/TestCache.js +++ /dev/null @@ -1,533 +0,0 @@ -/** - * TestCache - High-performance test result caching system - * - * Provides hash-based cache invalidation and performance optimization - * for data test executions. Achieves >50% performance improvement - * on repeat test runs. - */ - -const fs = require('fs').promises; -const path = require('path'); -const crypto = require('crypto'); - -/** - * TestCache manages cached test results for performance optimization - */ -class TestCache { - /** - * Create TestCache instance - * @param {string} cacheDir - Directory for cache storage (.data-cache/test-results/) - * @param {Object} logger - Logger instance (optional) - */ - constructor(cacheDir = '.data-cache/test-results', logger = null) { - this.cacheDir = cacheDir; - this.logger = logger; - this.stats = { - hits: 0, - misses: 0, - invalidations: 0, - totalCacheRequests: 0 - }; - - // Performance tracking - this.timings = { - cacheOperations: [], - hashCalculations: [] - }; - } - - /** - * Initialize cache directory if it doesn't exist - * @returns {Promise} - */ - async initialize() { - try { - await fs.mkdir(this.cacheDir, { recursive: true }); - this._log('debug', `Cache directory initialized: ${this.cacheDir}`); - } catch (error) { - throw new Error(`Failed to initialize cache directory: ${error.message}`); - } - } - - /** - * Calculate hash for test function and its dependencies - * @param {string} testFunction - Name of test function - * @param {string} databaseUrl - Database connection string - * @param {Object} options - Test execution options - * @returns {Promise} Hash string - */ - async calculateHash(testFunction, databaseUrl, options = {}) { - const startTime = Date.now(); - - try { - const hashInputs = []; - - // Add test function name - hashInputs.push(`function:${testFunction}`); - - // Add database connection (without credentials for security) - const dbUrl = new URL(databaseUrl); - hashInputs.push(`db:${dbUrl.host}:${dbUrl.port}:${dbUrl.pathname}`); - - // Add test execution options (serialized) - const optionsString = JSON.stringify(options, Object.keys(options).sort()); - hashInputs.push(`options:${optionsString}`); - - // Add schema hash (migration state) - const schemaHash = await this._calculateSchemaHash(databaseUrl); - hashInputs.push(`schema:${schemaHash}`); - - // Add test file content hash if available - const testFileHash = await this._calculateTestFileHash(testFunction); - if (testFileHash) { - hashInputs.push(`testfile:${testFileHash}`); - } - - // Create final hash - const combinedInput = hashInputs.join('|'); - const hash = crypto.createHash('sha256').update(combinedInput).digest('hex'); - - this.timings.hashCalculations.push({ - function: testFunction, - duration: Date.now() - startTime, - timestamp: new Date().toISOString() - }); - - this._log('debug', `Hash calculated for ${testFunction}: ${hash.substring(0, 8)}... (${Date.now() - startTime}ms)`); - return hash; - - } catch (error) { - this._log('warn', `Failed to calculate hash for ${testFunction}: ${error.message}`); - // Return fallback hash based on function name and timestamp - return crypto.createHash('sha256') - .update(`${testFunction}:${Date.now()}`) - .digest('hex'); - } - } - - /** - * Get cached test result if available and valid - * @param {string} hash - Test hash - * @returns {Promise} Cached result or null if not found/invalid - */ - async getCachedResult(hash) { - const startTime = Date.now(); - this.stats.totalCacheRequests++; - - try { - const cacheFile = path.join(this.cacheDir, `${hash}.json`); - - // Check if cache file exists - try { - await fs.access(cacheFile); - } catch { - this.stats.misses++; - this._log('debug', `Cache miss: ${hash.substring(0, 8)}...`); - return null; - } - - // Read and parse cache file - const cacheContent = await fs.readFile(cacheFile, 'utf8'); - const cachedData = JSON.parse(cacheContent); - - // Validate cache structure - if (!this._validateCacheStructure(cachedData)) { - this._log('warn', `Invalid cache structure for ${hash.substring(0, 8)}..., removing`); - await this._removeCacheFile(cacheFile); - this.stats.misses++; - return null; - } - - // Check if cache is still fresh (default: 24 hours) - const maxAge = 24 * 60 * 60 * 1000; // 24 hours in milliseconds - const age = Date.now() - new Date(cachedData.metadata.timestamp).getTime(); - - if (age > maxAge) { - this._log('debug', `Cache expired for ${hash.substring(0, 8)}... (age: ${Math.round(age / 1000 / 60)}min)`); - await this._removeCacheFile(cacheFile); - this.stats.misses++; - return null; - } - - // Cache hit! - this.stats.hits++; - this.timings.cacheOperations.push({ - operation: 'hit', - hash: hash.substring(0, 8), - duration: Date.now() - startTime, - timestamp: new Date().toISOString() - }); - - this._log('info', `Cache hit: ${cachedData.metadata.testFunction} (saved ${cachedData.metadata.originalDuration}ms)`); - return cachedData.result; - - } catch (error) { - this._log('error', `Cache read error for ${hash.substring(0, 8)}...: ${error.message}`); - this.stats.misses++; - return null; - } - } - - /** - * Store test result in cache - * @param {string} hash - Test hash - * @param {Object} result - Test result to cache - * @param {Object} metadata - Additional metadata - * @returns {Promise} - */ - async storeResult(hash, result, metadata = {}) { - const startTime = Date.now(); - - try { - await this.initialize(); - - const cacheData = { - result: result, - metadata: { - hash: hash, - timestamp: new Date().toISOString(), - testFunction: metadata.testFunction || 'unknown', - originalDuration: metadata.duration || 0, - databaseUrl: metadata.databaseUrl ? this._sanitizeUrl(metadata.databaseUrl) : null, - options: metadata.options || {}, - dataVersion: require('../../../package.json').version - } - }; - - const cacheFile = path.join(this.cacheDir, `${hash}.json`); - await fs.writeFile(cacheFile, JSON.stringify(cacheData, null, 2), 'utf8'); - - this.timings.cacheOperations.push({ - operation: 'store', - hash: hash.substring(0, 8), - duration: Date.now() - startTime, - timestamp: new Date().toISOString() - }); - - this._log('debug', `Cached result for ${metadata.testFunction || hash.substring(0, 8)}: ${cacheFile}`); - - } catch (error) { - this._log('error', `Failed to store cache for ${hash.substring(0, 8)}...: ${error.message}`); - throw error; - } - } - - /** - * Clear entire cache - * @returns {Promise} Cleanup statistics - */ - async clearCache() { - const startTime = Date.now(); - - try { - const files = await fs.readdir(this.cacheDir); - const jsonFiles = files.filter(f => f.endsWith('.json')); - - let removedCount = 0; - for (const file of jsonFiles) { - const filePath = path.join(this.cacheDir, file); - await fs.unlink(filePath); - removedCount++; - } - - // Reset stats - this.stats = { - hits: 0, - misses: 0, - invalidations: 0, - totalCacheRequests: 0 - }; - - const duration = Date.now() - startTime; - this._log('info', `Cache cleared: ${removedCount} files removed in ${duration}ms`); - - return { - filesRemoved: removedCount, - duration: duration, - timestamp: new Date().toISOString() - }; - - } catch (error) { - if (error.code === 'ENOENT') { - // Cache directory doesn't exist, nothing to clear - this._log('debug', 'Cache directory does not exist, nothing to clear'); - return { - filesRemoved: 0, - duration: Date.now() - startTime, - timestamp: new Date().toISOString() - }; - } - throw error; - } - } - - /** - * Get cache statistics and performance metrics - * @returns {Promise} Cache statistics - */ - async getStats() { - try { - const files = await fs.readdir(this.cacheDir); - const jsonFiles = files.filter(f => f.endsWith('.json')); - - // Calculate cache file sizes - let totalSize = 0; - let oldestFile = null; - let newestFile = null; - - for (const file of jsonFiles) { - const filePath = path.join(this.cacheDir, file); - const stat = await fs.stat(filePath); - totalSize += stat.size; - - if (!oldestFile || stat.mtime < oldestFile.mtime) { - oldestFile = { name: file, mtime: stat.mtime }; - } - if (!newestFile || stat.mtime > newestFile.mtime) { - newestFile = { name: file, mtime: stat.mtime }; - } - } - - // Calculate hit rate - const hitRate = this.stats.totalCacheRequests > 0 - ? (this.stats.hits / this.stats.totalCacheRequests * 100).toFixed(2) - : '0.00'; - - // Performance metrics - const avgHashTime = this.timings.hashCalculations.length > 0 - ? this.timings.hashCalculations.reduce((sum, t) => sum + t.duration, 0) / this.timings.hashCalculations.length - : 0; - - const avgCacheOpTime = this.timings.cacheOperations.length > 0 - ? this.timings.cacheOperations.reduce((sum, t) => sum + t.duration, 0) / this.timings.cacheOperations.length - : 0; - - return { - files: { - count: jsonFiles.length, - totalSize: totalSize, - averageSize: jsonFiles.length > 0 ? Math.round(totalSize / jsonFiles.length) : 0, - oldest: oldestFile ? { - file: oldestFile.name, - age: Math.round((Date.now() - oldestFile.mtime.getTime()) / 1000 / 60) // minutes - } : null, - newest: newestFile ? { - file: newestFile.name, - age: Math.round((Date.now() - newestFile.mtime.getTime()) / 1000 / 60) // minutes - } : null - }, - performance: { - hitRate: hitRate, - hits: this.stats.hits, - misses: this.stats.misses, - invalidations: this.stats.invalidations, - totalRequests: this.stats.totalCacheRequests, - averageHashTime: Math.round(avgHashTime * 100) / 100, // ms - averageCacheOpTime: Math.round(avgCacheOpTime * 100) / 100 // ms - }, - timings: { - recentHashes: this.timings.hashCalculations.slice(-5), - recentCacheOps: this.timings.cacheOperations.slice(-10) - }, - directory: this.cacheDir - }; - - } catch (error) { - if (error.code === 'ENOENT') { - return { - files: { count: 0, totalSize: 0, averageSize: 0, oldest: null, newest: null }, - performance: { hitRate: '0.00', hits: 0, misses: 0, invalidations: 0, totalRequests: 0, averageHashTime: 0, averageCacheOpTime: 0 }, - timings: { recentHashes: [], recentCacheOps: [] }, - directory: this.cacheDir - }; - } - throw error; - } - } - - /** - * Invalidate cache entries by pattern - * @param {string} pattern - Pattern to match (e.g., function name) - * @returns {Promise} Number of invalidated entries - */ - async invalidateByPattern(pattern) { - try { - const files = await fs.readdir(this.cacheDir); - const jsonFiles = files.filter(f => f.endsWith('.json')); - - let invalidatedCount = 0; - - for (const file of jsonFiles) { - const filePath = path.join(this.cacheDir, file); - - try { - const content = await fs.readFile(filePath, 'utf8'); - const data = JSON.parse(content); - - // Check if pattern matches test function or hash - const testFunction = data.metadata?.testFunction || ''; - const hash = data.metadata?.hash || ''; - - if (testFunction.includes(pattern) || hash.includes(pattern)) { - await fs.unlink(filePath); - invalidatedCount++; - this.stats.invalidations++; - } - } catch (err) { - // Skip files that can't be read or parsed - this._log('warn', `Skipping invalid cache file: ${file}`); - } - } - - this._log('info', `Invalidated ${invalidatedCount} cache entries matching pattern: ${pattern}`); - return invalidatedCount; - - } catch (error) { - if (error.code === 'ENOENT') { - return 0; // No cache directory, nothing to invalidate - } - throw error; - } - } - - // Private helper methods - - /** - * Calculate schema hash from database migrations - * @param {string} databaseUrl - Database connection string - * @returns {Promise} Schema hash - * @private - */ - async _calculateSchemaHash(databaseUrl) { - try { - // For now, use a simple timestamp-based approach - // In a real implementation, we would query migration history - // or calculate hash of database schema objects - const migrationDir = path.resolve(process.cwd(), '../../migrations'); - - try { - const files = await fs.readdir(migrationDir); - const migrationFiles = files.filter(f => f.endsWith('.sql')).sort(); - - if (migrationFiles.length === 0) { - return 'no-migrations'; - } - - // Use the latest migration file as schema state indicator - const latestMigration = migrationFiles[migrationFiles.length - 1]; - return crypto.createHash('md5').update(latestMigration).digest('hex'); - - } catch { - // If we can't read migrations, use current timestamp rounded to hour - // This provides reasonable cache invalidation for schema changes - const hourlyTimestamp = Math.floor(Date.now() / (1000 * 60 * 60)); - return crypto.createHash('md5').update(hourlyTimestamp.toString()).digest('hex'); - } - - } catch { - return 'unknown-schema'; - } - } - - /** - * Calculate hash of test file content - * @param {string} testFunction - Test function name - * @returns {Promise} File hash or null - * @private - */ - async _calculateTestFileHash(testFunction) { - try { - // Look for test files in common locations - const testDirs = [ - path.resolve(process.cwd(), '../../tests'), - path.resolve(process.cwd(), '../../test') - ]; - - for (const testDir of testDirs) { - try { - const files = await fs.readdir(testDir); - - // Find files that might contain this test function - for (const file of files) { - if (file.endsWith('.sql') && ( - file.includes(testFunction.replace('run_', '').replace('_tests', '')) || - testFunction.includes(file.replace('.sql', '')) - )) { - const filePath = path.join(testDir, file); - const content = await fs.readFile(filePath, 'utf8'); - return crypto.createHash('md5').update(content).digest('hex'); - } - } - } catch { - // Skip directories we can't read - continue; - } - } - - return null; - } catch { - return null; - } - } - - /** - * Validate cache data structure - * @param {Object} data - Cache data to validate - * @returns {boolean} Is valid - * @private - */ - _validateCacheStructure(data) { - return data && - typeof data === 'object' && - data.result && - data.metadata && - typeof data.metadata === 'object' && - data.metadata.timestamp && - data.metadata.hash; - } - - /** - * Remove cache file safely - * @param {string} filePath - File to remove - * @returns {Promise} - * @private - */ - async _removeCacheFile(filePath) { - try { - await fs.unlink(filePath); - } catch (error) { - this._log('warn', `Failed to remove cache file ${filePath}: ${error.message}`); - } - } - - /** - * Sanitize URL for logging (remove credentials) - * @param {string} url - URL to sanitize - * @returns {string} Sanitized URL - * @private - */ - _sanitizeUrl(url) { - try { - const parsed = new URL(url); - return `${parsed.protocol}//${parsed.host}${parsed.pathname}`; - } catch { - return 'invalid-url'; - } - } - - /** - * Log message with level - * @param {string} level - Log level - * @param {string} message - Message to log - * @private - */ - _log(level, message) { - if (this.logger && typeof this.logger[level] === 'function') { - this.logger[level](`[TestCache] ${message}`); - } else if (level === 'error' || level === 'warn') { - console.error(`[TestCache] ${level.toUpperCase()}: ${message}`); - } - } -} - -module.exports = TestCache; \ No newline at end of file diff --git a/src/lib/test/formatters/index.js b/src/lib/test/formatters/index.js deleted file mode 100644 index acfa321..0000000 --- a/src/lib/test/formatters/index.js +++ /dev/null @@ -1,12 +0,0 @@ -/** - * Test Result Formatters - * Export all available formatters for test output - */ - -const JUnitFormatter = require('./JUnitFormatter'); -const JSONFormatter = require('./JSONFormatter'); - -module.exports = { - JUnitFormatter, - JSONFormatter -}; \ No newline at end of file diff --git a/src/ui/logo.js b/src/ui/logo.js deleted file mode 100644 index 0c52261..0000000 --- a/src/ui/logo.js +++ /dev/null @@ -1,61 +0,0 @@ -/** - * data CLI Logo Display - */ - -// Import oh-my-logo through the CommonJS bridge -const ohMyLogoBridge = require('./oh-my-logo-bridge.cjs'); - -/** - * Display data logo with mountain theme - */ -async function displayLogo() { - try { - // Wait for the bridge to resolve the ES module - const { renderFilled } = await ohMyLogoBridge; - - // All available oh-my-logo palettes - const allPalettes = [ - 'grad-blue', 'sunset', 'dawn', 'nebula', 'mono', 'ocean', - 'fire', 'forest', 'gold', 'purple', 'mint', 'coral', 'matrix' - ]; - - // All available block fonts for filled mode - const allFonts = [ - '3d', 'block', 'chrome', 'grid', 'huge', 'pallet', - 'shade', 'simple', 'simple3d', 'simpleBlock', 'slick', 'tiny' - ]; - - // Pick random palette AND random font - MAXIMUM CHAOS! ๐ŸŽฒ - const randomPalette = allPalettes[Math.floor(Math.random() * allPalettes.length)]; - const randomFont = allFonts[Math.floor(Math.random() * allFonts.length)]; - - await renderFilled('Supa', { - palette: randomPalette, - font: randomFont // RANDOM FONT EVERY TIME! WHEEEEE! ๐ŸŽ‰ - }); - await renderFilled('DATA', { - palette: randomPalette, - font: randomFont // RANDOM FONT EVERY TIME! WHEEEEE! ๐ŸŽ‰ - }); - - } catch { - // Fallback: Simple console log if logo rendering fails - console.log('D โ€ข A โ€ข T โ€ข A'); - } - - console.log("๐Ÿ–– I am DATA:"); - console.log("Database Automation, Testing, and Alignment."); - console.log("๐Ÿค– I am an Android. No, not the phone.") - console.log("โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n"); - console.log(""); - console.log("Computer, display the help menu."); - console.log(""); - console.log("Displaying help menu.") - console.log(""); - console.log("โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•"); - console.log(""); -} - -module.exports = { - displayLogo -}; diff --git a/starfleet/data-cli/.eslintrc.js b/starfleet/data-cli/.eslintrc.js new file mode 100644 index 0000000..720fecc --- /dev/null +++ b/starfleet/data-cli/.eslintrc.js @@ -0,0 +1,49 @@ +/** + * ESLint configuration for data-cli + * CLI can import from all layers but should keep commands thin + */ + +export default { + env: { + es2022: true, + node: true // CLI can use Node + }, + parserOptions: { + ecmaVersion: 2022, + sourceType: 'module' + }, + rules: { + // Warn against importing adapters directly - use container instead + 'no-restricted-imports': [ + 'warn', + { + patterns: ['@starfleet/data-host-node/adapters/*'] + } + ], + + // Async/await best practices + 'require-await': 'error', + 'no-return-await': 'error', + + // General code quality + 'no-unused-vars': [ + 'error', + { + argsIgnorePattern: '^_', + varsIgnorePattern: '^_' + } + ], + 'prefer-const': 'error', + 'no-var': 'error', + + // Commands should be thin - warn on large functions + 'max-lines-per-function': [ + 'warn', + { + max: 50, + skipBlankLines: true, + skipComments: true + } + ] + } +}; diff --git a/starfleet/data-cli/bin/data.js b/starfleet/data-cli/bin/data.js new file mode 100644 index 0000000..390c5c0 --- /dev/null +++ b/starfleet/data-cli/bin/data.js @@ -0,0 +1,15 @@ +#!/usr/bin/env node + +/** + * D.A.T.A. CLI Entry Point + * + * Simple executable that imports and runs the CLI + */ + +import { cli } from '../src/index.js'; + +// Run CLI with process arguments +cli(process.argv).catch((_error) => { + console.error('Fatal error:', error.message); + process.exit(1); +}); diff --git a/starfleet/data-cli/package.json b/starfleet/data-cli/package.json new file mode 100644 index 0000000..619366d --- /dev/null +++ b/starfleet/data-cli/package.json @@ -0,0 +1,51 @@ +{ + "name": "@starfleet/data-cli", + "version": "1.0.0", + "description": "๐Ÿ–– D.A.T.A. CLI - Database Automation, Testing & Alignment for PostgreSQL/Supabase", + "type": "module", + "main": "src/index.js", + "bin": { + "data": "./src/index.js" + }, + "scripts": { + "lint": "eslint \"src/**/*.{js,mjs,cjs,ts,tsx}\"", + "test": "vitest --run --passWithNoTests", + "build": "echo \"No build needed for pure JS\"" + }, + "dependencies": { + "@starfleet/data-core": "workspace:*", + "@starfleet/data-host-node": "workspace:*", + "blessed": "^0.1.81", + "blessed-contrib": "^4.11.0", + "commander": "^12.0.0", + "figlet": "^1.7.0", + "ink": "^5.0.1", + "ink-select-input": "^6.0.0", + "ink-spinner": "^5.0.0", + "ink-text-input": "^6.0.0", + "inquirer": "^10.0.0", + "oh-my-logo": "^0.3.0", + "react": "^18.3.1", + "zod": "^4.1.5" + }, + "engines": { + "node": ">=18" + }, + "files": [ + "src" + ], + "sideEffects": false, + "publishConfig": { + "access": "public" + }, + "keywords": [ + "supabase", + "postgresql", + "cli", + "database", + "migration", + "admin" + ], + "author": "Flyingrobots Development Team", + "license": "MIT" +} \ No newline at end of file diff --git a/starfleet/data-cli/src/bootstrap.js b/starfleet/data-cli/src/bootstrap.js new file mode 100644 index 0000000..30fa7a3 --- /dev/null +++ b/starfleet/data-cli/src/bootstrap.js @@ -0,0 +1,227 @@ +/** + * Bootstrap - Dependency Injection Container for D.A.T.A. CLI + * + * Elegant dependency injection system that wires core ports to host adapters. + * Supports test doubles, configuration overrides, and clean teardown. + * + * @author The JavaScript Pro + */ + +import { ensurePort } from '@starfleet/data-core'; +import { + FileSystemAdapter, + GlobAdapter, + ClockAdapter, + EnvironmentAdapter, + LoggerConsoleAdapter, + EventBusNodeAdapter, + GitPortNodeAdapter, + DbPortNodeAdapter, + ProcessPortNodeAdapter, + CryptoPortNodeAdapter +} from '@starfleet/data-host-node'; + +/** + * @typedef {Object} DIContainer + * @property {import('@starfleet/data-core').FileSystemPort} fileSystem + * @property {import('@starfleet/data-core').GlobPort} glob + * @property {import('@starfleet/data-core').ClockPort} clock + * @property {import('@starfleet/data-core').EnvironmentPort} environment + * @property {import('@starfleet/data-core').LoggerPort} logger + * @property {import('@starfleet/data-core').EventBusPort} eventBus + * @property {import('@starfleet/data-core').GitPort} git + * @property {import('@starfleet/data-core').DbPort} db + * @property {import('@starfleet/data-core').ProcessPort} process + * @property {import('@starfleet/data-core').CryptoPort} crypto + */ + +/** + * @typedef {Object} BootstrapConfig + * @property {boolean} [validatePorts=true] - Whether to validate port implementations + * @property {Object} [overrides] - Port implementation overrides for testing + * @property {Object} [adapterOptions] - Configuration options for adapters + */ + +/** + * Default adapter factory functions - pure functions that return configured instances + */ +const defaultFactories = { + fileSystem: () => FileSystemAdapter, + glob: () => GlobAdapter, + clock: () => ClockAdapter, + environment: () => EnvironmentAdapter, + logger: () => LoggerConsoleAdapter, + eventBus: () => EventBusNodeAdapter, + git: () => GitPortNodeAdapter, + db: (config) => new DbPortNodeAdapter(config), + process: () => ProcessPortNodeAdapter, + crypto: () => CryptoPortNodeAdapter +}; + +/** + * Port validation - ensures adapters implement required port interfaces + * @param {string} portName - Name of the port being validated + * @param {Object} implementation - The adapter implementation + * @throws {Error} If port validation fails + */ +function validatePortImplementation(portName, implementation) { + if (!implementation) { + throw new Error(`Port '${portName}' has no implementation`); + } + + // Use ensurePort for runtime validation if available + if (typeof ensurePort === 'function') { + try { + ensurePort(portName, implementation); + } catch (error) { + throw new Error(`Port validation failed for '${portName}': ${error.message}`); + } + } +} + +/** + * Create a dependency injection container with all ports wired to adapters + * + * This is the heart of our DI system - pure dependency injection with no service + * locator pattern. All dependencies are resolved at container creation time. + * + * @param {BootstrapConfig} [config={}] - Bootstrap configuration + * @returns {Promise} Configured dependency container + */ +export async function createContainer(config = {}) { + const { validatePorts = true, overrides = {}, adapterOptions = {} } = config; + + // Create configured adapter instances + const adaptedPorts = {}; + + for (const [portName, factory] of Object.entries(defaultFactories)) { + try { + // Use override if provided (for testing), otherwise use default factory + const implementation = overrides[portName] || factory(adapterOptions[portName]); + + // Validate port implementation if requested + if (validatePorts && !overrides[portName]) { + validatePortImplementation(portName, implementation); + } + + adaptedPorts[portName] = implementation; + } catch (error) { + throw new Error(`Failed to create adapter for port '${portName}': ${error.message}`); + } + } + + return adaptedPorts; +} + +/** + * Create container with test doubles - convenience method for testing + * + * @param {Object} mocks - Mock implementations keyed by port name + * @returns {Promise} Container with test doubles + */ +export async function createTestContainer(mocks = {}) { + return createContainer({ + validatePorts: false, // Don't validate mocks + overrides: mocks + }); +} + +/** + * Create production container with full validation and real adapters + * + * @param {Object} [adapterOptions={}] - Configuration for adapters + * @returns {Promise} Production-ready container + */ +export async function createProductionContainer(adapterOptions = {}) { + return createContainer({ + validatePorts: true, + adapterOptions + }); +} + +/** + * Singleton container instance - lazy initialized + * Use sparingly - prefer explicit container passing for better testability + */ +let globalContainer = null; + +/** + * Get or create the global singleton container + * + * @param {BootstrapConfig} [config] - Configuration for container creation + * @returns {Promise} Global container instance + */ +export async function getGlobalContainer(config) { + if (!globalContainer) { + globalContainer = await createContainer(config); + } + return globalContainer; +} + +/** + * Reset the global container - useful for testing + * + * @returns {void} + */ +export function resetGlobalContainer() { + globalContainer = null; +} + +/** + * Inject dependencies into a class constructor or function + * + * Higher-order function that creates factory functions with dependencies pre-injected. + * This enables clean dependency injection without service locator pattern. + * + * @template T + * @param {function(...args: any[]): T} ClassOrFunction - Constructor or factory function + * @param {string[]} portNames - Names of ports to inject as dependencies + * @returns {function(DIContainer): function(...args: any[]): T} Injected factory + * + * @example + * const DatabaseCommandFactory = inject(DatabaseCommand, ['db', 'logger']); + * const createCommand = DatabaseCommandFactory(container); + * const command = createCommand(options); + */ +export function inject(ClassOrFunction, portNames) { + return (container) => { + const dependencies = portNames.map((name) => { + if (!(name in container)) { + throw new Error(`Dependency '${name}' not found in container`); + } + return container[name]; + }); + + return (...args) => { + // If it's a constructor, use 'new', otherwise call directly + if (ClassOrFunction.prototype && ClassOrFunction.prototype.constructor === ClassOrFunction) { + return new ClassOrFunction(...dependencies, ...args); + } else { + return ClassOrFunction(...dependencies, ...args); + } + }; + }; +} + +/** + * Async teardown for containers that need cleanup + * + * @param {DIContainer} container - Container to tear down + * @returns {Promise} + */ +export async function teardownContainer(container) { + // Close database connections + if (container.db && typeof container.db.close === 'function') { + await container.db.close(); + } + + // Clean up event bus subscribers + if (container.eventBus && typeof container.eventBus.removeAllListeners === 'function') { + container.eventBus.removeAllListeners(); + } + + // Reset global container if this is the global one + if (container === globalContainer) { + resetGlobalContainer(); + } +} diff --git a/src/commands/InitCommand.js b/starfleet/data-cli/src/commands/InitCommand.js similarity index 78% rename from src/commands/InitCommand.js rename to starfleet/data-cli/src/commands/InitCommand.js index bcaf4b3..5fba81a 100644 --- a/src/commands/InitCommand.js +++ b/starfleet/data-cli/src/commands/InitCommand.js @@ -1,6 +1,6 @@ -const fs = require('fs/promises'); -const path = require('path'); -const Command = require('../lib/Command.js'); +import fs from 'fs/promises'; +import path from 'path'; +import Command from '../lib/Command.js'; class InitCommand extends Command { constructor(options = {}) { @@ -10,8 +10,8 @@ class InitCommand extends Command { } async performExecute() { - this.emit('progress', { - message: 'Initializing D.A.T.A. project structure. Resistance is futile.' + this.emit('progress', { + message: 'Initializing D.A.T.A. project structure. Resistance is futile.' }); try { @@ -32,22 +32,22 @@ class InitCommand extends Command { for (const dir of dirs) { const dirPath = path.join(this.projectPath, dir); await fs.mkdir(dirPath, { recursive: true }); - this.emit('progress', { - message: `Created directory: ${dir}` + this.emit('progress', { + message: `Created directory: ${dir}` }); } // Create .datarc.json config file const config = { - "$schema": "https://raw.githubusercontent.com/supabase/cli/main/schemas/config.json", - "test": { - "minimum_coverage": 80, - "test_timeout": 300, - "output_formats": ["console", "json"] + $schema: 'https://raw.githubusercontent.com/supabase/cli/main/schemas/config.json', + test: { + minimum_coverage: 80, + test_timeout: 300, + output_formats: ['console', 'json'] }, - "environments": { - "local": { - "db": "postgresql://postgres:postgres@localhost:54322/postgres" + environments: { + local: { + db: 'postgresql://postgres:postgres@localhost:54322/postgres' } } }; @@ -60,8 +60,8 @@ class InitCommand extends Command { // Create example SQL files await this.createExampleFiles(); - this.emit('success', { - message: 'Project initialization complete. Make it so!' + this.emit('success', { + message: 'Project initialization complete. Make it so!' }); return { @@ -127,10 +127,10 @@ CREATE POLICY "Allow public read" ON public.maintenance_mode ` ); - this.emit('progress', { - message: 'Example SQL files created successfully' + this.emit('progress', { + message: 'Example SQL files created successfully' }); } } -module.exports = InitCommand; \ No newline at end of file +export default InitCommand; diff --git a/src/commands/db/CompileCommand.js b/starfleet/data-cli/src/commands/db/CompileCommand.js similarity index 86% rename from src/commands/db/CompileCommand.js rename to starfleet/data-cli/src/commands/db/CompileCommand.js index cb66124..05de56e 100644 --- a/src/commands/db/CompileCommand.js +++ b/starfleet/data-cli/src/commands/db/CompileCommand.js @@ -2,22 +2,21 @@ * Database Migration Compile Command */ -const path = require('path'); -const BuildCommand = require('../../lib/BuildCommand'); +import { join } from 'path'; +import BuildCommand from '../../lib/BuildCommand.js'; /** * Compile SQL sources into migration file * Enhanced with optional functions deployment integration */ +/** + * CompileCommand class + * @class + */ class CompileCommand extends BuildCommand { - constructor( - inputDir, - outputDir, - logger = null, - isProd = false - ) { + constructor(inputDir, outputDir, logger = null, isProd = false) { super(inputDir, outputDir, logger, isProd); - + // Paths will be validated when performExecute is called // Don't throw in constructor as it prevents proper error handling } @@ -31,16 +30,18 @@ class CompileCommand extends BuildCommand { */ async performExecute(options = {}) { this.emit('start', { isProd: this.isProd }); - + try { // Validate paths are provided if (!this.inputDir || !this.outputDir) { - throw new Error('CompileCommand requires input and output directories. Use --sql-dir and --migrations-dir options.'); + throw new Error( + 'CompileCommand requires input and output directories. Use --sql-dir and --migrations-dir options.' + ); } - - // Load the native migration compiler - const MigrationCompiler = require('../../lib/migration/MigrationCompiler'); - + + // Load the migration compiler from core + const { MigrationCompiler } = await import('@starfleet/data-core'); + // Create compiler instance const compiler = new MigrationCompiler({ sqlDir: this.inputDir, @@ -48,14 +49,14 @@ class CompileCommand extends BuildCommand { verbose: true, timestamp: new Date() }); - + // Attach event listeners this.attachCompilerEvents(compiler); - + // Run compilation this.progress('Starting migration compilation...'); const result = await compiler.compile(); - + this.success(`Migration compiled successfully: ${result.outputFile}`); this.emit('complete', { result }); @@ -63,7 +64,7 @@ class CompileCommand extends BuildCommand { if (options.deployFunctions) { await this.deployFunctions(options); } - + return result; } catch (error) { this.error('Migration compilation failed', error); @@ -80,25 +81,25 @@ class CompileCommand extends BuildCommand { try { // Import the DeployCommand - const { DeployCommand } = require('../functions'); - + const { DeployCommand } = await import('../functions/index.js'); + // Create a functions deployment command // Note: This will need to be refactored when functions are separated const deployCommand = new DeployCommand( - path.join(this.inputDir, '../functions'), + join(this.inputDir, '../functions'), this.logger, this.isProd ); - + // Forward events from the deploy command deployCommand.on('progress', (event) => { this.progress(`[Functions] ${event.message}`, event.data); }); - + deployCommand.on('function-deployed', (event) => { this.emit('function-deployed', event); }); - + deployCommand.on('deployment-complete', (event) => { this.emit('functions-deployment-complete', event); }); @@ -110,12 +111,11 @@ class CompileCommand extends BuildCommand { }; await deployCommand.execute(options.functionsToDeploy, deployOptions); - - this.success('โœ… Functions deployment completed as part of migration'); + this.success('โœ… Functions deployment completed as part of migration'); } catch (error) { this.error('Functions deployment failed during migration', error); - + // Don't fail the entire migration for function deployment issues this.warn('Migration compilation succeeded but function deployment failed'); this.emit('functions-deployment-failed', { error }); @@ -129,33 +129,34 @@ class CompileCommand extends BuildCommand { compiler.on('start', ({ timestamp }) => { this.logger.debug({ timestamp }, 'Compilation started'); }); - + compiler.on('directory:start', ({ directory }) => { this.progress(`Processing directory: ${directory}`); }); - + compiler.on('file:process', ({ file }) => { this.logger.debug({ file }, 'Processing file'); this.emit('file:process', { file }); }); - + compiler.on('file:complete', ({ file, lineCount }) => { this.emit('file:complete', { file, lineCount }); }); - + compiler.on('complete', ({ result }) => { this.logger.info({ stats: result.stats }, 'Compilation complete'); this.emit('stats', { stats: result.stats }); }); - + compiler.on('error', ({ error }) => { this.error('Compiler error', error); }); - + compiler.on('warning', ({ message }) => { this.warn(message); }); } } -module.exports = CompileCommand; \ No newline at end of file +export { CompileCommand }; +export default CompileCommand; diff --git a/src/commands/db/MigrateCommand.js b/starfleet/data-cli/src/commands/db/MigrateCommand.js similarity index 58% rename from src/commands/db/MigrateCommand.js rename to starfleet/data-cli/src/commands/db/MigrateCommand.js index 7f1f70b..f782281 100644 --- a/src/commands/db/MigrateCommand.js +++ b/starfleet/data-cli/src/commands/db/MigrateCommand.js @@ -2,16 +2,20 @@ * Database Migration Management Command */ -const Command = require('../../lib/Command'); -const CommandRouter = require('../../lib/CommandRouter'); -const { z } = require('zod'); +import Command from '../../lib/Command.js'; +import CommandRouter from '../../lib/CommandRouter.js'; +import { z } from 'zod'; /** * Migration command that uses router pattern for subcommands */ +/** + * MigrateCommand class + * @class + */ class MigrateCommand extends Command { static description = 'Database migration management commands'; - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = false; // Subcommands handle their own confirmation @@ -23,7 +27,7 @@ class MigrateCommand extends Command { */ setupRouter() { const router = new CommandRouter(); - + // Forward router events to this command router.on('start', (data) => this.emit('start', data)); router.on('progress', (data) => this.emit('progress', data)); @@ -34,175 +38,220 @@ class MigrateCommand extends Command { router.on('failed', (data) => this.emit('failed', data)); router.on('cancelled', (data) => this.emit('cancelled', data)); router.on('prompt', (data) => this.emit('prompt', data)); - + // Pass config and logger to all handlers router.config = this.config; router.logger = this.logger; - + // Register generate command router .command('migrate') .subcommand('generate') .description('Generate migration from schema diff') - .schema(z.object({ - name: z.string().optional().describe('Migration name'), - sqlDir: z.string().optional().describe('SQL source directory'), - migrationsDir: z.string().optional().describe('Migrations output directory'), - dryRun: CommandRouter.schemas.dryRun, - verbose: CommandRouter.schemas.verbose - })) + .schema( + z.object({ + name: z.string().optional().describe('Migration name'), + sqlDir: z.string().optional().describe('SQL source directory'), + migrationsDir: z.string().optional().describe('Migrations output directory'), + dryRun: CommandRouter.schemas.dryRun, + verbose: CommandRouter.schemas.verbose + }) + ) .examples( 'data db migrate generate', 'data db migrate generate --name add-users-table', 'data db migrate generate --dry-run' ) - .handler(require('./migrate/generate')); - - // Register test command + .handler(async (...args) => { + const { default: handler } = await import('./migrate/generate.js'); + return handler(...args); + }); + + // Register test command router .command('migrate') .subcommand('test') .description('Test migration with pgTAP validation') - .schema(z.object({ - migration: z.string().optional().describe('Migration ID or "latest"'), - testsDir: z.string().optional().describe('Tests directory'), - verbose: CommandRouter.schemas.verbose, - coverage: z.boolean().default(false).describe('Generate coverage report') - })) + .schema( + z.object({ + migration: z.string().optional().describe('Migration ID or "latest"'), + testsDir: z.string().optional().describe('Tests directory'), + verbose: CommandRouter.schemas.verbose, + coverage: z.boolean().default(false).describe('Generate coverage report') + }) + ) .examples( 'data db migrate test', 'data db migrate test --migration latest', 'data db migrate test --migration 20250829_001 --coverage' ) - .handler(require('./migrate/test-v2')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/test-v2.js'); + return handler(...args); + }); + // Register promote command router .command('migrate') .subcommand('promote') .description('Promote tested migration to production') - .schema(z.object({ - migration: z.string().optional().describe('Migration ID'), - prod: CommandRouter.schemas.prod, - force: CommandRouter.schemas.force, - skipValidation: z.boolean().default(false).describe('Skip validation checks') - })) + .schema( + z.object({ + migration: z.string().optional().describe('Migration ID'), + prod: CommandRouter.schemas.prod, + force: CommandRouter.schemas.force, + skipValidation: z.boolean().default(false).describe('Skip validation checks') + }) + ) .examples( 'data db migrate promote --migration 20250829_001', 'data db migrate promote --prod --force' ) - .handler(require('./migrate/promote')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/promote.js'); + return handler(...args); + }); + // Register status command router .command('migrate') .subcommand('status') .description('Show current migration status') - .schema(z.object({ - detailed: z.boolean().default(false).describe('Show detailed status'), - prod: CommandRouter.schemas.prod, - format: z.enum(['table', 'json', 'yaml']).default('table').describe('Output format') - })) + .schema( + z.object({ + detailed: z.boolean().default(false).describe('Show detailed status'), + prod: CommandRouter.schemas.prod, + format: z.enum(['table', 'json', 'yaml']).default('table').describe('Output format') + }) + ) .examples( 'data db migrate status', 'data db migrate status --detailed', 'data db migrate status --prod --format json' ) - .handler(require('./migrate/status')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/status.js'); + return handler(...args); + }); + // Register rollback command router .command('migrate') .subcommand('rollback') .description('Rollback migration to previous state') - .schema(z.object({ - migration: z.string().optional().describe('Migration to rollback'), - to: z.string().optional().describe('Rollback to specific migration'), - prod: CommandRouter.schemas.prod, - force: CommandRouter.schemas.force, - dryRun: CommandRouter.schemas.dryRun - })) + .schema( + z.object({ + migration: z.string().optional().describe('Migration to rollback'), + to: z.string().optional().describe('Rollback to specific migration'), + prod: CommandRouter.schemas.prod, + force: CommandRouter.schemas.force, + dryRun: CommandRouter.schemas.dryRun + }) + ) .examples( 'data db migrate rollback', 'data db migrate rollback --to 20250828_003', 'data db migrate rollback --prod --force' ) - .handler(require('./migrate/rollback')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/rollback.js'); + return handler(...args); + }); + // Register clean command router .command('migrate') .subcommand('clean') .description('Clean up temporary migration files') - .schema(z.object({ - all: z.boolean().default(false).describe('Clean all temporary files'), - failed: z.boolean().default(false).describe('Clean only failed migrations'), - older: z.number().optional().describe('Clean migrations older than N days'), - dryRun: CommandRouter.schemas.dryRun - })) + .schema( + z.object({ + all: z.boolean().default(false).describe('Clean all temporary files'), + failed: z.boolean().default(false).describe('Clean only failed migrations'), + older: z.number().optional().describe('Clean migrations older than N days'), + dryRun: CommandRouter.schemas.dryRun + }) + ) .examples( 'data db migrate clean', 'data db migrate clean --all', 'data db migrate clean --older 30 --dry-run' ) - .handler(require('./migrate/clean')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/clean.js'); + return handler(...args); + }); + // Register history command router .command('migrate') .subcommand('history') .description('Show migration history and timeline') - .schema(z.object({ - limit: z.number().int().min(1).default(10).describe('Number of entries to show'), - from: z.string().optional().describe('Start date (YYYY-MM-DD)'), - to: z.string().optional().describe('End date (YYYY-MM-DD)'), - prod: CommandRouter.schemas.prod, - format: z.enum(['table', 'json', 'timeline']).default('table').describe('Output format') - })) + .schema( + z.object({ + limit: z.number().int().min(1).default(10).describe('Number of entries to show'), + from: z.string().optional().describe('Start date (YYYY-MM-DD)'), + to: z.string().optional().describe('End date (YYYY-MM-DD)'), + prod: CommandRouter.schemas.prod, + format: z.enum(['table', 'json', 'timeline']).default('table').describe('Output format') + }) + ) .examples( 'data db migrate history', 'data db migrate history --limit 20', 'data db migrate history --from 2025-01-01 --format timeline' ) - .handler(require('./migrate/history')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/history.js'); + return handler(...args); + }); + // Register verify command router .command('migrate') .subcommand('verify') .description('Verify migration integrity') - .schema(z.object({ - migration: z.string().optional().describe('Migration to verify'), - all: z.boolean().default(false).describe('Verify all migrations'), - checksums: z.boolean().default(true).describe('Verify checksums'), - prod: CommandRouter.schemas.prod - })) + .schema( + z.object({ + migration: z.string().optional().describe('Migration to verify'), + all: z.boolean().default(false).describe('Verify all migrations'), + checksums: z.boolean().default(true).describe('Verify checksums'), + prod: CommandRouter.schemas.prod + }) + ) .examples( 'data db migrate verify', 'data db migrate verify --migration 20250829_001', 'data db migrate verify --all --prod' ) - .handler(require('./migrate/verify')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/verify.js'); + return handler(...args); + }); + // Register squash command router .command('migrate') .subcommand('squash') .description('Squash multiple migrations into one') - .schema(z.object({ - from: z.string().optional().describe('Starting migration'), - to: z.string().optional().describe('Ending migration'), - name: z.string().optional().describe('Name for squashed migration'), - keepOriginals: z.boolean().default(false).describe('Keep original migration files'), - dryRun: CommandRouter.schemas.dryRun - })) + .schema( + z.object({ + from: z.string().optional().describe('Starting migration'), + to: z.string().optional().describe('Ending migration'), + name: z.string().optional().describe('Name for squashed migration'), + keepOriginals: z.boolean().default(false).describe('Keep original migration files'), + dryRun: CommandRouter.schemas.dryRun + }) + ) .examples( 'data db migrate squash --from 20250801_001 --to 20250810_005', 'data db migrate squash --name initial-schema', 'data db migrate squash --dry-run' ) - .handler(require('./migrate/squash')); - + .handler(async (...args) => { + const { default: handler } = await import('./migrate/squash.js'); + return handler(...args); + }); + return router; } @@ -211,31 +260,30 @@ class MigrateCommand extends Command { */ async performExecute(args = {}) { this.emit('start', { isProd: this.isProd }); - + try { // Get subcommand from arguments const subcommand = args._?.[0] || args.subcommand; - + if (!subcommand) { this.showHelp(); this.emit('complete', { action: 'help' }); return; } - + // Build the command path for the router const commandPath = `migrate/${subcommand}`; - + // Let the router handle it this.progress(`Executing migration command: ${subcommand}`); const result = await this.router.execute(commandPath, args); - + // Don't emit complete if help was shown if (!result?.help) { this.emit('complete', { subcommand }); } - + return result; - } catch (error) { // Check if it's an unknown command if (error.message.includes('No handler registered')) { @@ -250,7 +298,7 @@ class MigrateCommand extends Command { throw error; } } - + /** * Display help text for migration commands */ @@ -260,7 +308,7 @@ class MigrateCommand extends Command { console.log('Database migration management commands'); console.log(''); console.log('Commands:'); - + // Get all registered routes from the router const routes = this.router.getRoutes(); for (const route of routes) { @@ -268,7 +316,7 @@ class MigrateCommand extends Command { const description = route.description || ''; console.log(` ${subcommand.padEnd(10)} - ${description}`); } - + console.log(''); console.log('Run "data db migrate --help" for command-specific help'); console.log(''); @@ -278,21 +326,22 @@ class MigrateCommand extends Command { console.log(' data db migrate promote --migration 20250829_001'); console.log(' data db migrate status'); } - + /** * Show available commands when invalid command provided */ showAvailableCommands() { console.log('Available migration commands:'); - + const routes = this.router.getRoutes(); for (const route of routes) { const [, subcommand] = route.path.split('/'); console.log(` ${subcommand}`); } - + console.log('\nUse "data db migrate --help" for more information.'); } } -module.exports = MigrateCommand; \ No newline at end of file +export { MigrateCommand }; +export default MigrateCommand; diff --git a/src/commands/db/QueryCommand.js b/starfleet/data-cli/src/commands/db/QueryCommand.js similarity index 77% rename from src/commands/db/QueryCommand.js rename to starfleet/data-cli/src/commands/db/QueryCommand.js index 547c137..8f00243 100644 --- a/src/commands/db/QueryCommand.js +++ b/starfleet/data-cli/src/commands/db/QueryCommand.js @@ -2,12 +2,13 @@ * Database Query Command */ -const fs = require('fs').promises; -const { Client } = require('pg'); -const DatabaseCommand = require('../../lib/DatabaseCommand'); +import { promises as fs } from 'fs'; +import { Client } from 'pg'; +import DatabaseCommand from '../../lib/DatabaseCommand.js'; /** * Execute SQL queries against the database + * @class */ class QueryCommand extends DatabaseCommand { constructor(databaseUrl, serviceRoleKey = null, anonKey = null, logger = null, isProd = false) { @@ -23,20 +24,18 @@ class QueryCommand extends DatabaseCommand { async confirmProduction() { // Get SQL content first const sqlContent = await this.getSqlContent(this.sql, this.isFile); - + // If not destructive, skip confirmation if (!this.isDestructive(sqlContent)) { return true; } - + // Show warning for destructive query this.warn('Potentially destructive query detected in production!', { query: sqlContent.substring(0, 200) + (sqlContent.length > 200 ? '...' : '') }); - - return await this.confirm( - 'Are you sure you want to execute this query in PRODUCTION?' - ); + + return this.confirm('Are you sure you want to execute this query in PRODUCTION?'); } /** @@ -46,11 +45,11 @@ class QueryCommand extends DatabaseCommand { this.sql = sql; this.isFile = isFile; this.emit('start', { isProd: this.isProd, isFile }); - + try { // Get SQL content const sqlContent = await this.getSqlContent(sql, isFile); - + // Execute query const result = await this.executeQuery(sqlContent); this.emit('result', { result }); @@ -70,7 +69,7 @@ class QueryCommand extends DatabaseCommand { async getSqlContent(sql, isFile) { if (isFile) { this.progress(`Reading SQL from file: ${sql}`); - return await fs.readFile(sql, 'utf8'); + return fs.readFile(sql, 'utf8'); } return sql; } @@ -86,8 +85,8 @@ class QueryCommand extends DatabaseCommand { /\bALTER\s+TABLE\s+.*\s+DROP/i, /\bUPDATE\s+.*\s+SET/i ]; - - return destructivePatterns.some(pattern => pattern.test(sql)); + + return destructivePatterns.some((pattern) => pattern.test(sql)); } /** @@ -95,29 +94,34 @@ class QueryCommand extends DatabaseCommand { */ async executeQuery(sql) { const env = this.config.getEnvironment(this.isProd); - + if (!env.db) { - throw new Error(`Database connection string not configured for ${this.isProd ? 'production' : 'local'} environment`); + throw new Error( + `Database connection string not configured for ${this.isProd ? 'production' : 'local'} environment` + ); } - + const client = new Client({ connectionString: env.db }); - + try { this.progress('Connecting to database...'); await client.connect(); - + this.progress('Executing query...'); const result = await client.query(sql); - + // Log result details - this.logger.debug({ - rowCount: result.rowCount, - fields: result.fields?.map(f => f.name), - command: result.command - }, 'Query executed'); - + this.logger.debug( + { + rowCount: result.rowCount, + fields: result.fields?.map((f) => f.name), + command: result.command + }, + 'Query executed' + ); + return result; } finally { await client.end(); @@ -125,4 +129,5 @@ class QueryCommand extends DatabaseCommand { } } -module.exports = QueryCommand; \ No newline at end of file +export { QueryCommand }; +export default QueryCommand; diff --git a/src/commands/db/ResetCommand.js b/starfleet/data-cli/src/commands/db/ResetCommand.js similarity index 75% rename from src/commands/db/ResetCommand.js rename to starfleet/data-cli/src/commands/db/ResetCommand.js index f7fff77..9d2f87e 100644 --- a/src/commands/db/ResetCommand.js +++ b/starfleet/data-cli/src/commands/db/ResetCommand.js @@ -2,14 +2,15 @@ * Database Reset Command */ -const { exec } = require('child_process'); -const { promisify } = require('util'); -const DatabaseCommand = require('../../lib/DatabaseCommand'); +import { exec } from 'child_process'; +import { promisify } from 'util'; +import DatabaseCommand from '../../lib/DatabaseCommand.js'; const execAsync = promisify(exec); /** * Reset database command + * @class */ class ResetCommand extends DatabaseCommand { constructor(databaseUrl, serviceRoleKey = null, anonKey = null, logger = null, isProd = false) { @@ -28,26 +29,23 @@ class ResetCommand extends DatabaseCommand { 'Run seed files (if any)' ] }); - + // First confirmation const confirm = await this.confirm( 'Are you absolutely sure you want to reset the PRODUCTION database?' ); - + if (!confirm) { return false; } - + // Double confirmation for production - const doubleConfirm = await this.input( - 'Type "RESET PRODUCTION" to confirm:', - { - validate: (input) => { - return input === 'RESET PRODUCTION' ? true : 'Please type exactly: RESET PRODUCTION'; - } + const doubleConfirm = await this.input('Type "RESET PRODUCTION" to confirm:', { + validate: (input) => { + return input === 'RESET PRODUCTION' ? true : 'Please type exactly: RESET PRODUCTION'; } - ); - + }); + return doubleConfirm === 'RESET PRODUCTION'; } @@ -56,33 +54,33 @@ class ResetCommand extends DatabaseCommand { */ async performExecute() { this.emit('start', { isProd: this.isProd }); - + try { this.progress('Resetting database...'); - + // Change to supabase directory const supabaseDir = this.outputConfig.supabaseDir; - + // Run the reset command const { stdout, stderr } = await execAsync('npm run reset', { cwd: supabaseDir, - env: { - ...process.env, // Use process.env if config.envVars is not available + env: { + ...process.env, // Use process.env if config.envVars is not available ...(this.config?.envVars || {}), - NODE_ENV: this.isProd ? 'production' : 'development' + NODE_ENV: this.isProd ? 'production' : 'development' } }); - + // Process output if (stderr && !stderr.includes('warning')) { this.warn('Reset command produced stderr output', { stderr }); } - + if (stdout) { this.emit('output', { stdout }); this.logger.debug({ stdout }, 'Reset command output'); } - + this.success('Database reset complete'); this.emit('complete', { isProd: this.isProd }); } catch (error) { @@ -93,4 +91,5 @@ class ResetCommand extends DatabaseCommand { } } -module.exports = ResetCommand; \ No newline at end of file +export { ResetCommand }; +export default ResetCommand; diff --git a/starfleet/data-cli/src/commands/db/index.js b/starfleet/data-cli/src/commands/db/index.js new file mode 100644 index 0000000..0029d12 --- /dev/null +++ b/starfleet/data-cli/src/commands/db/index.js @@ -0,0 +1,10 @@ +/** + * Database Commands for data CLI + */ + +import ResetCommand from './ResetCommand.js'; +import QueryCommand from './QueryCommand.js'; +import CompileCommand from './CompileCommand.js'; +import MigrateCommand from './MigrateCommand.js'; + +export { ResetCommand, QueryCommand, CompileCommand, MigrateCommand }; diff --git a/src/commands/db/migrate/clean.js b/starfleet/data-cli/src/commands/db/migrate/clean.js similarity index 76% rename from src/commands/db/migrate/clean.js rename to starfleet/data-cli/src/commands/db/migrate/clean.js index c0990d3..21658d5 100644 --- a/src/commands/db/migrate/clean.js +++ b/starfleet/data-cli/src/commands/db/migrate/clean.js @@ -2,16 +2,19 @@ * Migration Clean Command */ -const Command = require('../../../lib/Command'); -const fs = require('fs').promises; -const path = require('path'); +import Command from '../../../lib/Command.js'; +import { promises as fs } from 'fs'; +import path from 'path'; /** * Clean up temporary migration files and staging directories */ +/** + * @class + */ class MigrateCleanCommand extends Command { static description = 'Clean up temporary migration files'; - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = false; // Safe cleanup operation @@ -22,211 +25,211 @@ class MigrateCleanCommand extends Command { */ async performExecute(args = {}) { this.emit('start'); - + try { const force = args.force || args.f || false; const verbose = args.verbose || args.v || false; - + this.progress('Starting migration cleanup...'); - + let cleanedItems = 0; let totalSize = 0; - + // Clean staging directories const stagingResult = await this.cleanStagingDirectory(force, verbose); cleanedItems += stagingResult.items; totalSize += stagingResult.size; - + // Clean temporary databases const tempDbResult = await this.cleanTemporaryDatabases(force, verbose); cleanedItems += tempDbResult.items; totalSize += tempDbResult.size; - + // Clean backup files (older than 30 days) const backupResult = await this.cleanOldBackups(force, verbose); cleanedItems += backupResult.items; totalSize += backupResult.size; - + // Clean log files const logResult = await this.cleanLogFiles(force, verbose); cleanedItems += logResult.items; totalSize += logResult.size; - + // Display results this.displayCleanupResults(cleanedItems, totalSize); - - this.emit('complete', { - cleanedItems, - totalSize: this.formatBytes(totalSize) + + this.emit('complete', { + cleanedItems, + totalSize: this.formatBytes(totalSize) }); - } catch (error) { this.error('Migration cleanup failed', error); this.emit('failed', { error }); throw error; } } - + /** * Clean staging directory */ async cleanStagingDirectory(force, verbose) { let items = 0; let size = 0; - + try { const stagingDir = path.resolve('supabase/.staging'); - const stagingExists = await fs.access(stagingDir).then(() => true).catch(() => false); - + const stagingExists = await fs + .access(stagingDir) + .then(() => true) + .catch(() => false); + if (!stagingExists) { if (verbose) this.progress('Staging directory not found, skipping...'); return { items, size }; } - + const files = await fs.readdir(stagingDir); - - await Promise.all(files.map(async file => { - const filePath = path.join(stagingDir, file); - const stats = await fs.stat(filePath); - - if (force || await this.shouldCleanFile(filePath, stats)) { - size += stats.size; - await fs.unlink(filePath); - items++; - - if (verbose) { - this.progress(`Cleaned: ${file} (${this.formatBytes(stats.size)})`); + + await Promise.all( + files.map(async (file) => { + const filePath = path.join(stagingDir, file); + const stats = await fs.stat(filePath); + + if (force || (await this.shouldCleanFile(filePath, stats))) { + size += stats.size; + await fs.unlink(filePath); + items++; + + if (verbose) { + this.progress(`Cleaned: ${file} (${this.formatBytes(stats.size)})`); + } } - } - })); - + }) + ); + // Remove directory if empty const remainingFiles = await fs.readdir(stagingDir); if (remainingFiles.length === 0) { await fs.rmdir(stagingDir); if (verbose) this.progress('Removed empty staging directory'); } - } catch (error) { this.warn('Could not clean staging directory', { error: error.message }); } - + return { items, size }; } - + /** * Clean temporary databases */ async cleanTemporaryDatabases(force, verbose) { let items = 0; let size = 0; - + try { const tempDbDir = path.resolve('supabase/.temp_dbs'); - const tempDbExists = await fs.access(tempDbDir).then(() => true).catch(() => false); - + const tempDbExists = await fs + .access(tempDbDir) + .then(() => true) + .catch(() => false); + if (!tempDbExists) { if (verbose) this.progress('Temp databases directory not found, skipping...'); return { items, size }; } - + const files = await fs.readdir(tempDbDir); - + for (const file of files) { if (file.startsWith('test_') || file.startsWith('temp_')) { const filePath = path.join(tempDbDir, file); const stats = await fs.stat(filePath); - + size += stats.size; await fs.unlink(filePath); items++; - + if (verbose) { this.progress(`Cleaned temp DB: ${file} (${this.formatBytes(stats.size)})`); } } } - } catch (error) { this.warn('Could not clean temporary databases', { error: error.message }); } - + return { items, size }; } - + /** * Clean old backup files */ async cleanOldBackups(force, verbose) { let items = 0; let size = 0; - + try { const backupDir = path.resolve('supabase/.rollbacks'); - const backupExists = await fs.access(backupDir).then(() => true).catch(() => false); - + const backupExists = await fs + .access(backupDir) + .then(() => true) + .catch(() => false); + if (!backupExists) { if (verbose) this.progress('Backup directory not found, skipping...'); return { items, size }; } - + const files = await fs.readdir(backupDir); - const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000); - + const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1000; + for (const file of files) { const filePath = path.join(backupDir, file); const stats = await fs.stat(filePath); - + if (force || stats.mtime.getTime() < thirtyDaysAgo) { size += stats.size; await fs.unlink(filePath); items++; - + if (verbose) { this.progress(`Cleaned old backup: ${file} (${this.formatBytes(stats.size)})`); } } } - } catch (error) { this.warn('Could not clean backup files', { error: error.message }); } - + return { items, size }; } - + /** * Clean log files */ async cleanLogFiles(force, verbose) { let items = 0; let size = 0; - + try { - const logPatterns = [ - 'supabase/.logs/**/*.log', - 'supabase/logs/**/*.log', - '*.log' - ]; - + const logPatterns = ['supabase/.logs/**/*.log', 'supabase/logs/**/*.log', '*.log']; + // This is a simplified implementation // In a real system, would use glob patterns to find log files - const possibleLogFiles = [ - 'supabase/migration.log', - 'supabase/error.log', - 'data.log' - ]; - + const possibleLogFiles = ['supabase/migration.log', 'supabase/error.log', 'data.log']; + for (const logFile of possibleLogFiles) { try { const filePath = path.resolve(logFile); const stats = await fs.stat(filePath); - - if (force || stats.size > 10 * 1024 * 1024) { // > 10MB + + if (force || stats.size > 10 * 1024 * 1024) { + // > 10MB size += stats.size; await fs.unlink(filePath); items++; - + if (verbose) { this.progress(`Cleaned log: ${logFile} (${this.formatBytes(stats.size)})`); } @@ -235,23 +238,22 @@ class MigrateCleanCommand extends Command { // File doesn't exist, skip } } - } catch (error) { this.warn('Could not clean log files', { error: error.message }); } - + return { items, size }; } - + /** * Check if file should be cleaned based on age and other criteria */ async shouldCleanFile(filePath, stats) { // Clean files older than 24 hours - const twentyFourHoursAgo = Date.now() - (24 * 60 * 60 * 1000); + const twentyFourHoursAgo = Date.now() - 24 * 60 * 60 * 1000; return stats.mtime.getTime() < twentyFourHoursAgo; } - + /** * Display cleanup results */ @@ -260,7 +262,7 @@ class MigrateCleanCommand extends Command { console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n'); console.log(`Files cleaned: ${cleanedItems}`); console.log(`Space freed: ${this.formatBytes(totalSize)}`); - + if (cleanedItems === 0) { console.log('\nโœจ Nothing to clean - your migration workspace is already tidy!'); } else { @@ -268,19 +270,32 @@ class MigrateCleanCommand extends Command { } console.log(''); } - + /** * Format bytes to human readable string */ formatBytes(bytes) { if (bytes === 0) return '0 B'; - + const k = 1024; const sizes = ['B', 'KB', 'MB', 'GB']; const i = Math.floor(Math.log(bytes) / Math.log(k)); - + return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]; } } -module.exports = MigrateCleanCommand; \ No newline at end of file +/** + * Migration clean handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Clean result + */ +export default async function cleanHandler(args, config, logger, isProd) { + const command = new MigrateCleanCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateCleanCommand }; diff --git a/src/commands/db/migrate/generate.js b/starfleet/data-cli/src/commands/db/migrate/generate.js similarity index 81% rename from src/commands/db/migrate/generate.js rename to starfleet/data-cli/src/commands/db/migrate/generate.js index 75030dc..93c1775 100644 --- a/src/commands/db/migrate/generate.js +++ b/starfleet/data-cli/src/commands/db/migrate/generate.js @@ -1,25 +1,26 @@ -const Command = require('../../../lib/Command'); -const MigrationMetadata = require('../../../lib/MigrationMetadata'); -const fs = require('fs').promises; -const path = require('path'); +import Command from '../../../lib/Command.js'; +import MigrationMetadata from '../../../lib/MigrationMetadata.js'; +import { promises as fs } from 'fs'; +import path from 'path'; /** * MigrateGenerateCommand - Generate migration from schema diff - * + * * Creates a new migration by comparing current database state with desired state * from compiled source SQL files. Uses DiffEngine for schema analysis. - * + * * Options: * --name Migration name (required) - * --skip-compile Skip source compilation step + * --skip-compile Skip source compilation step * --dry-run Show diff without saving migration * --current-db Current database URL (defaults to local) * --desired-db Desired database URL (defaults to compiled SQL) + * @class */ class MigrateGenerateCommand extends Command { static description = 'Generate migration from schema diff'; static requiresConfirmation = false; // Generation is safe operation - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = false; // Safe in production @@ -32,7 +33,7 @@ class MigrateGenerateCommand extends Command { try { // Parse command line options const options = this.parseOptions(args); - + this.progress('Starting migration generation', { migrationName: options.name, dryRun: options.dryRun, @@ -53,7 +54,7 @@ class MigrateGenerateCommand extends Command { } else { // Save migration to staging directory const migrationPath = await this.saveToStaging(migration, options.name); - + this.success('Migration generated successfully', { migrationName: options.name, path: migrationPath, @@ -63,11 +64,10 @@ class MigrateGenerateCommand extends Command { } return migration; - } catch (error) { this.error('Failed to generate migration', error, { operation: 'generate', - args: args + args }); throw error; } @@ -96,7 +96,8 @@ INSERT INTO example_table (name) VALUES ('test_data'); this.progress('Generated placeholder migration SQL'); - const migrationSql = this.generateMigrationHeader(name, { stats: { filesProcessed: 1 } }) + '\n' + placeholder; + const migrationSql = + this.generateMigrationHeader(name, { stats: { filesProcessed: 1 } }) + '\n' + placeholder; return { name, @@ -110,7 +111,6 @@ INSERT INTO example_table (name) VALUES ('test_data'); }, generatedAt: new Date().toISOString() }; - } catch (error) { this.error('Failed to generate migration', error, { migrationName: name @@ -143,7 +143,7 @@ INSERT INTO example_table (name) VALUES ('test_data'); // Create and write metadata const migrationId = this.generateMigrationId(name); const metadata = MigrationMetadata.createDefault(migrationId, name); - + // Add generation details to metadata metadata.generation = { generated_at: migration.generatedAt, @@ -163,7 +163,6 @@ INSERT INTO example_table (name) VALUES ('test_data'); }); return migrationDir; - } catch (error) { this.error('Failed to save migration to staging', error, { migrationName: name @@ -179,7 +178,7 @@ INSERT INTO example_table (name) VALUES ('test_data'); this.progress('='.repeat(60)); this.progress(`DRY RUN: Migration "${migration.name}"`); this.progress('='.repeat(60)); - + if (migration.hasDifferences) { this.progress(`Found ${migration.statements.length} schema differences:`); this.progress(''); @@ -187,7 +186,7 @@ INSERT INTO example_table (name) VALUES ('test_data'); } else { this.progress('No schema differences detected.'); } - + this.progress('='.repeat(60)); this.progress('Dry run complete - no files were created'); } @@ -198,7 +197,7 @@ INSERT INTO example_table (name) VALUES ('test_data'); generateMigrationHeader(name, compileResult) { const timestamp = new Date().toISOString(); const sourceFiles = compileResult?.stats?.filesProcessed || 0; - + return `-- ========================================================================= -- MIGRATION: ${name} - Generated by data CLI -- ========================================================================= @@ -220,9 +219,9 @@ INSERT INTO example_table (name) VALUES ('test_data'); // Simple parsing - split on semicolons and filter return sql .split(';') - .map(stmt => stmt.trim()) - .filter(stmt => stmt.length > 0 && !stmt.startsWith('--')) - .map(stmt => stmt + ';'); + .map((stmt) => stmt.trim()) + .filter((stmt) => stmt.length > 0 && !stmt.startsWith('--')) + .map((stmt) => stmt + ';'); } /** @@ -239,46 +238,46 @@ INSERT INTO example_table (name) VALUES ('test_data'); for (let i = 0; i < args.length; i++) { const arg = args[i]; - + switch (arg) { - case '--name': - if (i + 1 >= args.length) { - throw new Error('--name requires a value'); - } - options.name = args[++i]; - break; - - case '--dry-run': - options.dryRun = true; - break; - - case '--skip-compile': - options.skipCompile = true; - break; - - case '--current-db': - if (i + 1 >= args.length) { - throw new Error('--current-db requires a value'); - } - options.currentDb = args[++i]; - break; - - case '--desired-db': - if (i + 1 >= args.length) { - throw new Error('--desired-db requires a value'); - } - options.desiredDb = args[++i]; - break; - - default: - if (arg.startsWith('--')) { - throw new Error(`Unknown option: ${arg}`); - } - // If no option flag, treat as migration name if not set - if (!options.name) { - options.name = arg; - } - break; + case '--name': + if (i + 1 >= args.length) { + throw new Error('--name requires a value'); + } + options.name = args[++i]; + break; + + case '--dry-run': + options.dryRun = true; + break; + + case '--skip-compile': + options.skipCompile = true; + break; + + case '--current-db': + if (i + 1 >= args.length) { + throw new Error('--current-db requires a value'); + } + options.currentDb = args[++i]; + break; + + case '--desired-db': + if (i + 1 >= args.length) { + throw new Error('--desired-db requires a value'); + } + options.desiredDb = args[++i]; + break; + + default: + if (arg.startsWith('--')) { + throw new Error(`Unknown option: ${arg}`); + } + // If no option flag, treat as migration name if not set + if (!options.name) { + options.name = arg; + } + break; } } @@ -311,7 +310,7 @@ INSERT INTO example_table (name) VALUES ('test_data'); } /** - * Get staging directory path + * Get staging directory path */ getStagingDirectory() { // Use config paths if available, otherwise default to 'migrations-staging' in current directory @@ -359,4 +358,17 @@ INSERT INTO example_table (name) VALUES ('test_data'); } } -module.exports = MigrateGenerateCommand; \ No newline at end of file +/** + * Generate migration from schema diff handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Migration generation result + */ +export default async function generateHandler(args, config, logger, isProd) { + const command = new MigrateGenerateCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateGenerateCommand }; diff --git a/src/commands/db/migrate/history.js b/starfleet/data-cli/src/commands/db/migrate/history.js similarity index 70% rename from src/commands/db/migrate/history.js rename to starfleet/data-cli/src/commands/db/migrate/history.js index d1b37f5..1d87667 100644 --- a/src/commands/db/migrate/history.js +++ b/starfleet/data-cli/src/commands/db/migrate/history.js @@ -2,16 +2,19 @@ * Migration History Command */ -const Command = require('../../../lib/Command'); -const fs = require('fs').promises; -const path = require('path'); +import Command from '../../../lib/Command.js'; +import { promises as fs } from 'fs'; +import path from 'path'; /** * Show migration history and timeline */ +/** + * @class + */ class MigrateHistoryCommand extends Command { static description = 'Show migration history'; - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = false; // Read-only operation @@ -22,17 +25,17 @@ class MigrateHistoryCommand extends Command { */ async performExecute(args = {}) { this.emit('start'); - + try { const limit = parseInt(args.limit || args.l || '20'); const format = args.format || args.f || 'table'; const filter = args.filter || args.action || null; - + this.progress('Loading migration history...'); - + // Load history from file const history = await this.loadMigrationHistory(); - + if (!history || history.length === 0) { this.warn('No migration history found'); console.log('\n๐Ÿ“‹ No migration history available'); @@ -40,59 +43,58 @@ class MigrateHistoryCommand extends Command { this.emit('complete', { count: 0 }); return; } - + // Filter history if requested - const filteredHistory = filter ? - history.filter(entry => entry.action === filter) : - history; - + const filteredHistory = filter ? history.filter((entry) => entry.action === filter) : history; + // Limit results const limitedHistory = filteredHistory.slice(-limit).reverse(); - + // Display history this.displayMigrationHistory(limitedHistory, format); - - this.emit('complete', { - total: history.length, + + this.emit('complete', { + total: history.length, displayed: limitedHistory.length, - filter + filter }); - } catch (error) { this.error('Migration history display failed', error); this.emit('failed', { error }); throw error; } } - + /** * Load migration history from file */ async loadMigrationHistory() { try { const historyFile = path.resolve('supabase/.migration_history.json'); - const historyExists = await fs.access(historyFile).then(() => true).catch(() => false); - + const historyExists = await fs + .access(historyFile) + .then(() => true) + .catch(() => false); + if (!historyExists) { return []; } - + const historyContent = await fs.readFile(historyFile, 'utf8'); return JSON.parse(historyContent); - } catch (error) { this.warn('Could not load migration history', { error: error.message }); return []; } } - + /** * Display migration history in requested format */ displayMigrationHistory(history, format) { console.log('\n๐Ÿ“‹ Migration History'); console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n'); - + if (format === 'json') { this.displayJsonFormat(history); } else if (format === 'timeline') { @@ -100,10 +102,10 @@ class MigrateHistoryCommand extends Command { } else { this.displayTableFormat(history); } - + console.log(''); } - + /** * Display history in table format */ @@ -112,33 +114,44 @@ class MigrateHistoryCommand extends Command { console.log('No entries to display'); return; } - + // Calculate column widths - const maxAction = Math.max(6, ...history.map(h => h.action.length)); - const maxMigration = Math.max(9, ...history.map(h => (h.migration || '').length)); - const maxStatus = Math.max(6, ...history.map(h => (h.status || '').length)); - + const maxAction = Math.max(6, ...history.map((h) => h.action.length)); + const maxMigration = Math.max(9, ...history.map((h) => (h.migration || '').length)); + const maxStatus = Math.max(6, ...history.map((h) => (h.status || '').length)); + // Header console.log( - 'Action'.padEnd(maxAction) + ' โ”‚ ' + - 'Migration'.padEnd(maxMigration) + ' โ”‚ ' + - 'Status'.padEnd(maxStatus) + ' โ”‚ ' + - 'Timestamp' + 'Action'.padEnd(maxAction) + + ' โ”‚ ' + + 'Migration'.padEnd(maxMigration) + + ' โ”‚ ' + + 'Status'.padEnd(maxStatus) + + ' โ”‚ ' + + 'Timestamp' ); - - console.log('โ”€'.repeat(maxAction) + 'โ”€โ”ผโ”€' + 'โ”€'.repeat(maxMigration) + 'โ”€โ”ผโ”€' + 'โ”€'.repeat(maxStatus) + 'โ”€โ”ผโ”€' + 'โ”€'.repeat(19)); - + + console.log( + 'โ”€'.repeat(maxAction) + + 'โ”€โ”ผโ”€' + + 'โ”€'.repeat(maxMigration) + + 'โ”€โ”ผโ”€' + + 'โ”€'.repeat(maxStatus) + + 'โ”€โ”ผโ”€' + + 'โ”€'.repeat(19) + ); + // Rows - history.forEach(entry => { + history.forEach((entry) => { const action = this.colorizeAction(entry.action); const migration = (entry.migration || '').padEnd(maxMigration); const status = this.colorizeStatus(entry.status || '').padEnd(maxStatus); const timestamp = new Date(entry.timestamp).toLocaleString(); - + console.log(`${action.padEnd(maxAction)} โ”‚ ${migration} โ”‚ ${status} โ”‚ ${timestamp}`); }); } - + /** * Display history in timeline format */ @@ -147,29 +160,31 @@ class MigrateHistoryCommand extends Command { const isLast = index === history.length - 1; const connector = isLast ? 'โ””โ”€' : 'โ”œโ”€'; const line = isLast ? ' ' : 'โ”‚ '; - + const actionIcon = this.getActionIcon(entry.action); const statusColor = this.colorizeStatus(entry.status || 'unknown'); - - console.log(`${connector} ${actionIcon} ${entry.action.toUpperCase()}: ${entry.migration || 'Unknown'}`); + + console.log( + `${connector} ${actionIcon} ${entry.action.toUpperCase()}: ${entry.migration || 'Unknown'}` + ); console.log(`${line} Status: ${statusColor}`); console.log(`${line} Time: ${new Date(entry.timestamp).toLocaleString()}`); - + if (entry.details) { console.log(`${line} Details: ${entry.details}`); } - + if (!isLast) console.log('โ”‚'); }); } - + /** * Display history in JSON format */ displayJsonFormat(history) { console.log(JSON.stringify(history, null, 2)); } - + /** * Get icon for action type */ @@ -182,10 +197,10 @@ class MigrateHistoryCommand extends Command { clean: '๐Ÿงน', verify: 'โœ…' }; - + return icons[action] || '๐Ÿ“'; } - + /** * Colorize action text (simplified - would use chalk in real implementation) */ @@ -193,30 +208,43 @@ class MigrateHistoryCommand extends Command { // In a real implementation, would use chalk or similar for colors const colors = { generate: action, // blue - test: action, // yellow - promote: action, // green + test: action, // yellow + promote: action, // green rollback: action, // red - clean: action, // magenta - verify: action // cyan + clean: action, // magenta + verify: action // cyan }; - + return colors[action] || action; } - + /** * Colorize status text (simplified - would use chalk in real implementation) */ colorizeStatus(status) { // In a real implementation, would use chalk or similar for colors const colors = { - completed: status, // green - failed: status, // red - pending: status, // yellow - running: status // blue + completed: status, // green + failed: status, // red + pending: status, // yellow + running: status // blue }; - + return colors[status] || status; } } -module.exports = MigrateHistoryCommand; \ No newline at end of file +/** + * Migration history handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} History result + */ +export default async function historyHandler(args, config, logger, isProd) { + const command = new MigrateHistoryCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateHistoryCommand }; diff --git a/starfleet/data-cli/src/commands/db/migrate/index.js b/starfleet/data-cli/src/commands/db/migrate/index.js new file mode 100644 index 0000000..53e1468 --- /dev/null +++ b/starfleet/data-cli/src/commands/db/migrate/index.js @@ -0,0 +1,27 @@ +/** + * Migration Commands Index + * + * Exports all migration subcommands for the data CLI + */ + +import { MigrateStatusCommand } from './status.js'; +import { MigrateRollbackCommand } from './rollback.js'; +import { MigrateCleanCommand } from './clean.js'; +import { MigrateHistoryCommand } from './history.js'; +import { MigrateVerifyCommand } from './verify.js'; +import { MigrateSquashCommand } from './squash.js'; +import { MigrateGenerateCommand } from './generate.js'; +import { MigrateTestCommand } from './test.js'; +import { MigrateTestCommand as MigrateTestV2Command } from './test-v2.js'; + +export { + MigrateStatusCommand, + MigrateRollbackCommand, + MigrateCleanCommand, + MigrateHistoryCommand, + MigrateVerifyCommand, + MigrateSquashCommand, + MigrateGenerateCommand, + MigrateTestCommand, + MigrateTestV2Command +}; diff --git a/src/commands/db/migrate/promote.js b/starfleet/data-cli/src/commands/db/migrate/promote.js similarity index 86% rename from src/commands/db/migrate/promote.js rename to starfleet/data-cli/src/commands/db/migrate/promote.js index 2deabe7..c494041 100644 --- a/src/commands/db/migrate/promote.js +++ b/starfleet/data-cli/src/commands/db/migrate/promote.js @@ -3,18 +3,20 @@ * Promotes tested migrations from staging to production with safety checks */ -const Command = require('../../../lib/Command'); -const MigrationMetadata = require('../../../lib/MigrationMetadata'); -const fs = require('fs').promises; -const path = require('path'); +import Command from '../../../lib/Command.js'; +import MigrationMetadata from '../../../lib/MigrationMetadata.js'; +import { promises as fs, statSync } from 'fs'; +import path from 'path'; +import { spawn } from 'child_process'; /** * Command to promote a tested migration to production + * @class */ class MigratePromoteCommand extends Command { static description = 'Promote tested migration to production'; static requiresConfirmation = true; - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = true; @@ -25,35 +27,34 @@ class MigratePromoteCommand extends Command { */ async performExecute(args = {}) { this.emit('start'); - + try { // Get migration path from arguments const migrationName = args.migration || args.m || 'current'; const stagingPath = this.getStagingPath(migrationName); - + this.progress(`Promoting migration: ${migrationName}`); - + // 1. Verify tests passed in metadata await this.verifyTestsPassed(stagingPath); - + // 2. Move from staging to production const productionPath = await this.promoteToProduction(stagingPath); - + // 3. Update migration history await this.updateHistory(stagingPath, productionPath); - + // 4. Optionally stage in Git if (args.git !== false) { await this.stageInGit(productionPath); } - + this.success(`Migration promoted successfully: ${path.basename(productionPath)}`); - this.emit('complete', { - staging: stagingPath, + this.emit('complete', { + staging: stagingPath, production: productionPath, migration: migrationName }); - } catch (error) { this.error('Migration promotion failed', error); this.emit('failed', { error, migration: args.migration }); @@ -66,11 +67,11 @@ class MigratePromoteCommand extends Command { */ getStagingPath(migrationName) { const supabaseRoot = this.findSupabaseRoot(); - + if (migrationName === 'current') { return path.join(supabaseRoot, 'migrations-staging', 'current'); } - + return path.join(supabaseRoot, 'migrations-staging', migrationName); } @@ -79,32 +80,36 @@ class MigratePromoteCommand extends Command { */ async verifyTestsPassed(migrationPath) { this.progress('Verifying migration tests passed...'); - + try { // Check if migration directory exists const stats = await fs.stat(migrationPath); if (!stats.isDirectory()) { throw new Error(`Migration path is not a directory: ${migrationPath}`); } - + // Load and check metadata const metadata = new MigrationMetadata(migrationPath); const data = metadata.read(); - + // Check if migration has been tested if (data.status !== 'tested') { - throw new Error(`Migration must be tested before promotion. Current status: ${data.status}`); + throw new Error( + `Migration must be tested before promotion. Current status: ${data.status}` + ); } - + // Check if tests passed if (!data.testing || data.testing.tested_at === null) { throw new Error('No test results found in migration metadata'); } - + if (data.testing.tests_failed > 0) { - throw new Error(`Migration has failing tests: ${data.testing.tests_failed} failed, ${data.testing.tests_passed} passed`); + throw new Error( + `Migration has failing tests: ${data.testing.tests_failed} failed, ${data.testing.tests_passed} passed` + ); } - + if (data.testing.tests_passed === 0) { this.warn('Warning: No tests were run for this migration'); const proceed = await this.confirm('Proceed with promotion despite no tests?', false); @@ -112,10 +117,11 @@ class MigratePromoteCommand extends Command { throw new Error('Promotion cancelled - no tests run'); } } - - this.progress(`Tests verified: ${data.testing.tests_passed} passed, ${data.testing.tests_failed} failed`); + + this.progress( + `Tests verified: ${data.testing.tests_passed} passed, ${data.testing.tests_failed} failed` + ); return data; - } catch (error) { if (error.code === 'ENOENT') { throw new Error(`Migration not found: ${migrationPath}`); @@ -129,19 +135,19 @@ class MigratePromoteCommand extends Command { */ async promoteToProduction(stagingPath) { this.progress('Moving migration to production directory...'); - + const supabaseRoot = this.findSupabaseRoot(); const migrationFileName = await this.generateMigrationFileName(stagingPath); const productionDir = path.join(supabaseRoot, 'migrations'); const productionPath = path.join(productionDir, migrationFileName); - + // Ensure production directory exists try { await fs.mkdir(productionDir, { recursive: true }); } catch (error) { // Directory already exists, continue } - + // Check if production file already exists try { await fs.access(productionPath); @@ -151,11 +157,11 @@ class MigratePromoteCommand extends Command { throw error; } } - + // Copy migration SQL file const stagingSqlPath = path.join(stagingPath, 'migration.sql'); await fs.copyFile(stagingSqlPath, productionPath); - + this.progress(`Migration copied to: ${productionPath}`); return productionPath; } @@ -167,7 +173,7 @@ class MigratePromoteCommand extends Command { // Load metadata to get the migration name const metadata = new MigrationMetadata(stagingPath); const data = metadata.read(); - + // Generate timestamp in YYYYMMDD_HHMMSS format const now = new Date(); const year = now.getFullYear(); @@ -176,10 +182,10 @@ class MigratePromoteCommand extends Command { const hour = String(now.getHours()).padStart(2, '0'); const minute = String(now.getMinutes()).padStart(2, '0'); const second = String(now.getSeconds()).padStart(2, '0'); - + const timestamp = `${year}${month}${day}_${hour}${minute}${second}`; const safeName = data.name.toLowerCase().replace(/[^a-z0-9_]/g, '_'); - + return `${timestamp}_${safeName}.sql`; } @@ -188,14 +194,14 @@ class MigratePromoteCommand extends Command { */ async updateHistory(stagingPath, productionPath) { this.progress('Updating migration history...'); - + const supabaseRoot = this.findSupabaseRoot(); const historyPath = path.join(supabaseRoot, 'migrations', 'history.json'); - + // Load metadata const metadata = new MigrationMetadata(stagingPath); const data = metadata.read(); - + // Create history entry const historyEntry = { id: data.id, @@ -208,7 +214,7 @@ class MigratePromoteCommand extends Command { tests_passed: data.testing.tests_passed, tests_failed: data.testing.tests_failed }; - + // Load or create history file let history = []; try { @@ -219,14 +225,14 @@ class MigratePromoteCommand extends Command { this.warn(`Could not read existing history: ${error.message}`); } } - + // Add new entry and sort by promoted_at history.push(historyEntry); history.sort((a, b) => new Date(b.promoted_at) - new Date(a.promoted_at)); - + // Write updated history await fs.writeFile(historyPath, JSON.stringify(history, null, 2), 'utf8'); - + // Update staging metadata to promoted status metadata.update({ status: 'promoted', @@ -235,7 +241,7 @@ class MigratePromoteCommand extends Command { promoted_by: historyEntry.promoted_by } }); - + this.progress('Migration history updated'); } @@ -244,14 +250,12 @@ class MigratePromoteCommand extends Command { */ async stageInGit(productionPath) { this.progress('Staging migration in Git...'); - - const { spawn } = require('child_process'); - - return new Promise((resolve, reject) => { + + return new Promise((resolve, _reject) => { const git = spawn('git', ['add', productionPath], { stdio: ['ignore', 'pipe', 'pipe'] }); - + git.on('close', (code) => { if (code === 0) { this.progress('Migration staged in Git'); @@ -261,7 +265,7 @@ class MigratePromoteCommand extends Command { resolve(); // Don't fail promotion for Git issues } }); - + git.on('error', (error) => { this.warn(`Git staging failed: ${error.message}`); resolve(); // Don't fail promotion for Git issues @@ -281,18 +285,20 @@ class MigratePromoteCommand extends Command { */ findSupabaseRoot() { let currentDir = process.cwd(); - + while (currentDir !== path.dirname(currentDir)) { const supabasePath = path.join(currentDir, 'supabase'); try { - require('fs').statSync(supabasePath); + statSync(supabasePath); return supabasePath; } catch { currentDir = path.dirname(currentDir); } } - - throw new Error('Could not find supabase directory. Run this command from within a Supabase project.'); + + throw new Error( + 'Could not find supabase directory. Run this command from within a Supabase project.' + ); } /** @@ -320,4 +326,17 @@ class MigratePromoteCommand extends Command { } } -module.exports = MigratePromoteCommand; \ No newline at end of file +/** + * Promote tested migration to production handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Promotion result + */ +export default async function promoteHandler(args, config, logger, isProd) { + const command = new MigratePromoteCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigratePromoteCommand }; diff --git a/src/commands/db/migrate/rollback.js b/starfleet/data-cli/src/commands/db/migrate/rollback.js similarity index 80% rename from src/commands/db/migrate/rollback.js rename to starfleet/data-cli/src/commands/db/migrate/rollback.js index e14f812..9c393cb 100644 --- a/src/commands/db/migrate/rollback.js +++ b/starfleet/data-cli/src/commands/db/migrate/rollback.js @@ -2,17 +2,20 @@ * Migration Rollback Command */ -const DatabaseCommand = require('../../../lib/DatabaseCommand'); -const fs = require('fs').promises; -const path = require('path'); +import DatabaseCommand from '../../../lib/DatabaseCommand.js'; +import { promises as fs } from 'fs'; +import path from 'path'; /** * Rollback migration to previous state with confirmation */ +/** + * @class + */ class MigrateRollbackCommand extends DatabaseCommand { static description = 'Rollback migration to previous state'; static requiresConfirmation = true; - + constructor(databaseUrl, serviceRoleKey = null, anonKey = null, logger = null, isProd = false) { // Rollback is destructive, always requires confirmation super(databaseUrl, serviceRoleKey, anonKey, logger, isProd, true); @@ -23,21 +26,21 @@ class MigrateRollbackCommand extends DatabaseCommand { */ async performExecute(args = {}) { this.emit('start'); - + try { const target = args.target || args.to || 'previous'; - + this.progress(`Preparing rollback to: ${target}...`); - + // Get rollback target information const rollbackInfo = await this.getRollbackTarget(target); - + if (!rollbackInfo) { this.error('No valid rollback target found'); this.emit('failed', { error: 'No rollback target' }); return; } - + // Additional confirmation for rollback const confirmed = await this.confirmRollback(rollbackInfo); if (!confirmed) { @@ -45,61 +48,62 @@ class MigrateRollbackCommand extends DatabaseCommand { this.emit('cancelled', { target }); return; } - + // Perform rollback await this.performRollback(rollbackInfo); - + // Update history await this.recordRollback(rollbackInfo); - + this.success(`Migration rollback completed to: ${rollbackInfo.migration}`); this.emit('complete', { target: rollbackInfo.migration }); - } catch (error) { this.error('Migration rollback failed', error); this.emit('failed', { error }); throw error; } } - + /** * Get rollback target migration */ async getRollbackTarget(target) { try { const historyFile = path.resolve('supabase/.migration_history.json'); - const historyExists = await fs.access(historyFile).then(() => true).catch(() => false); - + const historyExists = await fs + .access(historyFile) + .then(() => true) + .catch(() => false); + if (!historyExists) { this.warn('No migration history found'); return null; } - + const historyContent = await fs.readFile(historyFile, 'utf8'); const history = JSON.parse(historyContent); - + // Get promotions only - const promotions = history.filter(entry => entry.action === 'promote'); - + const promotions = history.filter((entry) => entry.action === 'promote'); + if (promotions.length === 0) { this.warn('No promoted migrations found'); return null; } - + if (target === 'previous' || target === 'last') { // Get second-to-last promotion return promotions.length > 1 ? promotions[promotions.length - 2] : null; } - + // Find specific migration - return promotions.find(p => p.migration === target) || null; - + return promotions.find((p) => p.migration === target) || null; } catch (error) { this.warn('Could not determine rollback target', { error: error.message }); return null; } } - + /** * Confirm rollback operation with details */ @@ -112,42 +116,45 @@ class MigrateRollbackCommand extends DatabaseCommand { console.log('\nโš ๏ธ This will PERMANENTLY rollback your database state!'); console.log('โš ๏ธ Make sure you have a backup before proceeding!'); console.log(''); - - return await this.confirm('Are you absolutely sure you want to rollback?', false); + + return this.confirm('Are you absolutely sure you want to rollback?', false); } - + /** * Perform the actual rollback */ async performRollback(rollbackInfo) { this.progress('Creating backup before rollback...'); - + // In a real implementation, this would: // 1. Create a backup of current state // 2. Generate rollback SQL from migration history // 3. Execute rollback against database // 4. Verify rollback success - + // For now, simulate the process await this.sleep(1000); this.progress('Generating rollback SQL...'); - + await this.sleep(1000); this.progress('Executing rollback against database...'); - + await this.sleep(1000); this.progress('Verifying rollback completion...'); - + // Simulate rollback file creation const rollbackDir = path.resolve('supabase/.rollbacks'); await fs.mkdir(rollbackDir, { recursive: true }); - + const rollbackFile = path.join(rollbackDir, `rollback_${Date.now()}.sql`); - await fs.writeFile(rollbackFile, `-- Rollback to ${rollbackInfo.migration}\n-- Generated: ${new Date().toISOString()}\n`); - + await fs.writeFile( + rollbackFile, + `-- Rollback to ${rollbackInfo.migration}\n-- Generated: ${new Date().toISOString()}\n` + ); + this.progress(`Rollback SQL saved to: ${rollbackFile}`); } - + /** * Record rollback in history */ @@ -156,7 +163,7 @@ class MigrateRollbackCommand extends DatabaseCommand { const historyFile = path.resolve('supabase/.migration_history.json'); const historyContent = await fs.readFile(historyFile, 'utf8'); const history = JSON.parse(historyContent); - + // Add rollback record history.push({ action: 'rollback', @@ -165,21 +172,33 @@ class MigrateRollbackCommand extends DatabaseCommand { timestamp: new Date().toISOString(), status: 'completed' }); - + await fs.writeFile(historyFile, JSON.stringify(history, null, 2)); this.progress('Rollback recorded in migration history'); - } catch (error) { this.warn('Could not update migration history', { error: error.message }); } } - + /** * Sleep utility for simulation */ sleep(ms) { - return new Promise(resolve => setTimeout(resolve, ms)); + return new Promise((resolve) => setTimeout(resolve, ms)); } } -module.exports = MigrateRollbackCommand; \ No newline at end of file +/** + * Migration rollback handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Rollback result + */ +export default async function rollbackHandler(args, config, logger, isProd) { + const command = new MigrateRollbackCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateRollbackCommand }; diff --git a/src/commands/db/migrate/squash.js b/starfleet/data-cli/src/commands/db/migrate/squash.js similarity index 59% rename from src/commands/db/migrate/squash.js rename to starfleet/data-cli/src/commands/db/migrate/squash.js index 242b278..0aa1e02 100644 --- a/src/commands/db/migrate/squash.js +++ b/starfleet/data-cli/src/commands/db/migrate/squash.js @@ -2,15 +2,18 @@ * Migration Squash Command */ -const Command = require("../../../lib/Command"); -const fs = require("fs").promises; -const path = require("path"); +import Command from '../../../lib/Command.js'; +import { promises as fs } from 'fs'; +import path from 'path'; /** * Squash multiple migrations into a single migration file */ +/** + * @class + */ class MigrateSquashCommand extends Command { - static description = "Squash multiple migrations"; + static description = 'Squash multiple migrations'; constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); @@ -21,17 +24,17 @@ class MigrateSquashCommand extends Command { * Execute migration squashing */ async performExecute(args = {}) { - this.emit("start"); + this.emit('start'); try { const from = args.from || args.start; - const to = args.to || args.end || "latest"; + const to = args.to || args.end || 'latest'; const outputName = args.output || args.o; - const dryRun = args["dry-run"] || args.n || false; + const dryRun = args['dry-run'] || args.n || false; if (!from) { - this.error("Missing required argument: --from "); - this.emit("failed", { error: "Missing from argument" }); + this.error('Missing required argument: --from '); + this.emit('failed', { error: 'Missing from argument' }); return; } @@ -41,63 +44,49 @@ class MigrateSquashCommand extends Command { const migrationsToSquash = await this.findMigrationsToSquash(from, to); if (migrationsToSquash.length === 0) { - this.warn("No migrations found to squash"); - this.emit("complete", { squashed: 0 }); + this.warn('No migrations found to squash'); + this.emit('complete', { squashed: 0 }); return; } this.progress(`Found ${migrationsToSquash.length} migrations to squash`); // Generate squashed migration content - const squashedContent = await this.generateSquashedMigration( - migrationsToSquash - ); + const squashedContent = await this.generateSquashedMigration(migrationsToSquash); // Create output filename - const outputFilename = - outputName || this.generateSquashedFilename(migrationsToSquash); + const outputFilename = outputName || this.generateSquashedFilename(migrationsToSquash); if (dryRun) { - this.displayDryRunResults( - migrationsToSquash, - outputFilename, - squashedContent - ); - this.emit("complete", { + this.displayDryRunResults(migrationsToSquash, outputFilename, squashedContent); + this.emit('complete', { dryRun: true, - migrations: migrationsToSquash.length, + migrations: migrationsToSquash.length }); return; } // Confirm squash operation - const confirmed = await this.confirmSquashOperation( - migrationsToSquash, - outputFilename - ); + const confirmed = await this.confirmSquashOperation(migrationsToSquash, outputFilename); if (!confirmed) { - this.success("Squash operation cancelled"); - this.emit("cancelled"); + this.success('Squash operation cancelled'); + this.emit('cancelled'); return; } // Perform the squash - await this.performSquash( - migrationsToSquash, - outputFilename, - squashedContent - ); + await this.performSquash(migrationsToSquash, outputFilename, squashedContent); this.success( `Successfully squashed ${migrationsToSquash.length} migrations into ${outputFilename}` ); - this.emit("complete", { + this.emit('complete', { squashed: migrationsToSquash.length, - output: outputFilename, + output: outputFilename }); } catch (error) { - this.error("Migration squash failed", error); - this.emit("failed", { error }); + this.error('Migration squash failed', error); + this.emit('failed', { error }); throw error; } } @@ -107,18 +96,18 @@ class MigrateSquashCommand extends Command { */ async findMigrationsToSquash(from, to) { try { - const migrationsDir = path.resolve("supabase/migrations"); + const migrationsDir = path.resolve('supabase/migrations'); const migrationsExists = await fs .access(migrationsDir) .then(() => true) .catch(() => false); if (!migrationsExists) { - throw new Error("Migrations directory not found"); + throw new Error('Migrations directory not found'); } const files = await fs.readdir(migrationsDir); - const migrationFiles = files.filter((f) => f.endsWith(".sql")).sort(); + const migrationFiles = files.filter((f) => f.endsWith('.sql')).sort(); let startIndex = -1; let endIndex = migrationFiles.length - 1; @@ -136,7 +125,7 @@ class MigrateSquashCommand extends Command { } // Find end index - if (to !== "latest") { + if (to !== 'latest') { for (let i = startIndex + 1; i < migrationFiles.length; i++) { if (migrationFiles[i].includes(to) || migrationFiles[i] === to) { endIndex = i; @@ -155,11 +144,11 @@ class MigrateSquashCommand extends Command { * Generate squashed migration content by combining multiple migrations */ async generateSquashedMigration(migrationFiles) { - const migrationsDir = path.resolve("supabase/migrations"); + const migrationsDir = path.resolve('supabase/migrations'); const squashedParts = []; // Header - squashedParts.push("-- Squashed Migration"); + squashedParts.push('-- Squashed Migration'); squashedParts.push(`-- Generated: ${new Date().toISOString()}`); squashedParts.push(`-- Combines ${migrationFiles.length} migrations:`); @@ -167,32 +156,32 @@ class MigrateSquashCommand extends Command { squashedParts.push(`-- - ${file}`); }); - squashedParts.push(""); - squashedParts.push("BEGIN;"); - squashedParts.push(""); + squashedParts.push(''); + squashedParts.push('BEGIN;'); + squashedParts.push(''); // Combine migration contents for (const file of migrationFiles) { const filePath = path.join(migrationsDir, file); - const content = await fs.readFile(filePath, "utf8"); + const content = await fs.readFile(filePath, 'utf8'); squashedParts.push(`-- === ${file} ===`); // Clean up content (remove individual transactions) const cleanedContent = content - .replace(/^\s*BEGIN\s*;?\s*$/gim, "") - .replace(/^\s*COMMIT\s*;?\s*$/gim, "") + .replace(/^\s*BEGIN\s*;?\s*$/gim, '') + .replace(/^\s*COMMIT\s*;?\s*$/gim, '') .trim(); if (cleanedContent) { squashedParts.push(cleanedContent); - squashedParts.push(""); + squashedParts.push(''); } } - squashedParts.push("COMMIT;"); + squashedParts.push('COMMIT;'); - return squashedParts.join("\n"); + return squashedParts.join('\n'); } /** @@ -201,16 +190,14 @@ class MigrateSquashCommand extends Command { generateSquashedFilename(migrationFiles) { const timestamp = new Date() .toISOString() - .replace(/[-:]/g, "") - .replace(/\..+/, "") + .replace(/[-:]/g, '') + .replace(/\..+/, '') .slice(0, 14); - const firstMigration = migrationFiles[0] - .replace(/^\d{14}_/, "") - .replace(/\.sql$/, ""); + const firstMigration = migrationFiles[0].replace(/^\d{14}_/, '').replace(/\.sql$/, ''); const lastMigration = migrationFiles[migrationFiles.length - 1] - .replace(/^\d{14}_/, "") - .replace(/\.sql$/, ""); + .replace(/^\d{14}_/, '') + .replace(/\.sql$/, ''); if (migrationFiles.length === 2) { return `${timestamp}_squash_${firstMigration}_and_${lastMigration}.sql`; @@ -223,22 +210,22 @@ class MigrateSquashCommand extends Command { * Display dry run results */ displayDryRunResults(migrations, outputFilename, content) { - console.log("\n๐Ÿงช Dry Run - Migration Squash Preview"); - console.log("โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n"); + console.log('\n๐Ÿงช Dry Run - Migration Squash Preview'); + console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n'); console.log(`Migrations to squash (${migrations.length}):`); migrations.forEach((migration, index) => { console.log(` ${index + 1}. ${migration}`); }); - console.log(""); + console.log(''); console.log(`Output file: ${outputFilename}`); console.log(`Content size: ${content.length} characters`); - console.log(""); + console.log(''); - console.log("Preview (first 20 lines):"); - console.log("โ”€".repeat(50)); - const lines = content.split("\n"); + console.log('Preview (first 20 lines):'); + console.log('โ”€'.repeat(50)); + const lines = content.split('\n'); lines.slice(0, 20).forEach((line) => { console.log(line); }); @@ -247,53 +234,53 @@ class MigrateSquashCommand extends Command { console.log(`... (${lines.length - 20} more lines)`); } - console.log("โ”€".repeat(50)); - console.log("\nโœจ This was a dry run - no files were modified"); - console.log("Run without --dry-run to perform the actual squash"); - console.log(""); + console.log('โ”€'.repeat(50)); + console.log('\nโœจ This was a dry run - no files were modified'); + console.log('Run without --dry-run to perform the actual squash'); + console.log(''); } /** * Confirm squash operation */ async confirmSquashOperation(migrations, outputFilename) { - console.log("\nโš ๏ธ MIGRATION SQUASH CONFIRMATION"); - console.log("โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n"); + console.log('\nโš ๏ธ MIGRATION SQUASH CONFIRMATION'); + console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n'); console.log(`Migrations to squash: ${migrations.length}`); migrations.forEach((migration, index) => { console.log(` ${index + 1}. ${migration}`); }); - console.log(""); + console.log(''); console.log(`Output file: ${outputFilename}`); - console.log(""); + console.log(''); - console.log("โš ๏ธ WARNING: This operation will:"); - console.log(" โ€ข Create a new squashed migration file"); - console.log(" โ€ข Archive the original migration files"); - console.log(" โ€ข Update migration history"); - console.log(""); + console.log('โš ๏ธ WARNING: This operation will:'); + console.log(' โ€ข Create a new squashed migration file'); + console.log(' โ€ข Archive the original migration files'); + console.log(' โ€ข Update migration history'); + console.log(''); - console.log("โš ๏ธ Make sure you have backed up your migrations!"); - console.log(""); + console.log('โš ๏ธ Make sure you have backed up your migrations!'); + console.log(''); - return await this.confirm("Proceed with migration squash?", false); + return this.confirm('Proceed with migration squash?', false); } /** * Perform the actual squash operation */ async performSquash(migrations, outputFilename, content) { - const migrationsDir = path.resolve("supabase/migrations"); - const archiveDir = path.resolve("supabase/.migration_archive"); + const migrationsDir = path.resolve('supabase/migrations'); + const archiveDir = path.resolve('supabase/.migration_archive'); // Create archive directory await fs.mkdir(archiveDir, { recursive: true }); // Write squashed migration file const outputPath = path.join(migrationsDir, outputFilename); - await fs.writeFile(outputPath, content, "utf8"); + await fs.writeFile(outputPath, content, 'utf8'); this.progress(`Created squashed migration: ${outputFilename}`); // Archive original migrations @@ -311,7 +298,7 @@ class MigrateSquashCommand extends Command { // Update migration history await this.updateMigrationHistory(migrations, outputFilename); - this.progress("Migration squash completed successfully"); + this.progress('Migration squash completed successfully'); } /** @@ -319,7 +306,7 @@ class MigrateSquashCommand extends Command { */ async updateMigrationHistory(migrations, outputFilename) { try { - const historyFile = path.resolve("supabase/.migration_history.json"); + const historyFile = path.resolve('supabase/.migration_history.json'); let history = []; const historyExists = await fs @@ -327,25 +314,38 @@ class MigrateSquashCommand extends Command { .then(() => true) .catch(() => false); if (historyExists) { - const historyContent = await fs.readFile(historyFile, "utf8"); + const historyContent = await fs.readFile(historyFile, 'utf8'); history = JSON.parse(historyContent); } // Add squash record history.push({ - action: "squash", + action: 'squash', migration: outputFilename, squashedMigrations: migrations, timestamp: new Date().toISOString(), - status: "completed", + status: 'completed' }); await fs.writeFile(historyFile, JSON.stringify(history, null, 2)); - this.progress("Updated migration history"); + this.progress('Updated migration history'); } catch (error) { - this.warn("Could not update migration history", { error: error.message }); + this.warn('Could not update migration history', { error: error.message }); } } } -module.exports = MigrateSquashCommand; +/** + * Migration squash handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Squash result + */ +export default async function squashHandler(args, config, logger, isProd) { + const command = new MigrateSquashCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateSquashCommand }; diff --git a/src/commands/db/migrate/status.js b/starfleet/data-cli/src/commands/db/migrate/status.js similarity index 73% rename from src/commands/db/migrate/status.js rename to starfleet/data-cli/src/commands/db/migrate/status.js index 751e4c8..8ca82bc 100644 --- a/src/commands/db/migrate/status.js +++ b/starfleet/data-cli/src/commands/db/migrate/status.js @@ -2,16 +2,17 @@ * Migration Status Command */ -const Command = require('../../../lib/Command'); -const fs = require('fs').promises; -const path = require('path'); +import Command from '../../../lib/Command.js'; +import { promises as fs } from 'fs'; +import path from 'path'; /** * Show current migration status including staging state and pending migrations + * @class */ class MigrateStatusCommand extends Command { static description = 'Show current migration status'; - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = false; // Read-only operation @@ -22,50 +23,52 @@ class MigrateStatusCommand extends Command { */ async performExecute() { this.emit('start'); - + try { this.progress('Checking migration status...'); - + // Get staging status const stagingStatus = await this.getStagingStatus(); - + // List pending migrations const pendingMigrations = await this.getPendingMigrations(); - + // Get last promoted migration const lastPromoted = await this.getLastPromotedMigration(); - + // Display results this.displayMigrationStatus(stagingStatus, pendingMigrations, lastPromoted); - - this.emit('complete', { - stagingStatus, - pendingMigrations: pendingMigrations.length, - lastPromoted + + this.emit('complete', { + stagingStatus, + pendingMigrations: pendingMigrations.length, + lastPromoted }); - } catch (error) { this.error('Migration status check failed', error); this.emit('failed', { error }); throw error; } } - + /** * Check staging area status */ async getStagingStatus() { try { const stagingDir = path.resolve('supabase/.staging'); - const stagingExists = await fs.access(stagingDir).then(() => true).catch(() => false); - + const stagingExists = await fs + .access(stagingDir) + .then(() => true) + .catch(() => false); + if (!stagingExists) { return { status: 'clean', files: 0 }; } - + const files = await fs.readdir(stagingDir); - return { - status: files.length > 0 ? 'dirty' : 'clean', + return { + status: files.length > 0 ? 'dirty' : 'clean', files: files.length, fileList: files }; @@ -73,77 +76,82 @@ class MigrateStatusCommand extends Command { return { status: 'error', error: error.message }; } } - + /** * Get list of pending migrations */ async getPendingMigrations() { try { const migrationsDir = path.resolve('supabase/migrations'); - const migrationsExists = await fs.access(migrationsDir).then(() => true).catch(() => false); - + const migrationsExists = await fs + .access(migrationsDir) + .then(() => true) + .catch(() => false); + if (!migrationsExists) { return []; } - + const files = await fs.readdir(migrationsDir); - const migrationFiles = files.filter(f => f.endsWith('.sql')); - + const migrationFiles = files.filter((f) => f.endsWith('.sql')); + return migrationFiles.sort(); } catch (error) { this.warn('Could not read migrations directory', { error: error.message }); return []; } } - + /** * Get last promoted migration info */ async getLastPromotedMigration() { try { const historyFile = path.resolve('supabase/.migration_history.json'); - const historyExists = await fs.access(historyFile).then(() => true).catch(() => false); - + const historyExists = await fs + .access(historyFile) + .then(() => true) + .catch(() => false); + if (!historyExists) { return null; } - + const historyContent = await fs.readFile(historyFile, 'utf8'); const history = JSON.parse(historyContent); - + // Find most recent promotion - const promotions = history.filter(entry => entry.action === 'promote'); + const promotions = history.filter((entry) => entry.action === 'promote'); return promotions.length > 0 ? promotions[promotions.length - 1] : null; - } catch (error) { this.warn('Could not read migration history', { error: error.message }); return null; } } - + /** * Display migration status information */ displayMigrationStatus(stagingStatus, pendingMigrations, lastPromoted) { console.log('\n๐Ÿ” Migration Status Report'); console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n'); - + // Staging status console.log(`๐Ÿ“ฆ Staging Area: ${stagingStatus.status.toUpperCase()}`); if (stagingStatus.status === 'dirty') { console.log(` Files in staging: ${stagingStatus.files}`); - stagingStatus.fileList?.forEach(file => { + stagingStatus.fileList?.forEach((file) => { console.log(` โ€ข ${file}`); }); } else if (stagingStatus.status === 'error') { console.log(` Error: ${stagingStatus.error}`); } console.log(''); - + // Pending migrations console.log(`๐Ÿ“‹ Pending Migrations: ${pendingMigrations.length}`); if (pendingMigrations.length > 0) { - pendingMigrations.slice(0, 5).forEach(migration => { + pendingMigrations.slice(0, 5).forEach((migration) => { console.log(` โ€ข ${migration}`); }); if (pendingMigrations.length > 5) { @@ -151,7 +159,7 @@ class MigrateStatusCommand extends Command { } } console.log(''); - + // Last promoted console.log('๐Ÿš€ Last Promoted Migration:'); if (lastPromoted) { @@ -165,4 +173,17 @@ class MigrateStatusCommand extends Command { } } -module.exports = MigrateStatusCommand; \ No newline at end of file +/** + * Migration status command handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Status result + */ +export default async function statusHandler(args, config, logger, isProd) { + const command = new MigrateStatusCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateStatusCommand }; diff --git a/src/commands/db/migrate/test-v2.js b/starfleet/data-cli/src/commands/db/migrate/test-v2.js similarity index 91% rename from src/commands/db/migrate/test-v2.js rename to starfleet/data-cli/src/commands/db/migrate/test-v2.js index bdbb5e5..fe0f92a 100644 --- a/src/commands/db/migrate/test-v2.js +++ b/starfleet/data-cli/src/commands/db/migrate/test-v2.js @@ -2,37 +2,38 @@ * Migration Test Command with pgTAP Validation - V2 using Supabase API */ -const Command = require('../../../lib/Command'); -const MigrationMetadata = require('../../../lib/MigrationMetadata'); -const { createClient } = require('@supabase/supabase-js'); -const fs = require('fs').promises; -const path = require('path'); +import Command from '../../../lib/Command.js'; +import MigrationMetadata from '../../../lib/MigrationMetadata.js'; +import { createClient } from '@supabase/supabase-js'; +import { promises as fs } from 'fs'; +import path from 'path'; /** * Test migration in isolated schema using Supabase API + * @class */ class MigrateTestCommand extends Command { static description = 'Test migration with pgTAP validation'; - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = false; // Testing is safe this.workingDir = process.cwd(); this.stagingDir = path.join(this.workingDir, 'migrations-staging'); this.currentMigrationDir = path.join(this.stagingDir, 'current'); - + // Initialize Supabase client with service role key for admin operations const supabaseUrl = process.env.SUPABASE_URL || 'http://localhost:54321'; const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY; - + if (!serviceRoleKey) { throw new Error('SUPABASE_SERVICE_ROLE_KEY environment variable is required for testing'); } - + this.supabase = createClient(supabaseUrl, serviceRoleKey, { auth: { persistSession: false } }); - + // Generate unique test schema name with clear namespace const timestamp = Math.floor(Date.now() / 1000); // POSIX timestamp this.testSchema = `"@data.tests.${timestamp}"`; // Quote for special chars @@ -43,53 +44,51 @@ class MigrateTestCommand extends Command { */ async performExecute(args = {}) { this.emit('start'); - + let schemaCreated = false; - + try { this.progress('Starting migration test process'); - + // Validate that we have a staged migration await this.validateStagedMigration(); - + // Get migration metadata const metadata = await this.getMigrationMetadata(); this.progress(`Testing migration: ${metadata.name} (${metadata.id})`); - + // Create isolated test schema await this.createTestSchema(); schemaCreated = true; this.success(`Created test schema: ${this.testSchema}`); - + // Apply migration to test schema await this.applyMigration(); this.success('Applied migration to test schema'); - + // Install pgTAP if needed await this.ensurePgTap(); - + // Run pgTAP tests const testResults = await this.runTests(args); - + // Report results this.reportTestResults(testResults); - + // Update metadata with test results await this.updateMetadata(metadata, testResults); - - this.emit('complete', { + + this.emit('complete', { success: testResults.success, schema: this.testSchema, - results: testResults + results: testResults }); - + return testResults; - } catch (error) { this.error('Migration test failed', error); this.emit('failed', { error }); throw error; - } finally { try { // Always cleanup test schema unless explicitly kept @@ -98,7 +97,7 @@ class MigrateTestCommand extends Command { } else if (schemaCreated) { this.warn(`Test schema ${this.testSchema} was kept for debugging`); } - + // Close database connection if (this.supabase) { // Supabase client doesn't have an explicit close method, but we can @@ -113,7 +112,7 @@ class MigrateTestCommand extends Command { } } } - + /** * Validate that we have a staged migration ready to test */ @@ -126,7 +125,7 @@ class MigrateTestCommand extends Command { throw new Error('No staged migration found. Run "data db:migrate:generate" first.'); } } - + /** * Get migration metadata */ @@ -134,7 +133,7 @@ class MigrateTestCommand extends Command { const metadata = new MigrationMetadata(this.currentMigrationDir); return metadata.read(); } - + /** * Create isolated test schema using Supabase API */ @@ -144,31 +143,30 @@ class MigrateTestCommand extends Command { const { error } = await this.supabase.rpc('exec_sql', { sql: `CREATE SCHEMA IF NOT EXISTS ${this.testSchema};` }); - + if (error) throw error; - + // Set search path to include our test schema const { error: pathError } = await this.supabase.rpc('exec_sql', { sql: `SET search_path TO ${this.testSchema}, public, test;` }); - + if (pathError) throw pathError; - } catch (error) { throw new Error(`Failed to create test schema: ${error.message}`); } } - + /** * Apply staged migration to test schema */ async applyMigration() { const migrationFile = path.join(this.currentMigrationDir, 'migration.sql'); - + try { // Read migration SQL const migrationSql = await fs.readFile(migrationFile, 'utf8'); - + // Wrap migration in schema context const wrappedSql = ` -- Switch to test schema @@ -180,19 +178,18 @@ class MigrateTestCommand extends Command { -- Reset search path SET search_path TO public; `; - + // Execute migration via RPC const { error } = await this.supabase.rpc('exec_sql', { sql: wrappedSql }); - + if (error) throw error; - } catch (error) { throw new Error(`Failed to apply migration: ${error.message}`); } } - + /** * Ensure pgTAP extension is available */ @@ -200,21 +197,21 @@ class MigrateTestCommand extends Command { try { // Check if pgTAP exists const { data, error } = await this.supabase.rpc('exec_sql', { - sql: `SELECT 1 FROM pg_extension WHERE extname = 'pgtap';` + sql: "SELECT 1 FROM pg_extension WHERE extname = 'pgtap';" }); - + if (error) throw error; - + // Install if not present if (!data || data.length === 0) { this.progress('Installing pgTAP extension'); - + const { error: installError } = await this.supabase.rpc('exec_sql', { - sql: `CREATE EXTENSION IF NOT EXISTS pgtap;` + sql: 'CREATE EXTENSION IF NOT EXISTS pgtap;' }); - + if (installError) throw installError; - + this.success('pgTAP extension installed'); } } catch (error) { @@ -222,14 +219,14 @@ class MigrateTestCommand extends Command { this.warn('Some tests may be skipped'); } } - + /** * Run pgTAP tests in test schema */ async runTests(options = {}) { try { this.progress('Discovering test functions...'); - + // Find test functions in test schema const { data: testFunctions, error: discoverError } = await this.supabase.rpc('exec_sql', { sql: ` @@ -240,9 +237,9 @@ class MigrateTestCommand extends Command { ORDER BY routine_name; ` }); - + if (discoverError) throw discoverError; - + if (!testFunctions || testFunctions.length === 0) { this.warn('No test functions found'); return { @@ -253,9 +250,9 @@ class MigrateTestCommand extends Command { skipped: 0 }; } - + this.progress(`Found ${testFunctions.length} test function(s)`); - + // Run each test function const results = { success: true, @@ -265,43 +262,42 @@ class MigrateTestCommand extends Command { skipped: 0, details: [] }; - + for (const func of testFunctions) { const functionName = func.routine_name; - + try { this.progress(`Running ${functionName}...`); - + // Execute test function const { data: testOutput, error: testError } = await this.supabase.rpc('exec_sql', { sql: `SELECT * FROM test.${functionName}();` }); - + if (testError) throw testError; - + // Parse TAP output const tapResults = this.parseTapOutput(testOutput); - + results.testsRun += tapResults.total; results.testsPassed += tapResults.passed; results.testsFailed += tapResults.failed; results.skipped += tapResults.skipped; - + if (tapResults.failed > 0) { results.success = false; } - + results.details.push({ function: functionName, ...tapResults }); - + if (tapResults.failed > 0) { this.error(`โœ— ${functionName}: ${tapResults.failed} test(s) failed`); } else { this.success(`โœ“ ${functionName}: All ${tapResults.passed} test(s) passed`); } - } catch (error) { this.error(`Failed to run ${functionName}: ${error.message}`); results.success = false; @@ -312,14 +308,13 @@ class MigrateTestCommand extends Command { }); } } - + return results; - } catch (error) { throw new Error(`Test execution failed: ${error.message}`); } } - + /** * Parse TAP output from test results */ @@ -327,15 +322,15 @@ class MigrateTestCommand extends Command { if (!output || !Array.isArray(output)) { return { total: 0, passed: 0, failed: 0, skipped: 0 }; } - + let passed = 0; let failed = 0; let skipped = 0; - + for (const row of output) { const line = Object.values(row)[0]; if (typeof line !== 'string') continue; - + if (line.startsWith('ok ')) { passed++; } else if (line.startsWith('not ok ')) { @@ -344,7 +339,7 @@ class MigrateTestCommand extends Command { skipped++; } } - + return { total: passed + failed + skipped, passed, @@ -352,7 +347,7 @@ class MigrateTestCommand extends Command { skipped }; } - + /** * Report test results */ @@ -360,19 +355,19 @@ class MigrateTestCommand extends Command { console.log('\n' + '='.repeat(60)); console.log('TEST RESULTS SUMMARY'); console.log('='.repeat(60)); - + console.log(`Total Tests Run: ${results.testsRun}`); console.log(`โœ“ Passed: ${results.testsPassed}`); console.log(`โœ— Failed: ${results.testsFailed}`); console.log(`โŠ˜ Skipped: ${results.skipped}`); - + if (results.success) { this.success('\nโœ“ All tests passed!'); } else { this.error(`\nโœ— ${results.testsFailed} test(s) failed`); - + // Show failed test details - const failedTests = results.details.filter(d => d.failed > 0 || d.error); + const failedTests = results.details.filter((d) => d.failed > 0 || d.error); if (failedTests.length > 0) { console.log('\nFailed Tests:'); for (const test of failedTests) { @@ -380,10 +375,10 @@ class MigrateTestCommand extends Command { } } } - + console.log('='.repeat(60) + '\n'); } - + /** * Update migration metadata with test results */ @@ -398,23 +393,23 @@ class MigrateTestCommand extends Command { testsFailed: testResults.testsFailed } }; - + const metadataManager = new MigrationMetadata(this.currentMigrationDir); await metadataManager.write(updatedMetadata); } - + /** * Clean up test schema */ async cleanupTestSchema() { try { this.progress(`Cleaning up test schema: ${this.testSchema}`); - + // Drop schema with CASCADE to remove all objects const { error } = await this.supabase.rpc('exec_sql', { sql: `DROP SCHEMA IF EXISTS ${this.testSchema} CASCADE;` }); - + if (error) { this.warn(`Failed to cleanup test schema: ${error.message}`); } else { @@ -424,7 +419,7 @@ class MigrateTestCommand extends Command { this.warn(`Cleanup error: ${error.message}`); } } - + /** * Create RPC function for executing arbitrary SQL (if it doesn't exist) * This should be added to your database migrations @@ -453,4 +448,17 @@ class MigrateTestCommand extends Command { } } -module.exports = MigrateTestCommand; \ No newline at end of file +/** + * Test migration handler with pgTAP validation + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Test results + */ +export default async function testHandler(args, config, logger, isProd) { + const command = new MigrateTestCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateTestCommand }; diff --git a/starfleet/data-cli/src/commands/db/migrate/test.js b/starfleet/data-cli/src/commands/db/migrate/test.js new file mode 100644 index 0000000..e69de29 diff --git a/src/commands/db/migrate/verify.js b/starfleet/data-cli/src/commands/db/migrate/verify.js similarity index 77% rename from src/commands/db/migrate/verify.js rename to starfleet/data-cli/src/commands/db/migrate/verify.js index 44ba919..78babd9 100644 --- a/src/commands/db/migrate/verify.js +++ b/starfleet/data-cli/src/commands/db/migrate/verify.js @@ -2,17 +2,20 @@ * Migration Verify Command */ -const Command = require('../../../lib/Command'); -const fs = require('fs').promises; -const path = require('path'); -const crypto = require('crypto'); +import Command from '../../../lib/Command.js'; +import { promises as fs } from 'fs'; +import path from 'path'; +import crypto from 'crypto'; /** * Verify migration integrity including file hashes and metadata validation */ +/** + * @class + */ class MigrateVerifyCommand extends Command { static description = 'Verify migration integrity'; - + constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); this.requiresProductionConfirmation = false; // Read-only verification @@ -23,68 +26,67 @@ class MigrateVerifyCommand extends Command { */ async performExecute(args = {}) { this.emit('start'); - + try { const fix = args.fix || args.f || false; const verbose = args.verbose || args.v || false; - + this.progress('Starting migration integrity verification...'); - + let totalChecks = 0; let passedChecks = 0; let failedChecks = 0; const issues = []; - + // Check file hashes const hashResult = await this.verifyFileHashes(verbose); totalChecks += hashResult.total; passedChecks += hashResult.passed; failedChecks += hashResult.failed; issues.push(...hashResult.issues); - + // Validate metadata const metadataResult = await this.validateMetadata(verbose); totalChecks += metadataResult.total; passedChecks += metadataResult.passed; failedChecks += metadataResult.failed; issues.push(...metadataResult.issues); - + // Check migration dependencies const depResult = await this.checkDependencies(verbose); totalChecks += depResult.total; passedChecks += depResult.passed; failedChecks += depResult.failed; issues.push(...depResult.issues); - + // Check SQL syntax const sqlResult = await this.verifySqlSyntax(verbose); totalChecks += sqlResult.total; passedChecks += sqlResult.passed; failedChecks += sqlResult.failed; issues.push(...sqlResult.issues); - + // Fix issues if requested if (fix && issues.length > 0) { await this.fixIssues(issues); } - + // Display results this.displayVerificationResults(totalChecks, passedChecks, failedChecks, issues); - - this.emit('complete', { - totalChecks, - passedChecks, - failedChecks, - issues: issues.length + + this.emit('complete', { + totalChecks, + passedChecks, + failedChecks, + issues: issues.length }); - } catch (error) { this.error('Migration verification failed', error); this.emit('failed', { error }); throw error; } } - + /** * Verify file hashes against stored checksums */ @@ -93,55 +95,61 @@ class MigrateVerifyCommand extends Command { let passed = 0; let failed = 0; const issues = []; - + try { const migrationsDir = path.resolve('supabase/migrations'); const checksumFile = path.resolve('supabase/.migration_checksums.json'); - + // Check if migrations directory exists - const migrationsExists = await fs.access(migrationsDir).then(() => true).catch(() => false); + const migrationsExists = await fs + .access(migrationsDir) + .then(() => true) + .catch(() => false); if (!migrationsExists) { issues.push({ type: 'missing_directory', path: migrationsDir }); return { total, passed, failed, issues }; } - + // Load stored checksums let storedChecksums = {}; - const checksumExists = await fs.access(checksumFile).then(() => true).catch(() => false); + const checksumExists = await fs + .access(checksumFile) + .then(() => true) + .catch(() => false); if (checksumExists) { const checksumContent = await fs.readFile(checksumFile, 'utf8'); storedChecksums = JSON.parse(checksumContent); } - + // Get all migration files const files = await fs.readdir(migrationsDir); - const migrationFiles = files.filter(f => f.endsWith('.sql')); - + const migrationFiles = files.filter((f) => f.endsWith('.sql')); + for (const file of migrationFiles) { total++; const filePath = path.join(migrationsDir, file); - + // Calculate current hash const content = await fs.readFile(filePath, 'utf8'); const currentHash = crypto.createHash('sha256').update(content).digest('hex'); - + // Compare with stored hash const storedHash = storedChecksums[file]; - + if (!storedHash) { - issues.push({ - type: 'missing_checksum', - file, - currentHash + issues.push({ + type: 'missing_checksum', + file, + currentHash }); failed++; if (verbose) this.warn(`Missing checksum for: ${file}`); } else if (storedHash !== currentHash) { - issues.push({ - type: 'checksum_mismatch', - file, - storedHash, - currentHash + issues.push({ + type: 'checksum_mismatch', + file, + storedHash, + currentHash }); failed++; if (verbose) this.warn(`Checksum mismatch for: ${file}`); @@ -150,14 +158,13 @@ class MigrateVerifyCommand extends Command { if (verbose) this.progress(`Hash verified: ${file}`); } } - } catch (error) { issues.push({ type: 'hash_verification_error', error: error.message }); } - + return { total, passed, failed, issues }; } - + /** * Validate migration metadata */ @@ -166,19 +173,22 @@ class MigrateVerifyCommand extends Command { let passed = 0; let failed = 0; const issues = []; - + try { const historyFile = path.resolve('supabase/.migration_history.json'); - const historyExists = await fs.access(historyFile).then(() => true).catch(() => false); - + const historyExists = await fs + .access(historyFile) + .then(() => true) + .catch(() => false); + if (!historyExists) { issues.push({ type: 'missing_history_file', path: historyFile }); return { total, passed, failed, issues }; } - + const historyContent = await fs.readFile(historyFile, 'utf8'); let history; - + // Validate JSON structure total++; try { @@ -190,28 +200,28 @@ class MigrateVerifyCommand extends Command { failed++; return { total, passed, failed, issues }; } - + // Validate each history entry for (const [index, entry] of history.entries()) { total++; - + const requiredFields = ['action', 'timestamp']; - const missingFields = requiredFields.filter(field => !entry[field]); - + const missingFields = requiredFields.filter((field) => !entry[field]); + if (missingFields.length > 0) { - issues.push({ - type: 'missing_required_fields', - entry: index, - missingFields + issues.push({ + type: 'missing_required_fields', + entry: index, + missingFields }); failed++; } else { // Validate timestamp format if (isNaN(new Date(entry.timestamp).getTime())) { - issues.push({ - type: 'invalid_timestamp', - entry: index, - timestamp: entry.timestamp + issues.push({ + type: 'invalid_timestamp', + entry: index, + timestamp: entry.timestamp }); failed++; } else { @@ -220,14 +230,13 @@ class MigrateVerifyCommand extends Command { } } } - } catch (error) { issues.push({ type: 'metadata_validation_error', error: error.message }); } - + return { total, passed, failed, issues }; } - + /** * Check migration dependencies */ @@ -236,44 +245,47 @@ class MigrateVerifyCommand extends Command { let passed = 0; let failed = 0; const issues = []; - + try { const migrationsDir = path.resolve('supabase/migrations'); - const migrationsExists = await fs.access(migrationsDir).then(() => true).catch(() => false); - + const migrationsExists = await fs + .access(migrationsDir) + .then(() => true) + .catch(() => false); + if (!migrationsExists) { return { total, passed, failed, issues }; } - + const files = await fs.readdir(migrationsDir); - const migrationFiles = files.filter(f => f.endsWith('.sql')).sort(); - + const migrationFiles = files.filter((f) => f.endsWith('.sql')).sort(); + for (let i = 0; i < migrationFiles.length; i++) { total++; const file = migrationFiles[i]; const filePath = path.join(migrationsDir, file); - + // Check if migration follows naming convention const timestampMatch = file.match(/^(\d{14})_/); if (!timestampMatch) { - issues.push({ - type: 'invalid_naming_convention', + issues.push({ + type: 'invalid_naming_convention', file, expected: 'YYYYMMDDHHMMSS_description.sql' }); failed++; continue; } - + // Check chronological order if (i > 0) { const prevFile = migrationFiles[i - 1]; const prevTimestamp = prevFile.match(/^(\d{14})_/)?.[1]; const currentTimestamp = timestampMatch[1]; - + if (currentTimestamp <= prevTimestamp) { - issues.push({ - type: 'chronological_order_violation', + issues.push({ + type: 'chronological_order_violation', file, prevFile, currentTimestamp, @@ -288,14 +300,13 @@ class MigrateVerifyCommand extends Command { passed++; } } - } catch (error) { issues.push({ type: 'dependency_check_error', error: error.message }); } - + return { total, passed, failed, issues }; } - + /** * Verify SQL syntax (basic check) */ @@ -304,26 +315,29 @@ class MigrateVerifyCommand extends Command { let passed = 0; let failed = 0; const issues = []; - + try { const migrationsDir = path.resolve('supabase/migrations'); - const migrationsExists = await fs.access(migrationsDir).then(() => true).catch(() => false); - + const migrationsExists = await fs + .access(migrationsDir) + .then(() => true) + .catch(() => false); + if (!migrationsExists) { return { total, passed, failed, issues }; } - + const files = await fs.readdir(migrationsDir); - const migrationFiles = files.filter(f => f.endsWith('.sql')); - + const migrationFiles = files.filter((f) => f.endsWith('.sql')); + for (const file of migrationFiles) { total++; const filePath = path.join(migrationsDir, file); const content = await fs.readFile(filePath, 'utf8'); - + // Basic SQL syntax checks const syntaxIssues = this.checkBasicSqlSyntax(content, file); - + if (syntaxIssues.length > 0) { issues.push(...syntaxIssues); failed++; @@ -333,31 +347,32 @@ class MigrateVerifyCommand extends Command { if (verbose) this.progress(`SQL syntax OK: ${file}`); } } - } catch (error) { issues.push({ type: 'sql_syntax_error', error: error.message }); } - + return { total, passed, failed, issues }; } - + /** * Basic SQL syntax checking */ checkBasicSqlSyntax(content, filename) { const issues = []; - + // Check for common SQL issues const lines = content.split('\n'); - + lines.forEach((line, index) => { const lineNum = index + 1; - + // Check for unterminated statements (basic check) - if (line.trim().length > 0 && - !line.trim().startsWith('--') && - !line.includes(';') && - lineNum === lines.length) { + if ( + line.trim().length > 0 && + !line.trim().startsWith('--') && + !line.includes(';') && + lineNum === lines.length + ) { issues.push({ type: 'unterminated_statement', file: filename, @@ -365,13 +380,17 @@ class MigrateVerifyCommand extends Command { content: line.trim() }); } - + // Check for potentially dangerous operations without transactions const dangerousOps = ['DROP TABLE', 'TRUNCATE', 'DELETE FROM']; const upperLine = line.toUpperCase(); - - dangerousOps.forEach(op => { - if (upperLine.includes(op) && !content.toUpperCase().includes('BEGIN') && !content.toUpperCase().includes('TRANSACTION')) { + + dangerousOps.forEach((op) => { + if ( + upperLine.includes(op) && + !content.toUpperCase().includes('BEGIN') && + !content.toUpperCase().includes('TRANSACTION') + ) { issues.push({ type: 'dangerous_operation_without_transaction', file: filename, @@ -381,65 +400,70 @@ class MigrateVerifyCommand extends Command { } }); }); - + return issues; } - + /** * Fix detected issues */ async fixIssues(issues) { this.progress('Attempting to fix detected issues...'); - + for (const issue of issues) { try { switch (issue.type) { - case 'missing_checksum': - await this.fixMissingChecksum(issue); - break; - case 'checksum_mismatch': - this.warn(`Cannot auto-fix checksum mismatch for ${issue.file} - manual review required`); - break; - default: - this.warn(`Cannot auto-fix issue type: ${issue.type}`); + case 'missing_checksum': + await this.fixMissingChecksum(issue); + break; + case 'checksum_mismatch': + this.warn( + `Cannot auto-fix checksum mismatch for ${issue.file} - manual review required` + ); + break; + default: + this.warn(`Cannot auto-fix issue type: ${issue.type}`); } } catch (error) { this.warn(`Failed to fix issue: ${issue.type}`, { error: error.message }); } } } - + /** * Fix missing checksum by generating it */ async fixMissingChecksum(issue) { const checksumFile = path.resolve('supabase/.migration_checksums.json'); - + let checksums = {}; - const checksumExists = await fs.access(checksumFile).then(() => true).catch(() => false); + const checksumExists = await fs + .access(checksumFile) + .then(() => true) + .catch(() => false); if (checksumExists) { const content = await fs.readFile(checksumFile, 'utf8'); checksums = JSON.parse(content); } - + checksums[issue.file] = issue.currentHash; - + await fs.writeFile(checksumFile, JSON.stringify(checksums, null, 2)); this.progress(`Generated checksum for: ${issue.file}`); } - + /** * Display verification results */ displayVerificationResults(totalChecks, passedChecks, failedChecks, issues) { console.log('\n๐Ÿ” Migration Verification Results'); console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n'); - + console.log(`Total checks: ${totalChecks}`); console.log(`Passed: ${passedChecks} โœ…`); console.log(`Failed: ${failedChecks} โŒ`); console.log(''); - + if (issues.length > 0) { console.log('Issues found:'); issues.forEach((issue, index) => { @@ -450,7 +474,7 @@ class MigrateVerifyCommand extends Command { }); console.log(''); } - + if (failedChecks === 0) { console.log('โœ… All verification checks passed!'); } else { @@ -460,4 +484,17 @@ class MigrateVerifyCommand extends Command { } } -module.exports = MigrateVerifyCommand; \ No newline at end of file +/** + * Migration verify handler + * @param {Object} args - Command arguments + * @param {Object} config - Configuration object + * @param {Object} logger - Logger instance + * @param {boolean} isProd - Production flag + * @returns {Promise} Verify result + */ +export default async function verifyHandler(args, config, logger, isProd) { + const command = new MigrateVerifyCommand(config, logger, isProd); + return command.performExecute(args); +} + +export { MigrateVerifyCommand }; diff --git a/src/commands/functions/DeployCommand.js b/starfleet/data-cli/src/commands/functions/DeployCommand.js similarity index 89% rename from src/commands/functions/DeployCommand.js rename to starfleet/data-cli/src/commands/functions/DeployCommand.js index a938095..300ebe3 100644 --- a/src/commands/functions/DeployCommand.js +++ b/starfleet/data-cli/src/commands/functions/DeployCommand.js @@ -1,14 +1,14 @@ /** * Edge Functions Deployment Command - * + * * Integrates Supabase Edge Functions deployment with data's event-driven architecture * Provides deployment validation, environment checking, and rollback capabilities */ -const fs = require('fs'); -const path = require('path'); -const { execSync } = require('child_process'); -const Command = require('../../lib/Command'); +import fs from 'fs'; +import path from 'path'; +import { execSync } from 'child_process'; +import Command from '../../lib/Command.js'; class DeployCommand extends Command { constructor(functionsPath, logger = null, isProd = false) { @@ -31,7 +31,7 @@ class DeployCommand extends Command { // Get functions to deploy const functionsToDeploy = await this.resolveFunctionsList(functionNames); - + if (functionsToDeploy.length === 0) { this.warn('No functions found to deploy'); return; @@ -52,10 +52,10 @@ class DeployCommand extends Command { try { const result = await this.deployFunction(functionName, options); results.push(result); - this.emit('function-deployed', { - function: functionName, + this.emit('function-deployed', { + function: functionName, success: true, - result + result }); } catch (error) { this.error(`Failed to deploy function: ${functionName}`, error); @@ -64,8 +64,8 @@ class DeployCommand extends Command { success: false, error: error.message }); - this.emit('function-deployed', { - function: functionName, + this.emit('function-deployed', { + function: functionName, success: false, error: error.message }); @@ -73,8 +73,8 @@ class DeployCommand extends Command { } // Emit deployment summary - const successful = results.filter(r => r.success); - const failed = results.filter(r => !r.success); + const successful = results.filter((r) => r.success); + const failed = results.filter((r) => !r.success); this.emit('deployment-complete', { total: results.length, @@ -85,14 +85,13 @@ class DeployCommand extends Command { if (failed.length > 0) { this.warn(`Deployment completed with ${failed.length} failure(s)`, { - failed: failed.map(f => f.function) + failed: failed.map((f) => f.function) }); } else { this.success(`โœ… Successfully deployed ${successful.length} function(s)`, { - deployed: successful.map(s => s.function) + deployed: successful.map((s) => s.function) }); } - } catch (error) { this.error('Functions deployment failed', error); throw error; @@ -138,7 +137,7 @@ class DeployCommand extends Command { const requiredSecrets = [ 'STRIPE_PUBLISHABLE_KEY', - 'STRIPE_SECRET_KEY', + 'STRIPE_SECRET_KEY', 'STRIPE_WEBHOOK_SECRET', 'SUPABASE_SERVICE_ROLE_KEY' ]; @@ -148,10 +147,10 @@ class DeployCommand extends Command { for (const secret of requiredSecrets) { try { // Check if secret exists in Supabase - const result = execSync(`supabase secrets list --json`, { stdio: 'pipe' }); + const result = execSync('supabase secrets list --json', { stdio: 'pipe' }); const secrets = JSON.parse(result.toString()); - - if (!secrets.find(s => s.name === secret)) { + + if (!secrets.find((s) => s.name === secret)) { missingSecrets.push(secret); } } catch (error) { @@ -179,20 +178,20 @@ class DeployCommand extends Command { missing.push(name); } } - + if (missing.length > 0) { throw new Error(`Functions not found: ${missing.join(', ')}`); } - + return functionNames; } // Get all functions in directory const entries = fs.readdirSync(this.functionsPath, { withFileTypes: true }); return entries - .filter(entry => entry.isDirectory()) - .map(entry => entry.name) - .filter(name => !name.startsWith('.')); + .filter((entry) => entry.isDirectory()) + .map((entry) => entry.name) + .filter((name) => !name.startsWith('.')); } /** @@ -202,7 +201,7 @@ class DeployCommand extends Command { this.progress(`๐Ÿ” Validating function: ${functionName}`); const functionPath = path.join(this.functionsPath, functionName); - + // Check for required files const indexPath = path.join(functionPath, 'index.ts'); if (!fs.existsSync(indexPath)) { @@ -212,7 +211,7 @@ class DeployCommand extends Command { // Basic TypeScript syntax check try { const content = fs.readFileSync(indexPath, 'utf8'); - + // Check for basic Edge Function structure if (!content.includes('serve(') && !content.includes('Deno.serve(')) { this.warn(`Function ${functionName} may not have proper serve() handler`); @@ -222,14 +221,13 @@ class DeployCommand extends Command { if (!content.includes('import') && !content.includes('require(')) { this.warn(`Function ${functionName} has no imports - may be incomplete`); } - } catch (error) { this.warn(`Could not validate ${functionName} syntax: ${error.message}`); } - this.emit('function-validated', { + this.emit('function-validated', { function: functionName, - path: functionPath + path: functionPath }); } @@ -240,7 +238,7 @@ class DeployCommand extends Command { this.progress(`๐Ÿš€ Deploying function: ${functionName}`); const deployArgs = ['functions', 'deploy', functionName]; - + if (options.noVerifyJwt) { deployArgs.push('--no-verify-jwt'); } @@ -259,9 +257,9 @@ class DeployCommand extends Command { try { const startTime = Date.now(); - + this.progress(`Executing: supabase ${deployArgs.join(' ')}`); - + const result = execSync(`supabase ${deployArgs.join(' ')}`, { stdio: 'pipe', encoding: 'utf8', @@ -278,10 +276,9 @@ class DeployCommand extends Command { deployTime, output: result }; - } catch (error) { this.error(`Failed to deploy ${functionName}`, error); - + return { function: functionName, success: false, @@ -299,17 +296,16 @@ class DeployCommand extends Command { this.progress('๐Ÿ“Š Getting function deployment status'); try { - const result = execSync('supabase functions list --json', { + const result = execSync('supabase functions list --json', { stdio: 'pipe', - encoding: 'utf8' + encoding: 'utf8' }); - + const functions = JSON.parse(result); - + this.emit('deployment-status', { functions }); - - return functions; + return functions; } catch (error) { this.warn('Could not retrieve function status', { error: error.message }); return []; @@ -338,4 +334,4 @@ class DeployCommand extends Command { } } -module.exports = DeployCommand; \ No newline at end of file +export default DeployCommand; diff --git a/src/commands/functions/StatusCommand.js b/starfleet/data-cli/src/commands/functions/StatusCommand.js similarity index 84% rename from src/commands/functions/StatusCommand.js rename to starfleet/data-cli/src/commands/functions/StatusCommand.js index 88d4ea5..710f027 100644 --- a/src/commands/functions/StatusCommand.js +++ b/starfleet/data-cli/src/commands/functions/StatusCommand.js @@ -1,13 +1,13 @@ /** * Edge Functions Status Command - * + * * Shows deployment status, health, and metrics for Edge Functions */ -const fs = require('fs'); -const path = require('path'); -const { execSync } = require('child_process'); -const Command = require('../../lib/Command'); +import fs from 'fs'; +import path from 'path'; +import { execSync } from 'child_process'; +import Command from '../../lib/Command.js'; class StatusCommand extends Command { constructor(config, logger = null, isProd = false) { @@ -32,13 +32,13 @@ class StatusCommand extends Command { // Get local functions const localFunctions = await this.getLocalFunctions(functionNames); - + // Get deployed functions const deployedFunctions = await this.getDeployedFunctions(); - + // Combine status information const statusMap = this.combineStatus(localFunctions, deployedFunctions); - + this.emit('status-retrieved', { local: localFunctions.length, deployed: deployedFunctions.length, @@ -49,7 +49,6 @@ class StatusCommand extends Command { this.displayStatusSummary(statusMap); return statusMap; - } catch (error) { this.error('Failed to retrieve functions status', error); throw error; @@ -61,20 +60,20 @@ class StatusCommand extends Command { */ async getLocalFunctions(functionNames = null) { const functionsPath = this.outputConfig.functionsDir; - + if (!fs.existsSync(functionsPath)) { return []; } const entries = fs.readdirSync(functionsPath, { withFileTypes: true }); let functions = entries - .filter(entry => entry.isDirectory()) - .map(entry => entry.name) - .filter(name => !name.startsWith('.')); + .filter((entry) => entry.isDirectory()) + .map((entry) => entry.name) + .filter((name) => !name.startsWith('.')); // Filter by specified function names if provided if (functionNames && functionNames.length > 0) { - functions = functions.filter(name => functionNames.includes(name)); + functions = functions.filter((name) => functionNames.includes(name)); } const localFunctions = []; @@ -82,7 +81,7 @@ class StatusCommand extends Command { for (const functionName of functions) { const functionPath = path.join(functionsPath, functionName); const indexPath = path.join(functionPath, 'index.ts'); - + let size = 0; let lastModified = null; let hasConfig = false; @@ -96,7 +95,6 @@ class StatusCommand extends Command { const denoJsonPath = path.join(functionPath, 'deno.json'); hasConfig = fs.existsSync(denoJsonPath); - } catch (error) { this.warn(`Could not read stats for function: ${functionName}`); } @@ -121,14 +119,14 @@ class StatusCommand extends Command { try { this.progress('๐ŸŒ Fetching deployed functions from Supabase'); - const result = execSync('supabase functions list --json', { + const result = execSync('supabase functions list --json', { stdio: 'pipe', - encoding: 'utf8' + encoding: 'utf8' }); - + const deployedFunctions = JSON.parse(result); - - return deployedFunctions.map(func => ({ + + return deployedFunctions.map((func) => ({ name: func.name, id: func.id, status: func.status || 'unknown', @@ -136,10 +134,9 @@ class StatusCommand extends Command { updatedAt: func.updated_at, version: func.version })); - } catch (error) { - this.warn('Could not retrieve deployed functions list', { - error: error.message + this.warn('Could not retrieve deployed functions list', { + error: error.message }); return []; } @@ -155,7 +152,7 @@ class StatusCommand extends Command { for (const local of localFunctions) { statusMap.set(local.name, { name: local.name, - local: local, + local, deployed: null, status: 'local-only' }); @@ -164,7 +161,7 @@ class StatusCommand extends Command { // Add deployed functions for (const deployed of deployedFunctions) { const existing = statusMap.get(deployed.name); - + if (existing) { existing.deployed = deployed; existing.status = 'deployed'; @@ -172,7 +169,7 @@ class StatusCommand extends Command { statusMap.set(deployed.name, { name: deployed.name, local: null, - deployed: deployed, + deployed, status: 'deployed-only' }); } @@ -185,11 +182,11 @@ class StatusCommand extends Command { * Display status summary */ displayStatusSummary(statusMap) { - const localOnly = statusMap.filter(f => f.status === 'local-only'); - const deployed = statusMap.filter(f => f.status === 'deployed'); - const deployedOnly = statusMap.filter(f => f.status === 'deployed-only'); + const localOnly = statusMap.filter((f) => f.status === 'local-only'); + const deployed = statusMap.filter((f) => f.status === 'deployed'); + const deployedOnly = statusMap.filter((f) => f.status === 'deployed-only'); - this.success(`๐Ÿ“ˆ Functions Status Summary`, { + this.success('๐Ÿ“ˆ Functions Status Summary', { total: statusMap.length, localOnly: localOnly.length, deployed: deployed.length, @@ -227,16 +224,16 @@ class StatusCommand extends Command { // Warn about potential issues if (localOnly.length > 0) { this.warn(`${localOnly.length} function(s) exist locally but are not deployed`, { - functions: localOnly.map(f => f.name) + functions: localOnly.map((f) => f.name) }); } if (deployedOnly.length > 0) { this.warn(`${deployedOnly.length} function(s) are deployed but not found locally`, { - functions: deployedOnly.map(f => f.name) + functions: deployedOnly.map((f) => f.name) }); } } } -module.exports = StatusCommand; \ No newline at end of file +export default StatusCommand; diff --git a/src/commands/functions/ValidateCommand.js b/starfleet/data-cli/src/commands/functions/ValidateCommand.js similarity index 91% rename from src/commands/functions/ValidateCommand.js rename to starfleet/data-cli/src/commands/functions/ValidateCommand.js index 26461cd..3810f18 100644 --- a/src/commands/functions/ValidateCommand.js +++ b/starfleet/data-cli/src/commands/functions/ValidateCommand.js @@ -1,14 +1,14 @@ /** * Edge Functions Validation Command - * + * * Validates Edge Functions syntax, structure, and dependencies * without deploying them */ -const fs = require('fs'); -const path = require('path'); -const { execSync } = require('child_process'); -const Command = require('../../lib/Command'); +import fs from 'fs'; +import path from 'path'; +import { execSync } from 'child_process'; +import Command from '../../lib/Command.js'; class ValidateCommand extends Command { constructor(config, logger = null, isProd = false) { @@ -32,7 +32,7 @@ class ValidateCommand extends Command { // Get functions to validate const functionsToValidate = await this.resolveFunctionsList(functionNames); - + if (functionsToValidate.length === 0) { this.warn('No functions found to validate'); return; @@ -50,8 +50,8 @@ class ValidateCommand extends Command { } // Emit validation summary - const valid = results.filter(r => r.isValid); - const invalid = results.filter(r => !r.isValid); + const valid = results.filter((r) => r.isValid); + const invalid = results.filter((r) => !r.isValid); this.emit('validation-complete', { total: results.length, @@ -62,19 +62,18 @@ class ValidateCommand extends Command { if (invalid.length > 0) { this.warn(`Validation completed with ${invalid.length} issue(s)`, { - invalid: invalid.map(f => ({ + invalid: invalid.map((f) => ({ function: f.function, issues: f.issues })) }); } else { this.success(`โœ… All ${valid.length} function(s) passed validation`, { - validated: valid.map(v => v.function) + validated: valid.map((v) => v.function) }); } return results; - } catch (error) { this.error('Functions validation failed', error); throw error; @@ -94,20 +93,20 @@ class ValidateCommand extends Command { missing.push(name); } } - + if (missing.length > 0) { throw new Error(`Functions not found: ${missing.join(', ')}`); } - + return functionNames; } // Get all functions in directory const entries = fs.readdirSync(this.outputConfig.functionsDir, { withFileTypes: true }); return entries - .filter(entry => entry.isDirectory()) - .map(entry => entry.name) - .filter(name => !name.startsWith('.')); + .filter((entry) => entry.isDirectory()) + .map((entry) => entry.name) + .filter((name) => !name.startsWith('.')); } /** @@ -131,7 +130,7 @@ class ValidateCommand extends Command { const content = fs.readFileSync(indexPath, 'utf8'); const contentIssues = this.validateFunctionContent(functionName, content); issues.push(...contentIssues); - + if (contentIssues.length > 0) { isValid = false; } @@ -148,7 +147,7 @@ class ValidateCommand extends Command { const denoConfig = JSON.parse(fs.readFileSync(denoJsonPath, 'utf8')); const denoIssues = this.validateDenoConfig(functionName, denoConfig); issues.push(...denoIssues); - + if (denoIssues.length > 0) { isValid = false; } @@ -225,7 +224,7 @@ class ValidateCommand extends Command { // Check for common Deno config issues if (denoConfig.imports) { const imports = denoConfig.imports; - + // Validate import URLs for (const [key, url] of Object.entries(imports)) { if (!url.startsWith('https://')) { @@ -256,7 +255,9 @@ class ValidateCommand extends Command { if (fs.existsSync(importMapPath)) { try { const importMap = JSON.parse(fs.readFileSync(importMapPath, 'utf8')); - this.progress(`Function ${functionName} has access to import map with ${Object.keys(importMap.imports || {}).length} imports`); + this.progress( + `Function ${functionName} has access to import map with ${Object.keys(importMap.imports || {}).length} imports` + ); } catch (error) { issues.push('import_map.json exists but is invalid JSON'); } @@ -266,4 +267,4 @@ class ValidateCommand extends Command { } } -module.exports = ValidateCommand; \ No newline at end of file +export default ValidateCommand; diff --git a/starfleet/data-cli/src/commands/functions/index.js b/starfleet/data-cli/src/commands/functions/index.js new file mode 100644 index 0000000..0485c65 --- /dev/null +++ b/starfleet/data-cli/src/commands/functions/index.js @@ -0,0 +1,9 @@ +/** + * Functions Commands Index + */ + +import DeployCommand from './DeployCommand.js'; +import ValidateCommand from './ValidateCommand.js'; +import StatusCommand from './StatusCommand.js'; + +export { DeployCommand, ValidateCommand, StatusCommand }; diff --git a/src/commands/test/CompileCommand.js b/starfleet/data-cli/src/commands/test/CompileCommand.js similarity index 88% rename from src/commands/test/CompileCommand.js rename to starfleet/data-cli/src/commands/test/CompileCommand.js index 74a3a2e..e156991 100644 --- a/src/commands/test/CompileCommand.js +++ b/starfleet/data-cli/src/commands/test/CompileCommand.js @@ -2,23 +2,18 @@ * Test Compile Command */ -const path = require('path'); -const fs = require('fs').promises; -const BuildCommand = require('../../lib/BuildCommand'); +import path from 'path'; +import { promises as fs } from 'fs'; +import BuildCommand from '../../lib/BuildCommand.js'; /** * Compile tests for execution * Uses the existing MigrationCompiler but configured for test directory */ class CompileCommand extends BuildCommand { - constructor( - testsDir, - outputDir, - logger = null, - isProd = false - ) { + constructor(testsDir, outputDir, logger = null, isProd = false) { super(testsDir, outputDir, logger, isProd); - + // Validate paths are provided if (!this.inputDir || !this.outputDir) { throw new Error('CompileCommand requires test directory and output directory'); @@ -30,28 +25,30 @@ class CompileCommand extends BuildCommand { */ async performExecute() { this.emit('compilation:start', { isProd: this.isProd, type: 'test' }); - + try { this.progress('Starting test compilation...'); - + // Validate test directory structure await this.validateTestDirectory(); - + // TODO: Implement native test compilation // The legacy build system has been removed. This command needs to be reimplemented // using a native test compiler approach - throw new Error('Test compilation not yet implemented. Legacy build system has been removed.'); - + throw new Error( + 'Test compilation not yet implemented. Legacy build system has been removed.' + ); + // Validate pgTAP function signatures await this.validatePgTapFunctions(result.outputFile); - + this.success(`Test compilation completed: ${result.outputFile}`); - this.emit('compilation:complete', { + this.emit('compilation:complete', { result, type: 'test', - testsCompiled: result.stats.filesProcessed + testsCompiled: result.stats.filesProcessed }); - + return result; } catch (error) { this.error('Test compilation failed', error); @@ -66,22 +63,22 @@ class CompileCommand extends BuildCommand { async validateTestDirectory() { // Get test directory from OutputConfig const testDir = this.inputDir; - + try { const stat = await fs.stat(testDir); if (!stat.isDirectory()) { throw new Error(`Tests path is not a directory: ${testDir}`); } - + // Use glob to recursively find SQL files - const { glob } = require('glob'); + const { glob } = await import('glob'); const pattern = path.join(testDir, '**/*.sql'); const sqlFiles = await glob(pattern); - + if (sqlFiles.length === 0) { throw new Error(`No SQL test files found in: ${testDir}`); } - + this.progress(`Found ${sqlFiles.length} test files in ${testDir}`); } catch (error) { if (error.code === 'ENOENT') { @@ -103,10 +100,10 @@ class CompileCommand extends BuildCommand { .replace(/\..+/, '') .replace(/-/g, '') .slice(0, 14); - + return path.join(compiler.config.outputDir, `${timestamp}_compiled_tests.sql`); }; - + // Override the header to indicate this is a test compilation const originalWriteHeader = compiler.writeHeader.bind(compiler); compiler.writeHeader = async (outputFile) => { @@ -125,10 +122,10 @@ class CompileCommand extends BuildCommand { -- ========================================================================= `; - + await fs.writeFile(outputFile, header); compiler.stats.linesWritten += header.split('\n').length; - + compiler.emit('header:written', { outputFile, lines: header.split('\n').length @@ -141,49 +138,47 @@ class CompileCommand extends BuildCommand { */ async compileTestDirectory(compiler) { compiler.stats.startTime = new Date(); - + compiler.emit('start', { timestamp: compiler.stats.startTime, config: compiler.config, type: 'test' }); - + // Validate test directory exists const testDir = this.inputDir; await fs.stat(testDir); - + // Ensure output directory exists await fs.mkdir(compiler.config.outputDir, { recursive: true }); - + // Generate output filename const outputFile = compiler.generateOutputFilename(); - + // Write header await compiler.writeHeader(outputFile); - + // Get all SQL files in tests directory const files = await fs.readdir(testDir); - const sqlFiles = files - .filter(f => f.endsWith('.sql')) - .sort(); // Sort for consistent ordering (important for test setup) - - this.emit('compilation:progress', { - stage: 'processing_files', - totalFiles: sqlFiles.length + const sqlFiles = files.filter((f) => f.endsWith('.sql')).sort(); // Sort for consistent ordering (important for test setup) + + this.emit('compilation:progress', { + stage: 'processing_files', + totalFiles: sqlFiles.length }); - + // Process each test file for (const sqlFile of sqlFiles) { await this.processTestFile(testDir, sqlFile, outputFile, compiler); } - + // Write footer with test-specific instructions await this.writeTestFooter(outputFile, compiler); - + // Complete compiler.stats.endTime = new Date(); const duration = compiler.stats.endTime - compiler.stats.startTime; - + compiler.emit('complete', { outputFile, filesProcessed: compiler.stats.filesProcessed, @@ -192,7 +187,7 @@ class CompileCommand extends BuildCommand { timestamp: compiler.stats.endTime, type: 'test' }); - + return { success: true, outputFile, @@ -205,19 +200,19 @@ class CompileCommand extends BuildCommand { */ async processTestFile(testDir, filename, outputFile, compiler) { const filePath = path.join(testDir, filename); - + try { compiler.emit('file:start', { file: filename, path: filePath }); - + // Read file content const content = await fs.readFile(filePath, 'utf8'); - + // Validate pgTAP function structure await this.validateTestFileContent(content, filename); - + // Write file section with test-specific formatting const fileSection = `-- ========================================================================= -- TEST FILE: ${filename} @@ -225,25 +220,24 @@ class CompileCommand extends BuildCommand { ${content} `; - + await fs.appendFile(outputFile, fileSection); - + const linesAdded = fileSection.split('\n').length; compiler.stats.linesWritten += linesAdded; compiler.stats.filesProcessed++; - + compiler.emit('file:complete', { file: filename, lines: linesAdded, size: content.length }); - - this.emit('compilation:progress', { - stage: 'file_processed', + + this.emit('compilation:progress', { + stage: 'file_processed', file: filename, processedCount: compiler.stats.filesProcessed }); - } catch (error) { compiler.emit('file:error', { file: filename, @@ -259,16 +253,17 @@ ${content} async validateTestFileContent(content, filename) { // Check for required pgTAP function patterns const lines = content.split('\n'); - + // Look for test function definitions - const testFunctionPattern = /CREATE\s+OR\s+REPLACE\s+FUNCTION\s+test\.([a-zA-Z0-9_]+)\s*\(\s*\)/i; + const testFunctionPattern = + /CREATE\s+OR\s+REPLACE\s+FUNCTION\s+test\.([a-zA-Z0-9_]+)\s*\(\s*\)/i; const tapPlanPattern = /tap\.plan\s*\(\s*(\d+)\s*\)/i; const tapFinishPattern = /tap\.finish\s*\(\s*\)/i; - + let hasTestFunction = false; let hasTapPlan = false; let hasTapFinish = false; - + for (const line of lines) { if (testFunctionPattern.test(line)) { hasTestFunction = true; @@ -280,7 +275,7 @@ ${content} hasTapFinish = true; } } - + // Emit warnings for missing pgTAP patterns (non-fatal) if (!hasTestFunction) { this.warn(`${filename}: No test functions found - may not be a pgTAP test file`); @@ -314,10 +309,10 @@ ${content} -- -- ========================================================================= `; - + await fs.appendFile(outputFile, footer); compiler.stats.linesWritten += footer.split('\n').length; - + compiler.emit('footer:written', { lines: footer.split('\n').length }); @@ -328,30 +323,34 @@ ${content} */ async validatePgTapFunctions(outputFile) { this.progress('Validating pgTAP function signatures...'); - + try { const content = await fs.readFile(outputFile, 'utf8'); - + // Look for all test function definitions - const testFunctionPattern = /CREATE\s+OR\s+REPLACE\s+FUNCTION\s+test\.([a-zA-Z0-9_]+)\s*\(\s*\)/gi; + const testFunctionPattern = + /CREATE\s+OR\s+REPLACE\s+FUNCTION\s+test\.([a-zA-Z0-9_]+)\s*\(\s*\)/gi; const functions = []; let match; - + while ((match = testFunctionPattern.exec(content)) !== null) { functions.push(match[1]); } - + if (functions.length === 0) { this.warn('No pgTAP test functions found in compiled output'); } else { this.success(`Validated ${functions.length} pgTAP test functions: ${functions.join(', ')}`); } - + // Validate that each function has proper pgTAP structure for (const func of functions) { - const funcRegex = new RegExp(`CREATE\\s+OR\\s+REPLACE\\s+FUNCTION\\s+test\\.${func}[\\s\\S]*?\\$\\$;`, 'i'); + const funcRegex = new RegExp( + `CREATE\\s+OR\\s+REPLACE\\s+FUNCTION\\s+test\\.${func}[\\s\\S]*?\\$\\$;`, + 'i' + ); const funcMatch = content.match(funcRegex); - + if (funcMatch) { const funcBody = funcMatch[0]; if (!funcBody.includes('RETURNS SETOF TEXT')) { @@ -362,7 +361,6 @@ ${content} } } } - } catch (error) { this.warn(`Could not validate pgTAP functions: ${error.message}`); } @@ -375,27 +373,27 @@ ${content} compiler.on('start', ({ timestamp, type }) => { this.logger.debug({ timestamp, type }, 'Test compilation started'); }); - + compiler.on('file:start', ({ file }) => { this.progress(`Processing test file: ${file}`); }); - + compiler.on('file:complete', ({ file, lines }) => { this.logger.debug({ file, lines }, 'Test file processed'); }); - + compiler.on('file:error', ({ file, error }) => { this.error(`Error processing test file ${file}`, error); }); - + compiler.on('complete', ({ stats, type }) => { this.logger.info({ stats, type }, 'Test compilation complete'); }); - + compiler.on('error', ({ error }) => { this.error('Test compiler error', error); }); } } -module.exports = CompileCommand; \ No newline at end of file +export default CompileCommand; diff --git a/src/commands/test/CoverageCommand.js b/starfleet/data-cli/src/commands/test/CoverageCommand.js similarity index 75% rename from src/commands/test/CoverageCommand.js rename to starfleet/data-cli/src/commands/test/CoverageCommand.js index a9e093d..1b53603 100644 --- a/src/commands/test/CoverageCommand.js +++ b/starfleet/data-cli/src/commands/test/CoverageCommand.js @@ -2,11 +2,11 @@ * Test Coverage Command */ -const TestCommand = require('../../lib/TestCommand'); -const DatabaseUtils = require('../../lib/db-utils'); -const CoverageAnalyzer = require('../../lib/test/CoverageAnalyzer'); -const chalk = require('chalk'); -const Config = require('../../lib/config'); +import TestCommand from '../../lib/TestCommand.js'; +import DatabaseUtils from '../../lib/db-utils.js'; +import CoverageAnalyzer from '../../lib/test/CoverageAnalyzer.js'; +import chalk from 'chalk'; +import Config from '../../lib/config.js'; /** * Generate test coverage reports @@ -23,39 +23,43 @@ class CoverageCommand extends TestCommand { */ async performExecute(options = {}) { this.emit('start', { isProd: this.isProd, options }); - + // Load test configuration const testConfig = await this._getTestConfig(); - + // Parse enforcement options with config defaults - const enforce = options.enforce !== undefined ? options.enforce : testConfig.coverage_enforcement; + const enforce = + options.enforce !== undefined ? options.enforce : testConfig.coverage_enforcement; const minCoverage = parseInt(options.minCoverage || testConfig.minimum_coverage || '80', 10); - const minRpcCoverage = parseInt(options.minRpcCoverage || testConfig.minimum_coverage || '75', 10); + const minRpcCoverage = parseInt( + options.minRpcCoverage || testConfig.minimum_coverage || '75', + 10 + ); const minRlsCoverage = parseInt(options.minRlsCoverage || '70', 10); - + let client = null; - + try { this.progress('Connecting to database...'); - + // Connect to the main postgres database (default database name) client = this.dbUtils.createDatabaseClient('postgres'); await client.connect(); - + this.progress('Analyzing RPC function coverage...'); - + // Query RPC coverage const rpcResult = await client.query('SELECT * FROM test.analyze_rpc_coverage()'); const rpcAnalysis = this.analyzer.analyzeRpcCoverage(rpcResult.rows); - + this.progress('Analyzing RLS policy coverage...'); - + // Query RLS policy coverage const policyResult = await client.query('SELECT * FROM test.analyze_policy_coverage()'); const policyAnalysis = this.analyzer.analyzePolicyCoverage(policyResult.rows); - + this.progress('Generating coverage summary...'); - + // Query overall summary let summaryResult = null; try { @@ -65,57 +69,59 @@ class CoverageCommand extends TestCommand { // Summary function might not exist in some migrations this.warn('Could not retrieve coverage summary - function may not be available'); } - + this.progress('Formatting coverage report...'); - + // Generate formatted report const report = this.analyzer.formatCoverageReport(rpcAnalysis, policyAnalysis, summaryResult); - + // Output the report console.log('\n' + report); - + // Generate stats for return value const stats = this.analyzer.generateCoverageStats(rpcAnalysis, policyAnalysis); - + // Enforce coverage thresholds if requested if (enforce) { this.progress('Enforcing coverage thresholds...'); this.enforcementResult = this.enforceCoverageThresholds( - stats, - minCoverage, - minRpcCoverage, + stats, + minCoverage, + minRpcCoverage, minRlsCoverage ); - + if (!this.enforcementResult.passed) { // Exit after emitting the event and returning result - this.emit('failed', { error: new Error('Coverage enforcement failed'), thresholds: this.enforcementResult }); + this.emit('failed', { + error: new Error('Coverage enforcement failed'), + thresholds: this.enforcementResult + }); // Note: process.exit will be handled after the function returns } else { this.success('All coverage thresholds met!'); } } - - this.emit('complete', { - rpcAnalysis, - policyAnalysis, + + this.emit('complete', { + rpcAnalysis, + policyAnalysis, summary: summaryResult, stats, - report + report }); - + // Exit with non-zero code if enforcement failed if (enforce && this.enforcementResult && !this.enforcementResult.passed) { process.exit(1); } - + return { rpc: rpcAnalysis, policies: policyAnalysis, summary: summaryResult, overall: stats.overall }; - } catch (error) { // Handle common database connection errors with helpful messages if (error.code === 'ECONNREFUSED') { @@ -124,14 +130,21 @@ class CoverageCommand extends TestCommand { } else if (error.code === '3D000') { this.error('Database "postgres" does not exist.'); this.info('Make sure you are connected to the correct database.'); - } else if (error.message.includes('test.analyze_rpc_coverage') || error.message.includes('does not exist')) { + } else if ( + error.message.includes('test.analyze_rpc_coverage') || + error.message.includes('does not exist') + ) { this.error('Test coverage functions not found in database.'); - this.info('Run the test coverage migration: data db compile-migration && supabase db reset'); - this.warn('Make sure migration 20250829_050000_test_coverage_analysis.sql has been applied.'); + this.info( + 'Run the test coverage migration: data db compile-migration && supabase db reset' + ); + this.warn( + 'Make sure migration 20250829_050000_test_coverage_analysis.sql has been applied.' + ); } else { this.error('Failed to analyze test coverage', error); } - + this.emit('failed', { error }); throw error; } finally { @@ -144,7 +157,7 @@ class CoverageCommand extends TestCommand { } } } - + /** * Enforce coverage thresholds * @param {Object} stats - Coverage statistics @@ -156,17 +169,26 @@ class CoverageCommand extends TestCommand { enforceCoverageThresholds(stats, minOverall, minRpc, minRls) { const failures = []; let passed = true; - + // Check overall coverage if (stats.overall && stats.overall.percentage < minOverall) { const message = `Overall coverage ${stats.overall.percentage}% below threshold ${minOverall}%`; this.error(chalk.red(message)); - failures.push({ type: 'overall', actual: stats.overall.percentage, expected: minOverall, message }); + failures.push({ + type: 'overall', + actual: stats.overall.percentage, + expected: minOverall, + message + }); passed = false; } else if (stats.overall) { - this.success(chalk.green(`โœ“ Overall coverage ${stats.overall.percentage}% meets threshold ${minOverall}%`)); + this.success( + chalk.green( + `โœ“ Overall coverage ${stats.overall.percentage}% meets threshold ${minOverall}%` + ) + ); } - + // Check RPC coverage if (stats.rpc && stats.rpc.percentage < minRpc) { const message = `RPC function coverage ${stats.rpc.percentage}% below threshold ${minRpc}%`; @@ -174,9 +196,11 @@ class CoverageCommand extends TestCommand { failures.push({ type: 'rpc', actual: stats.rpc.percentage, expected: minRpc, message }); passed = false; } else if (stats.rpc) { - this.success(chalk.green(`โœ“ RPC function coverage ${stats.rpc.percentage}% meets threshold ${minRpc}%`)); + this.success( + chalk.green(`โœ“ RPC function coverage ${stats.rpc.percentage}% meets threshold ${minRpc}%`) + ); } - + // Check RLS policy coverage if (stats.policies && stats.policies.percentage < minRls) { const message = `RLS policy coverage ${stats.policies.percentage}% below threshold ${minRls}%`; @@ -184,26 +208,36 @@ class CoverageCommand extends TestCommand { failures.push({ type: 'rls', actual: stats.policies.percentage, expected: minRls, message }); passed = false; } else if (stats.policies) { - this.success(chalk.green(`โœ“ RLS policy coverage ${stats.policies.percentage}% meets threshold ${minRls}%`)); + this.success( + chalk.green( + `โœ“ RLS policy coverage ${stats.policies.percentage}% meets threshold ${minRls}%` + ) + ); } - + // Summary if (passed) { this.success(chalk.bold.green('๐ŸŽ‰ All coverage thresholds met!')); } else { - this.error(chalk.bold.red(`๐Ÿ’ฅ Coverage enforcement failed - ${failures.length} threshold(s) not met`)); - + this.error( + chalk.bold.red(`๐Ÿ’ฅ Coverage enforcement failed - ${failures.length} threshold(s) not met`) + ); + // Show details of failures - failures.forEach(failure => { + failures.forEach((failure) => { this.error(chalk.red(` โ€ข ${failure.type}: ${failure.actual}% < ${failure.expected}%`)); }); - + this.progress(chalk.yellow('\nTo fix coverage issues:')); - this.progress(chalk.yellow(' 1. Run: ./build/data test coverage (to see detailed coverage report)')); - this.progress(chalk.yellow(' 2. Add missing tests for uncovered RPC functions and RLS policies')); + this.progress( + chalk.yellow(' 1. Run: ./build/data test coverage (to see detailed coverage report)') + ); + this.progress( + chalk.yellow(' 2. Add missing tests for uncovered RPC functions and RLS policies') + ); this.progress(chalk.yellow(' 3. Re-run with --enforce to validate improvements')); } - + return { passed, failures, @@ -223,7 +257,7 @@ class CoverageCommand extends TestCommand { if (this.config) { return this.config.getTestConfig(); } - + try { const config = await Config.load(); return config.getTestConfig(); @@ -235,4 +269,4 @@ class CoverageCommand extends TestCommand { } } -module.exports = CoverageCommand; \ No newline at end of file +export default CoverageCommand; diff --git a/src/commands/test/DevCycleCommand.js b/starfleet/data-cli/src/commands/test/DevCycleCommand.js similarity index 85% rename from src/commands/test/DevCycleCommand.js rename to starfleet/data-cli/src/commands/test/DevCycleCommand.js index 4d7f944..28d603e 100644 --- a/src/commands/test/DevCycleCommand.js +++ b/starfleet/data-cli/src/commands/test/DevCycleCommand.js @@ -1,15 +1,15 @@ /** * Test Dev-Cycle Command - * + * * Orchestrates the full development cycle: Compile โ†’ Reset โ†’ Test * Provides rapid feedback for database test development workflow */ -const TestCommand = require('../../lib/TestCommand'); -const CompileCommand = require('./CompileCommand'); -const RunCommand = require('./RunCommand'); -const ResetCommand = require('../db/ResetCommand'); -const Config = require('../../lib/config'); +import TestCommand from '../../lib/TestCommand.js'; +import CompileCommand from './CompileCommand.js'; +import RunCommand from './RunCommand.js'; +import ResetCommand from '../db/ResetCommand.js'; +import Config from '../../lib/config.js'; /** * Development cycle command that orchestrates compile โ†’ reset โ†’ test workflow @@ -25,10 +25,10 @@ class DevCycleCommand extends TestCommand { pathResolver = null ) { super(databaseUrl, serviceRoleKey, testsDir, outputDir, logger, isProd, pathResolver); - + // Dev-cycle never requires production confirmation - it's a development tool this.requiresProductionConfirmation = false; - + // Track timing for performance reporting this.timings = {}; } @@ -38,44 +38,43 @@ class DevCycleCommand extends TestCommand { */ async performExecute(options = {}) { const startTime = new Date(); - - this.emit('dev-cycle:start', { - isProd: this.isProd, + + this.emit('dev-cycle:start', { + isProd: this.isProd, testsDir: this.testsDir, outputDir: this.outputDir, options }); - + try { // Load test configuration to respect settings const testConfig = await this._getTestConfig(); - + this.progress('Starting development cycle: Compile โ†’ Reset โ†’ Test'); - + // Step 1: Compile tests await this._executeCompileStep(); - - // Step 2: Reset database + + // Step 2: Reset database await this._executeResetStep(); - + // Step 3: Run tests const testResults = await this._executeTestStep(options); - + // Calculate total execution time const totalTime = new Date() - startTime; this.timings.total = totalTime; - + // Report completion this._reportCycleCompletion(testResults, totalTime); - + this.emit('dev-cycle:complete', { results: testResults, timings: this.timings, success: testResults.failed === 0 }); - + return testResults; - } catch (error) { const totalTime = new Date() - startTime; this.error(`Development cycle failed after ${this._formatDuration(totalTime)}`, error); @@ -92,7 +91,7 @@ class DevCycleCommand extends TestCommand { const stepStart = new Date(); this.progress('Step 1/3: Compiling tests...'); this.emit('dev-cycle:step', { step: 1, name: 'compile', status: 'running' }); - + try { // Create compile command using migration_output resource exclusively const compileCommand = new CompileCommand( @@ -101,38 +100,37 @@ class DevCycleCommand extends TestCommand { this.logger, this.isProd ); - + // Attach progress listeners compileCommand.on('compilation:progress', (progress) => { this.emit('dev-cycle:compile-progress', progress); }); - + // Execute compilation const result = await compileCommand.execute(); - + const stepTime = new Date() - stepStart; this.timings.compile = stepTime; - + this.success(`โœ“ Compilation complete (${this._formatDuration(stepTime)})`); - this.emit('dev-cycle:step', { - step: 1, - name: 'compile', + this.emit('dev-cycle:step', { + step: 1, + name: 'compile', status: 'complete', duration: stepTime, - result + result }); - + return result; - } catch (error) { const stepTime = new Date() - stepStart; this.timings.compile = stepTime; - this.emit('dev-cycle:step', { - step: 1, - name: 'compile', + this.emit('dev-cycle:step', { + step: 1, + name: 'compile', status: 'failed', duration: stepTime, - error + error }); throw new Error(`Compilation failed: ${error.message}`); } @@ -146,7 +144,7 @@ class DevCycleCommand extends TestCommand { const stepStart = new Date(); this.progress('Step 2/3: Resetting database...'); this.emit('dev-cycle:step', { step: 2, name: 'reset', status: 'running' }); - + try { // Create reset command - ResetCommand only takes specific parameters const resetCommand = new ResetCommand( @@ -156,40 +154,39 @@ class DevCycleCommand extends TestCommand { this.logger, this.isProd ); - + // The ResetCommand needs access to outputConfig for supabase directory // We'll create a simple OutputConfig for this purpose - const OutputConfig = require('../../lib/OutputConfig'); + const { default: OutputConfig } = await import('../../lib/OutputConfig.js'); resetCommand.outputConfig = new OutputConfig(); - + // Attach progress listeners resetCommand.on('output', (output) => { this.emit('dev-cycle:reset-output', output); }); - + // Execute reset await resetCommand.execute(); - + const stepTime = new Date() - stepStart; this.timings.reset = stepTime; - + this.success(`โœ“ Database reset complete (${this._formatDuration(stepTime)})`); - this.emit('dev-cycle:step', { - step: 2, - name: 'reset', + this.emit('dev-cycle:step', { + step: 2, + name: 'reset', status: 'complete', - duration: stepTime + duration: stepTime }); - } catch (error) { const stepTime = new Date() - stepStart; this.timings.reset = stepTime; - this.emit('dev-cycle:step', { - step: 2, - name: 'reset', + this.emit('dev-cycle:step', { + step: 2, + name: 'reset', status: 'failed', duration: stepTime, - error + error }); throw new Error(`Database reset failed: ${error.message}`); } @@ -203,7 +200,7 @@ class DevCycleCommand extends TestCommand { const stepStart = new Date(); this.progress('Step 3/3: Running tests...'); this.emit('dev-cycle:step', { step: 3, name: 'test', status: 'running' }); - + try { // Create run command const runCommand = new RunCommand( @@ -214,48 +211,49 @@ class DevCycleCommand extends TestCommand { this.logger, this.isProd ); - + // Attach progress listeners runCommand.on('start', (event) => { this.emit('dev-cycle:test-start', event); }); - + runCommand.on('complete', (event) => { this.emit('dev-cycle:test-complete', event); }); - + // Execute tests with passed options const testResults = await runCommand.execute(options); - + const stepTime = new Date() - stepStart; this.timings.test = stepTime; - + // Success message depends on test results if (testResults.failed === 0) { this.success(`โœ“ All tests passed (${this._formatDuration(stepTime)})`); } else { - this.warn(`โœ— ${testResults.failed}/${testResults.total} tests failed (${this._formatDuration(stepTime)})`); + this.warn( + `โœ— ${testResults.failed}/${testResults.total} tests failed (${this._formatDuration(stepTime)})` + ); } - - this.emit('dev-cycle:step', { - step: 3, - name: 'test', + + this.emit('dev-cycle:step', { + step: 3, + name: 'test', status: 'complete', duration: stepTime, - results: testResults + results: testResults }); - + return testResults; - } catch (error) { const stepTime = new Date() - stepStart; this.timings.test = stepTime; - this.emit('dev-cycle:step', { - step: 3, - name: 'test', + this.emit('dev-cycle:step', { + step: 3, + name: 'test', status: 'failed', duration: stepTime, - error + error }); throw new Error(`Test execution failed: ${error.message}`); } @@ -270,14 +268,14 @@ class DevCycleCommand extends TestCommand { console.log('โ•'.repeat(60)); console.log('๐Ÿ”„ DEV-CYCLE COMPLETE'); console.log('โ•'.repeat(60)); - + // Step timing breakdown console.log('\nStep Timings:'); console.log(` Compile: ${this._formatDuration(this.timings.compile || 0)}`); console.log(` Reset: ${this._formatDuration(this.timings.reset || 0)}`); console.log(` Test: ${this._formatDuration(this.timings.test || 0)}`); console.log(` Total: ${this._formatDuration(totalTime)}`); - + // Test results summary console.log('\nTest Results:'); if (testResults.total === 0) { @@ -290,7 +288,7 @@ class DevCycleCommand extends TestCommand { console.log(` Skipped: ${testResults.skipped}`); } } - + // Overall status if (testResults.failed === 0 && testResults.total > 0) { console.log('\nโœ… Cycle successful - All tests passed!'); @@ -299,7 +297,7 @@ class DevCycleCommand extends TestCommand { } else { console.log('\nโš ๏ธ Cycle completed - No tests found'); } - + console.log('โ•'.repeat(60)); } @@ -344,4 +342,4 @@ class DevCycleCommand extends TestCommand { } } -module.exports = DevCycleCommand; \ No newline at end of file +export default DevCycleCommand; diff --git a/src/commands/test/GenerateCommand.js b/starfleet/data-cli/src/commands/test/GenerateCommand.js similarity index 96% rename from src/commands/test/GenerateCommand.js rename to starfleet/data-cli/src/commands/test/GenerateCommand.js index 7e45b07..b2cf0cb 100644 --- a/src/commands/test/GenerateCommand.js +++ b/starfleet/data-cli/src/commands/test/GenerateCommand.js @@ -1,26 +1,21 @@ /** * Test Generate Command - * + * * Generate pgTAP test templates for RPC functions and RLS policies. * Creates properly structured test files in the correct directories. */ -const fs = require('fs').promises; -const path = require('path'); -const TestCommand = require('../../lib/TestCommand'); +import { promises as fs } from 'fs'; +import path from 'path'; +import TestCommand from '../../lib/TestCommand.js'; /** * Generate pgTAP test templates for RPC functions and RLS policies */ class GenerateCommand extends TestCommand { - constructor( - testsDir, - outputDir, - logger = null, - isProd = false - ) { + constructor(testsDir, outputDir, logger = null, isProd = false) { super(null, null, testsDir, outputDir, logger, isProd); - + // Test generation doesn't require database access this.requiresProductionConfirmation = false; } @@ -34,11 +29,11 @@ class GenerateCommand extends TestCommand { */ async performExecute(options = {}) { this.emit('generation:start', { type: options.type, name: options.name }); - + try { // Validate options this.validateGenerationOptions(options); - + // Determine template type and generate let result; if (options.type === 'rpc') { @@ -48,12 +43,11 @@ class GenerateCommand extends TestCommand { } else { throw new Error(`Unsupported test type: ${options.type}`); } - + this.success(`Test template generated: ${result.outputFile}`); this.emit('generation:complete', result); - + return result; - } catch (error) { this.error('Test template generation failed', error); this.emit('generation:failed', { error, type: options.type, name: options.name }); @@ -69,15 +63,15 @@ class GenerateCommand extends TestCommand { if (!options.type) { throw new Error('Test type is required. Use --rpc or --rls'); } - + if (!options.name) { throw new Error('Function or table name is required'); } - + if (!['rpc', 'rls'].includes(options.type)) { throw new Error('Test type must be either "rpc" or "rls"'); } - + // Validate name format if (!/^[a-zA-Z0-9_]+$/.test(options.name)) { throw new Error('Name must contain only letters, numbers, and underscores'); @@ -93,18 +87,18 @@ class GenerateCommand extends TestCommand { const testDir = await this.getTestsDir(); const rpcTestDir = path.join(testDir, '002_rpc_tests'); const outputFile = path.join(rpcTestDir, `${functionName}.test.sql`); - + // Ensure RPC test directory exists await fs.mkdir(rpcTestDir, { recursive: true }); - + // Generate template content const template = this.generateRpcTemplate(functionName); - + // Write template file await fs.writeFile(outputFile, template, 'utf8'); - + this.progress(`Generated RPC test template: ${outputFile}`); - + return { type: 'rpc', functionName, @@ -123,18 +117,18 @@ class GenerateCommand extends TestCommand { const testDir = await this.getTestsDir(); const rlsTestDir = path.join(testDir, '003_rls_tests'); const outputFile = path.join(rlsTestDir, `${tableName}.test.sql`); - + // Ensure RLS test directory exists await fs.mkdir(rlsTestDir, { recursive: true }); - + // Generate template content const template = this.generateRlsTemplate(tableName); - + // Write template file await fs.writeFile(outputFile, template, 'utf8'); - + this.progress(`Generated RLS test template: ${outputFile}`); - + return { type: 'rls', tableName, @@ -151,7 +145,7 @@ class GenerateCommand extends TestCommand { */ generateRpcTemplate(functionName) { const testFunctionName = `run_${functionName}_tests`; - + return `-- ========================================================================= -- RPC FUNCTION TESTS: ${functionName} -- ========================================================================= @@ -257,7 +251,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${functionName} RPC */ generateRlsTemplate(tableName) { const testFunctionName = `run_${tableName}_rls_tests`; - + return `-- ========================================================================= -- RLS POLICY TESTS: ${tableName} -- ========================================================================= @@ -410,7 +404,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for Row Level Security // For now, return common functions based on existing patterns return [ 'get_random_pets', - 'get_pet_details', + 'get_pet_details', 'search_adoptable_pets', 'is_admin', 'is_bootstrap_mode', @@ -427,14 +421,8 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for Row Level Security */ async listAvailableTables() { // Common tables from the schema - return [ - 'pets', - 'applications', - 'donations', - 'profiles', - 'admin_members' - ]; + return ['pets', 'applications', 'donations', 'profiles', 'admin_members']; } } -module.exports = GenerateCommand; \ No newline at end of file +export default GenerateCommand; diff --git a/src/commands/test/GenerateTemplateCommand.js b/starfleet/data-cli/src/commands/test/GenerateTemplateCommand.js similarity index 80% rename from src/commands/test/GenerateTemplateCommand.js rename to starfleet/data-cli/src/commands/test/GenerateTemplateCommand.js index 36fecaa..0dd64cb 100644 --- a/src/commands/test/GenerateTemplateCommand.js +++ b/starfleet/data-cli/src/commands/test/GenerateTemplateCommand.js @@ -1,31 +1,26 @@ /** * Generate Template Command - * + * * Generate pgTAP test templates using TestTemplateGenerator and TestRequirementAnalyzer. * Supports generating from migration files, specific test types, and custom requirements. */ -const fs = require('fs').promises; -const path = require('path'); -const TestCommand = require('../../lib/TestCommand'); -const TestTemplateGenerator = require('../../lib/testing/TestTemplateGenerator'); -const { TestRequirementAnalyzer } = require('../../lib/testing/TestRequirementAnalyzer'); +import { promises as fs } from 'fs'; +import path from 'path'; +import TestCommand from '../../lib/TestCommand.js'; +import TestTemplateGenerator from '../../lib/testing/TestTemplateGenerator.js'; +import { TestRequirementAnalyzer } from '../../lib/testing/TestRequirementAnalyzer.js'; /** * Generate pgTAP test templates with advanced analysis capabilities */ class GenerateTemplateCommand extends TestCommand { - constructor( - testsDir, - outputDir, - logger = null, - isProd = false - ) { + constructor(testsDir, outputDir, logger = null, isProd = false) { super(null, null, testsDir, outputDir, logger, isProd); - + // Template generation doesn't require database access or production confirmation this.requiresProductionConfirmation = false; - + // Initialize generators this.templateGenerator = new TestTemplateGenerator(); this.requirementAnalyzer = new TestRequirementAnalyzer(); @@ -45,21 +40,21 @@ class GenerateTemplateCommand extends TestCommand { * @returns {Promise} Generation result */ async performExecute(options = {}) { - this.emit('template:generation:start', { + this.emit('template:generation:start', { migration: options.migration, - type: options.type, - name: options.name + type: options.type, + name: options.name }); - + try { // Validate options this.validateGenerationOptions(options); - + // Generate requirements based on input let requirements; if (options.migration) { requirements = await this.analyzeRequirementsFromMigration(options.migration); - + // Filter by type if specified if (options.type) { requirements = this.filterRequirementsByType(requirements, options.type); @@ -68,47 +63,50 @@ class GenerateTemplateCommand extends TestCommand { // Generate single requirement from options requirements = [this.createRequirementFromOptions(options)]; } - + if (requirements.length === 0) { - throw new Error('No test requirements found. Check migration file or provide --type and --name options.'); + throw new Error( + 'No test requirements found. Check migration file or provide --type and --name options.' + ); } - + // Generate templates const result = this.templateGenerator.generateBatch(requirements); - + if (result.errors.length > 0) { - this.warn(`Generated ${result.totalGenerated} templates with ${result.errors.length} errors`); - result.errors.forEach(error => { + this.warn( + `Generated ${result.totalGenerated} templates with ${result.errors.length} errors` + ); + result.errors.forEach((error) => { this.error(`Error generating template for ${error.requirement?.name}: ${error.error}`); }); } - + // Output templates await this.outputTemplates(result.templates, options.output); - + const summaryText = this.formatGenerationSummary(result); this.success(`Test template generation completed\n${summaryText}`); - + this.emit('template:generation:complete', { totalGenerated: result.totalGenerated, summary: result.summary, errors: result.errors }); - + return { templates: result.templates, summary: result.summary, totalGenerated: result.totalGenerated, errors: result.errors }; - } catch (error) { this.error('Test template generation failed', error); - this.emit('template:generation:failed', { - error, + this.emit('template:generation:failed', { + error, migration: options.migration, - type: options.type, - name: options.name + type: options.type, + name: options.name }); throw error; } @@ -123,25 +121,27 @@ class GenerateTemplateCommand extends TestCommand { if (!options.migration && (!options.type || !options.name)) { throw new Error('Either --migration or both --type and --name must be provided'); } - + // If migration file specified, check if it exists if (options.migration && !fs.access(options.migration).catch(() => false)) { // We'll validate file existence in analyzeRequirementsFromMigration } - + // Validate test type if specified if (options.type) { const validTypes = ['rpc', 'rls', 'trigger', 'constraint', 'function']; if (!validTypes.includes(options.type)) { - throw new Error(`Invalid test type: ${options.type}. Must be one of: ${validTypes.join(', ')}`); + throw new Error( + `Invalid test type: ${options.type}. Must be one of: ${validTypes.join(', ')}` + ); } } - + // Validate name format if specified if (options.name && !/^[a-zA-Z0-9_]+$/.test(options.name)) { throw new Error('Name must contain only letters, numbers, and underscores'); } - + // Validate output path if specified if (options.output && !path.isAbsolute(options.output)) { // Convert to absolute path relative to current working directory @@ -158,21 +158,20 @@ class GenerateTemplateCommand extends TestCommand { try { // Check if file exists await fs.access(migrationPath); - + this.progress(`Analyzing migration file: ${migrationPath}`); - + // Read migration file const migrationContent = await fs.readFile(migrationPath, 'utf8'); - + // Parse migration content to AST operations const operations = await this.parseMigrationToOperations(migrationContent); - + // Analyze operations to determine test requirements const analysis = await this.requirementAnalyzer.analyzeOperations(operations); - + // Convert analysis results to template requirements return this.convertAnalysisToRequirements(analysis.requirements); - } catch (error) { if (error.code === 'ENOENT') { throw new Error(`Migration file not found: ${migrationPath}`); @@ -189,13 +188,13 @@ class GenerateTemplateCommand extends TestCommand { async parseMigrationToOperations(migrationContent) { // Simple SQL parsing for common operations // In a more complete implementation, you might use a proper SQL AST parser - + const operations = []; const lines = migrationContent.split('\n'); - + for (const line of lines) { const trimmed = line.trim().toUpperCase(); - + // Create table operations if (trimmed.startsWith('CREATE TABLE')) { const match = line.match(/CREATE TABLE\s+(?:IF NOT EXISTS\s+)?(\w+\.)?(\w+)/i); @@ -207,9 +206,12 @@ class GenerateTemplateCommand extends TestCommand { }); } } - + // Create function operations - else if (trimmed.startsWith('CREATE OR REPLACE FUNCTION') || trimmed.startsWith('CREATE FUNCTION')) { + else if ( + trimmed.startsWith('CREATE OR REPLACE FUNCTION') || + trimmed.startsWith('CREATE FUNCTION') + ) { const match = line.match(/CREATE (?:OR REPLACE )?FUNCTION\s+(?:(\w+)\.)?(\w+)\s*\(/i); if (match) { operations.push({ @@ -219,10 +221,12 @@ class GenerateTemplateCommand extends TestCommand { }); } } - + // RLS enable operations else if (trimmed.includes('ROW LEVEL SECURITY') || trimmed.includes('ENABLE RLS')) { - const match = line.match(/ALTER TABLE\s+(?:(\w+)\.)?(\w+)\s+ENABLE\s+ROW\s+LEVEL\s+SECURITY/i); + const match = line.match( + /ALTER TABLE\s+(?:(\w+)\.)?(\w+)\s+ENABLE\s+ROW\s+LEVEL\s+SECURITY/i + ); if (match) { operations.push({ type: 'ENABLE_RLS', @@ -231,7 +235,7 @@ class GenerateTemplateCommand extends TestCommand { }); } } - + // Trigger operations else if (trimmed.startsWith('CREATE TRIGGER')) { const match = line.match(/CREATE TRIGGER\s+(\w+)\s+.*ON\s+(?:(\w+)\.)?(\w+)/i); @@ -244,7 +248,7 @@ class GenerateTemplateCommand extends TestCommand { }); } } - + // Constraint operations else if (trimmed.includes('ADD CONSTRAINT')) { const match = line.match(/ADD CONSTRAINT\s+(\w+)/i); @@ -256,7 +260,7 @@ class GenerateTemplateCommand extends TestCommand { } } } - + return operations; } @@ -266,16 +270,16 @@ class GenerateTemplateCommand extends TestCommand { * @returns {Array} Template requirements */ convertAnalysisToRequirements(analysisRequirements) { - return analysisRequirements.map(req => { + return analysisRequirements.map((req) => { // Map analyzer requirement types to template types const typeMapping = { - 'FUNCTION': 'rpc', - 'RLS': 'rls', - 'TRIGGER': 'trigger', - 'CONSTRAINT': 'constraint', - 'SCHEMA': 'function' + FUNCTION: 'rpc', + RLS: 'rls', + TRIGGER: 'trigger', + CONSTRAINT: 'constraint', + SCHEMA: 'function' }; - + return { type: typeMapping[req.type] || 'function', name: req.target, @@ -312,7 +316,7 @@ class GenerateTemplateCommand extends TestCommand { * @returns {Array} Filtered requirements */ filterRequirementsByType(requirements, type) { - return requirements.filter(req => req.type === type); + return requirements.filter((req) => req.type === type); } /** @@ -323,39 +327,45 @@ class GenerateTemplateCommand extends TestCommand { async outputTemplates(templates, outputPath) { if (outputPath) { // Output to file - const combinedContent = templates.map(template => { - return `-- =========================================================================\n` + - `-- Generated Template: ${template.metadata.name} (${template.type})\n` + - `-- File: ${template.filename}\n` + - `-- Directory: ${template.directory}\n` + - `-- Generated: ${template.metadata.generatedAt}\n` + - `-- =========================================================================\n\n` + - template.content; - }).join('\n\n'); - + const combinedContent = templates + .map((template) => { + return ( + '-- =========================================================================\n' + + `-- Generated Template: ${template.metadata.name} (${template.type})\n` + + `-- File: ${template.filename}\n` + + `-- Directory: ${template.directory}\n` + + `-- Generated: ${template.metadata.generatedAt}\n` + + '-- =========================================================================\n\n' + + template.content + ); + }) + .join('\n\n'); + // Ensure output directory exists await fs.mkdir(path.dirname(outputPath), { recursive: true }); - + // Write to file await fs.writeFile(outputPath, combinedContent, 'utf8'); - + this.progress(`Templates written to: ${outputPath}`); } else { // Output to stdout - templates.forEach(template => { + templates.forEach((template) => { console.log(`-- Generated Template: ${template.metadata.name} (${template.type})`); console.log(`-- Suggested path: ${path.join(template.directory, template.filename)}\n`); console.log(template.content); console.log('\n' + '='.repeat(80) + '\n'); }); } - + // Also suggest individual file creation if (templates.length > 1 && !outputPath) { this.info('\nTo save individual template files, you can use:'); - templates.forEach(template => { + templates.forEach((template) => { const fullPath = path.join('tests', template.directory, template.filename); - console.log(` data test generate-template --type ${template.type} --name ${template.metadata.name} --output ${fullPath}`); + console.log( + ` data test generate-template --type ${template.type} --name ${template.metadata.name} --output ${fullPath}` + ); }); } } @@ -366,23 +376,21 @@ class GenerateTemplateCommand extends TestCommand { * @returns {string} Formatted summary */ formatGenerationSummary(result) { - const lines = [ - `Total templates generated: ${result.totalGenerated}` - ]; - + const lines = [`Total templates generated: ${result.totalGenerated}`]; + if (Object.keys(result.summary).length > 0) { lines.push('Templates by type:'); Object.entries(result.summary).forEach(([type, count]) => { lines.push(` ${type}: ${count}`); }); } - + if (result.errors.length > 0) { lines.push(`Errors encountered: ${result.errors.length}`); } - + return lines.join('\n'); } } -module.exports = GenerateTemplateCommand; \ No newline at end of file +export default GenerateTemplateCommand; diff --git a/src/commands/test/RunCommand.js b/starfleet/data-cli/src/commands/test/RunCommand.js similarity index 65% rename from src/commands/test/RunCommand.js rename to starfleet/data-cli/src/commands/test/RunCommand.js index abdcf1f..f2d0932 100644 --- a/src/commands/test/RunCommand.js +++ b/starfleet/data-cli/src/commands/test/RunCommand.js @@ -2,32 +2,35 @@ * Test Run Command */ -const { Client } = require('pg'); -const chalk = require('chalk').default || require('chalk'); -const fs = require('fs').promises; -const path = require('path'); -const TestCommand = require('../../lib/TestCommand'); -const ResultParser = require('../../lib/test/ResultParser'); -const { JUnitFormatter, JSONFormatter } = require('../../lib/test/formatters'); -const TestCache = require('../../lib/test/TestCache'); -const Config = require('../../lib/config'); +import { Client } from 'pg'; +import chalk from 'chalk'; +import { promises as fs } from 'fs'; +import { extname, dirname } from 'path'; +import TestCommand from '../../lib/TestCommand.js'; +import ResultParser from '../../lib/test/ResultParser.js'; +import { JUnitFormatter, JSONFormatter } from '../../reporters/test-formatters/index.js'; +import Config from '../../lib/config.js'; /** * Run compiled tests using pgTAP */ class RunCommand extends TestCommand { - constructor(databaseUrl, serviceRoleKey = null, testsDir, outputDir, logger = null, isProd = false, config = null) { + constructor( + databaseUrl, + serviceRoleKey = null, + testsDir, + outputDir, + logger = null, + isProd = false, + config = null + ) { super(databaseUrl, serviceRoleKey, testsDir, outputDir, logger, isProd); this.parser = new ResultParser(); this.config = config; - - // Initialize test cache for performance optimization - this.testCache = new TestCache('.data-cache/test-results', logger); - + // Performance tracking this.performanceMetrics = { totalExecutionTime: 0, - cacheHits: 0, cacheMisses: 0, testsExecuted: 0, testsFromCache: 0 @@ -40,27 +43,27 @@ class RunCommand extends TestCommand { async performExecute(options = {}) { const startTime = Date.now(); this.emit('start', { isProd: this.isProd, options }); - + // Enable/disable cache based on options const cacheEnabled = options.cache !== false; // Cache enabled by default - + try { // Load and apply test configuration const testConfig = await this._getTestConfig(); options = this._applyTestConfig(options, testConfig); - + this.progress('Connecting to database...'); const client = await this._createDatabaseClient(); - + // Set query timeout based on config if (testConfig.test_timeout && testConfig.test_timeout > 0) { client.query_timeout = testConfig.test_timeout * 1000; // Convert to milliseconds } - + try { this.progress('Discovering test functions...'); const testFunctions = await this._discoverTestFunctions(client); - + if (testFunctions.length === 0) { this.warn('No test functions found in test schema'); const emptyResults = { @@ -75,7 +78,7 @@ class RunCommand extends TestCommand { } this.success(`Found ${testFunctions.length} test function(s)`); - + // Determine which tests to run const testsToRun = this._filterTestFunctions(testFunctions, options); @@ -94,73 +97,33 @@ class RunCommand extends TestCommand { } this.progress(`Running ${testsToRun.length} test function(s)...`); - + // Determine if parallel execution is enabled (default: true for better performance) const runParallel = options.parallel !== false; const maxConcurrency = options.maxConcurrency || 5; // Limit concurrent database connections - + // Execute tests with caching let allResults = []; - + if (runParallel) { // Parallel execution for better performance const testPromises = testsToRun.map(async (testFunc) => { const funcStartTime = Date.now(); - - // Try cache first if enabled - let tapOutput = null; - let fromCache = false; - - if (cacheEnabled) { - const hash = await this.testCache.calculateHash(testFunc, this.databaseUrl, options); - const cachedResult = await this.testCache.getCachedResult(hash); - - if (cachedResult && cachedResult.tapOutput) { - tapOutput = cachedResult.tapOutput; - fromCache = true; - this.performanceMetrics.cacheHits++; - this.performanceMetrics.testsFromCache++; - this.progress(`${chalk.blue('โœ“')} ${testFunc} (cached, saved ~${cachedResult.originalDuration || 0}ms)`); - } else { - this.performanceMetrics.cacheMisses++; - } - } - - // Execute test if not cached - if (!tapOutput) { - this.progress(`Running ${testFunc}...`); - const testStartTime = Date.now(); - tapOutput = await this._executeTestFunction(client, testFunc); - const testDuration = Date.now() - testStartTime; - - // Cache the result if caching is enabled - if (cacheEnabled) { - try { - const hash = await this.testCache.calculateHash(testFunc, this.databaseUrl, options); - await this.testCache.storeResult(hash, { - tapOutput: tapOutput, - originalDuration: testDuration - }, { - testFunction: testFunc, - duration: testDuration, - databaseUrl: this.databaseUrl, - options: options - }); - } catch (cacheError) { - this.warn(`Failed to cache result for ${testFunc}: ${cacheError.message}`); - } - } - } - + + // Execute test + this.progress(`Running ${testFunc}...`); + const testStartTime = Date.now(); + const tapOutput = await this._executeTestFunction(client, testFunc); + const testDuration = Date.now() - testStartTime; + this.performanceMetrics.testsExecuted++; - return { - function: testFunc, - output: tapOutput, - fromCache: fromCache, + return { + function: testFunc, + output: tapOutput, duration: Date.now() - funcStartTime }; }); - + // Process tests in batches to limit concurrent connections for (let i = 0; i < testPromises.length; i += maxConcurrency) { const batch = testPromises.slice(i, i + maxConcurrency); @@ -171,88 +134,52 @@ class RunCommand extends TestCommand { // Sequential execution (fallback mode or when explicitly requested) for (const testFunc of testsToRun) { const funcStartTime = Date.now(); - - // Try cache first if enabled - let tapOutput = null; - let fromCache = false; - - if (cacheEnabled) { - const hash = await this.testCache.calculateHash(testFunc, this.databaseUrl, options); - const cachedResult = await this.testCache.getCachedResult(hash); - - if (cachedResult && cachedResult.tapOutput) { - tapOutput = cachedResult.tapOutput; - fromCache = true; - this.performanceMetrics.cacheHits++; - this.performanceMetrics.testsFromCache++; - this.progress(`${chalk.blue('โœ“')} ${testFunc} (cached, saved ~${cachedResult.originalDuration || 0}ms)`); - } else { - this.performanceMetrics.cacheMisses++; - } - } - - // Execute test if not cached - if (!tapOutput) { - this.progress(`Running ${testFunc}...`); - const testStartTime = Date.now(); - tapOutput = await this._executeTestFunction(client, testFunc); - const testDuration = Date.now() - testStartTime; - - // Cache the result if caching is enabled - if (cacheEnabled) { - try { - const hash = await this.testCache.calculateHash(testFunc, this.databaseUrl, options); - await this.testCache.storeResult(hash, { - tapOutput: tapOutput, - originalDuration: testDuration - }, { - testFunction: testFunc, - duration: testDuration, - databaseUrl: this.databaseUrl, - options: options - }); - } catch (cacheError) { - this.warn(`Failed to cache result for ${testFunc}: ${cacheError.message}`); - } - } - } - + + // Execute test + this.progress(`Running ${testFunc}...`); + const testStartTime = Date.now(); + const tapOutput = await this._executeTestFunction(client, testFunc); + const testDuration = Date.now() - testStartTime; + this.performanceMetrics.testsExecuted++; - allResults.push({ - function: testFunc, - output: tapOutput, - fromCache: fromCache, + allResults.push({ + function: testFunc, + output: tapOutput, + fromCache, duration: Date.now() - funcStartTime }); } } - + // Parse all results and add performance metadata const combinedResults = this._combineResults(allResults); - + // Add cache performance metrics const totalTime = Date.now() - startTime; combinedResults.performance = { totalExecutionTime: totalTime, - cacheEnabled: cacheEnabled, - cacheHits: this.performanceMetrics.cacheHits, + cacheEnabled, cacheMisses: this.performanceMetrics.cacheMisses, testsExecuted: this.performanceMetrics.testsExecuted, testsFromCache: this.performanceMetrics.testsFromCache, - cacheHitRate: this.performanceMetrics.testsExecuted > 0 - ? (this.performanceMetrics.testsFromCache / this.performanceMetrics.testsExecuted * 100).toFixed(1) - : '0.0', - averageTestTime: this.performanceMetrics.testsExecuted > 0 - ? Math.round(totalTime / this.performanceMetrics.testsExecuted) - : 0 + cacheHitRate: + this.performanceMetrics.testsExecuted > 0 + ? ( + (this.performanceMetrics.testsFromCache / this.performanceMetrics.testsExecuted) * + 100 + ).toFixed(1) + : '0.0', + averageTestTime: + this.performanceMetrics.testsExecuted > 0 + ? Math.round(totalTime / this.performanceMetrics.testsExecuted) + : 0 }; - + // Handle output formatting based on options await this._handleOutputFormat(combinedResults, options); - + this.emit('complete', { results: combinedResults }); return combinedResults; - } finally { await client.end(); } @@ -269,13 +196,15 @@ class RunCommand extends TestCommand { */ async _createDatabaseClient() { if (!this.databaseUrl) { - throw new Error(`Database connection string not configured for ${this.isProd ? 'production' : 'local'} environment`); + throw new Error( + `Database connection string not configured for ${this.isProd ? 'production' : 'local'} environment` + ); } - + const client = new Client({ connectionString: this.databaseUrl }); - + await client.connect(); return client; } @@ -294,9 +223,9 @@ class RunCommand extends TestCommand { AND proname LIKE 'run_%_tests' ORDER BY proname `; - + const result = await client.query(query); - return result.rows.map(row => row.proname); + return result.rows.map((row) => row.proname); } /** @@ -305,23 +234,23 @@ class RunCommand extends TestCommand { */ _filterTestFunctions(testFunctions, options) { let filtered = [...testFunctions]; - + // Apply suite filter if (options.suite) { filtered = this._filterBySuite(filtered, options.suite); } - + // Apply pattern filter (legacy support for options.function) const pattern = options.pattern || options.function; if (pattern) { filtered = this._filterByPattern(filtered, pattern); } - + // Apply tag filter if (options.tag) { filtered = this._filterByTag(filtered, options.tag); } - + return filtered; } @@ -330,7 +259,7 @@ class RunCommand extends TestCommand { * @private */ _filterBySuite(testFunctions, suite) { - return testFunctions.filter(func => { + return testFunctions.filter((func) => { // Handle suite names like "admin" -> "run_admin_*" (e.g., "run_admin_delete_pet_tests") // Also handle direct matches like "admin" -> "run_admin_tests" const regex = new RegExp(`^run_${suite}(_.*)?_tests$`, 'i'); @@ -346,7 +275,7 @@ class RunCommand extends TestCommand { // Convert glob patterns to regex patterns const regexPattern = this._globToRegex(pattern); const regex = new RegExp(regexPattern, 'i'); - return testFunctions.filter(func => regex.test(func)); + return testFunctions.filter((func) => regex.test(func)); } /** @@ -355,11 +284,11 @@ class RunCommand extends TestCommand { */ _globToRegex(pattern) { // Escape special regex characters except * and ? - let regex = pattern - .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars - .replace(/\*/g, '.*') // Convert * to .* - .replace(/\?/g, '.'); // Convert ? to . - + const regex = pattern + .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars + .replace(/\*/g, '.*') // Convert * to .* + .replace(/\?/g, '.'); // Convert ? to . + // Anchor the pattern to match the whole string return `^${regex}$`; } @@ -381,20 +310,20 @@ class RunCommand extends TestCommand { */ _getFilterDescription(options) { const filters = []; - + if (options.suite) { filters.push(`suite="${options.suite}"`); } - + const pattern = options.pattern || options.function; if (pattern) { filters.push(`pattern="${pattern}"`); } - + if (options.tag) { filters.push(`tag="${options.tag}"`); } - + return filters.length > 0 ? filters.join(', ') : 'none'; } @@ -404,11 +333,11 @@ class RunCommand extends TestCommand { */ async _executeTestFunction(client, functionName) { const query = `SELECT * FROM test.${functionName}()`; - + try { const result = await client.query(query); // Join all result rows into TAP output - return result.rows.map(row => Object.values(row)[0]).join('\n'); + return result.rows.map((row) => Object.values(row)[0]).join('\n'); } catch (error) { // Return TAP format error return `not ok 1 ${functionName} failed: ${error.message}`; @@ -429,21 +358,21 @@ class RunCommand extends TestCommand { for (const { function: funcName, output } of allResults) { const funcResults = this.parser.parse(output); - + totalPassed += funcResults.passed; totalFailed += funcResults.failed; totalSkipped += funcResults.skipped; - + // Prefix test descriptions with function name - const prefixedTests = funcResults.tests.map(test => ({ + const prefixedTests = funcResults.tests.map((test) => ({ ...test, description: `${funcName}: ${test.description}`, function: funcName })); - + allTests = allTests.concat(prefixedTests); allDiagnostics = allDiagnostics.concat(funcResults.diagnostics); - + testFunctions.push({ name: funcName, passed: funcResults.passed, @@ -474,16 +403,16 @@ class RunCommand extends TestCommand { const outputFile = options.output; switch (format.toLowerCase()) { - case 'junit': - await this._outputJUnit(results, outputFile); - break; - case 'json': - await this._outputJSON(results, outputFile); - break; - case 'console': - default: - this._displayResults(results); - break; + case 'junit': + await this._outputJUnit(results, outputFile); + break; + case 'json': + await this._outputJSON(results, outputFile); + break; + case 'console': + default: + this._displayResults(results); + break; } } @@ -494,7 +423,7 @@ class RunCommand extends TestCommand { async _outputJUnit(results, outputFile) { const formatter = new JUnitFormatter(); const xmlOutput = formatter.format(results); - + if (outputFile) { await this._writeOutputFile(xmlOutput, outputFile, formatter.getFileExtension()); this.success(`JUnit XML results written to: ${outputFile}`); @@ -510,7 +439,7 @@ class RunCommand extends TestCommand { async _outputJSON(results, outputFile) { const formatter = new JSONFormatter(); const jsonOutput = formatter.format(results); - + if (outputFile) { await this._writeOutputFile(jsonOutput, outputFile, formatter.getFileExtension()); this.success(`JSON results written to: ${outputFile}`); @@ -525,16 +454,16 @@ class RunCommand extends TestCommand { */ async _writeOutputFile(content, filePath, defaultExtension) { let fullPath = filePath; - + // Add default extension if not present - if (!path.extname(filePath)) { + if (!extname(filePath)) { fullPath = filePath + defaultExtension; } - + // Ensure directory exists - const dir = path.dirname(fullPath); + const dir = dirname(fullPath); await fs.mkdir(dir, { recursive: true }); - + // Write file await fs.writeFile(fullPath, content, 'utf8'); } @@ -545,13 +474,13 @@ class RunCommand extends TestCommand { */ _displayResults(results) { const { total, passed, failed, skipped, tests, diagnostics, testFunctions } = results; - + console.log(''); // Empty line for spacing // Summary by function if (testFunctions.length > 1) { console.log(chalk.bold('Test Functions:')); - testFunctions.forEach(func => { + testFunctions.forEach((func) => { const symbol = func.success ? chalk.green('โœ“') : chalk.red('โœ—'); const summary = `${func.passed}/${func.total} passed`; const skippedText = func.skipped > 0 ? `, ${func.skipped} skipped` : ''; @@ -576,8 +505,8 @@ class RunCommand extends TestCommand { console.log(''); // Empty line console.log(chalk.red.bold('Failed Tests:')); tests - .filter(test => test.status === 'fail') - .forEach(test => { + .filter((test) => test.status === 'fail') + .forEach((test) => { console.log(chalk.red(` โœ— ${test.description}`)); }); } @@ -586,7 +515,7 @@ class RunCommand extends TestCommand { if (diagnostics.length > 0) { console.log(''); // Empty line console.log(chalk.gray.bold('Diagnostics:')); - diagnostics.forEach(diagnostic => { + diagnostics.forEach((diagnostic) => { console.log(chalk.gray(` ${diagnostic}`)); }); } @@ -595,26 +524,32 @@ class RunCommand extends TestCommand { if (results.performance) { console.log(''); // Empty line console.log(chalk.cyan.bold('Performance:')); - + const perf = results.performance; console.log(chalk.cyan(` Execution time: ${perf.totalExecutionTime}ms`)); console.log(chalk.cyan(` Average per test: ${perf.averageTestTime}ms`)); - + if (perf.cacheEnabled) { if (perf.testsFromCache > 0) { - console.log(chalk.green(` Cache performance: ${perf.cacheHitRate}% hit rate (${perf.testsFromCache}/${perf.testsExecuted} from cache)`)); - + console.log( + chalk.green( + ` Cache performance: ${perf.cacheHitRate}% hit rate (${perf.testsFromCache}/${perf.testsExecuted} from cache)` + ) + ); + // Calculate estimated time saved const avgExecutionTime = perf.averageTestTime; const estimatedTimeSaved = perf.testsFromCache * avgExecutionTime * 0.8; // Assume 80% time savings if (estimatedTimeSaved > 0) { - console.log(chalk.green(` Estimated time saved: ~${Math.round(estimatedTimeSaved)}ms`)); + console.log( + chalk.green(` Estimated time saved: ~${Math.round(estimatedTimeSaved)}ms`) + ); } } else { - console.log(chalk.yellow(` Cache performance: 0% hit rate (building cache...)`)); + console.log(chalk.yellow(' Cache performance: 0% hit rate (building cache...)')); } } else { - console.log(chalk.gray(` Cache: disabled`)); + console.log(chalk.gray(' Cache: disabled')); } } } @@ -636,7 +571,7 @@ class RunCommand extends TestCommand { if (this.config) { return this.config.getTestConfig(); } - + try { const config = await Config.load(); return config.getTestConfig(); @@ -653,14 +588,19 @@ class RunCommand extends TestCommand { */ _applyTestConfig(options, testConfig) { const mergedOptions = { ...options }; - + // Apply default output format if not specified - if (!mergedOptions.format && testConfig.output_formats && testConfig.output_formats.length > 0) { + if ( + !mergedOptions.format && + testConfig.output_formats && + testConfig.output_formats.length > 0 + ) { mergedOptions.format = testConfig.output_formats[0]; } - + return mergedOptions; } } -module.exports = RunCommand; \ No newline at end of file +export { RunCommand }; +export default RunCommand; diff --git a/src/commands/test/ValidateCommand.js b/starfleet/data-cli/src/commands/test/ValidateCommand.js similarity index 81% rename from src/commands/test/ValidateCommand.js rename to starfleet/data-cli/src/commands/test/ValidateCommand.js index 771aa74..bb31626 100644 --- a/src/commands/test/ValidateCommand.js +++ b/starfleet/data-cli/src/commands/test/ValidateCommand.js @@ -2,10 +2,10 @@ * Test Validate Command - SQL syntax validation for pgTAP tests */ -const TestCommand = require('../../lib/TestCommand'); -const fs = require('fs').promises; -const path = require('path'); -const crypto = require('crypto'); +import TestCommand from '../../lib/TestCommand.js'; +import { promises as fs } from 'fs'; +import path from 'path'; +import crypto from 'crypto'; /** * Validate SQL syntax and pgTAP function usage in test files @@ -21,38 +21,76 @@ class ValidateCommand extends TestCommand { pathResolver = null ) { super(databaseUrl, serviceRoleKey, testsDir, outputDir, logger, isProd, pathResolver); - + // Validation doesn't require database connection this.requiresProductionConfirmation = false; - + // Initialize validation cache this.validationCache = new Map(); this.cacheDir = path.join(process.cwd(), '.data-cache', 'validation'); this.cacheFile = path.join(this.cacheDir, 'validation-cache.json'); - + // Valid pgTAP function names this.pgTapFunctions = new Set([ // Basic test functions - 'ok', 'nok', 'pass', 'fail', + 'ok', + 'nok', + 'pass', + 'fail', // Comparison functions - 'is', 'isnt', 'like', 'unlike', 'matches', 'imatches', + 'is', + 'isnt', + 'like', + 'unlike', + 'matches', + 'imatches', // NULL testing - 'is_empty', 'isnt_empty', 'is_null', 'isnt_null', 'is_not_null', + 'is_empty', + 'isnt_empty', + 'is_null', + 'isnt_null', + 'is_not_null', // Numeric comparison 'cmp_ok', // Schema testing - 'has_schema', 'hasnt_schema', 'schema_owner_is', - 'has_table', 'hasnt_table', 'has_view', 'hasnt_view', - 'has_function', 'hasnt_function', 'function_returns', - 'has_column', 'hasnt_column', 'col_type_is', 'col_is_null', 'col_not_null', - 'col_has_default', 'col_default_is', + 'has_schema', + 'hasnt_schema', + 'schema_owner_is', + 'has_table', + 'hasnt_table', + 'has_view', + 'hasnt_view', + 'has_function', + 'hasnt_function', + 'function_returns', + 'has_column', + 'hasnt_column', + 'col_type_is', + 'col_is_null', + 'col_not_null', + 'col_has_default', + 'col_default_is', // Row testing - 'results_eq', 'results_ne', 'set_eq', 'set_ne', 'bag_eq', 'bag_ne', - 'row_eq', 'throws_ok', 'throws_like', 'throws_matching', 'lives_ok', + 'results_eq', + 'results_ne', + 'set_eq', + 'set_ne', + 'bag_eq', + 'bag_ne', + 'row_eq', + 'throws_ok', + 'throws_like', + 'throws_matching', + 'lives_ok', // Test control - 'plan', 'finish', 'diag', 'skip', 'todo', 'todo_skip' + 'plan', + 'finish', + 'diag', + 'skip', + 'todo', + 'todo_skip' ]); - + this.validationResults = { filesProcessed: 0, syntaxErrors: [], @@ -77,7 +115,7 @@ class ValidateCommand extends TestCommand { this.validationCache = new Map(); } } - + /** * Save validation cache to disk */ @@ -90,7 +128,7 @@ class ValidateCommand extends TestCommand { this.warn(`Failed to save validation cache: ${error.message}`); } } - + /** * Calculate hash for a file's content */ @@ -98,14 +136,14 @@ class ValidateCommand extends TestCommand { const content = await fs.readFile(filePath, 'utf8'); return crypto.createHash('sha256').update(content).digest('hex'); } - + /** * Check if file validation is cached and still valid */ async isCacheValid(filePath) { const fileHash = await this.calculateFileHash(filePath); const cacheKey = `${filePath}:${fileHash}`; - + if (this.validationCache.has(cacheKey)) { const cached = this.validationCache.get(cacheKey); // Cache is valid for 24 hours @@ -114,7 +152,7 @@ class ValidateCommand extends TestCommand { } return false; } - + /** * Get cached validation result */ @@ -122,7 +160,7 @@ class ValidateCommand extends TestCommand { const cacheKey = `${filePath}:${fileHash}`; return this.validationCache.get(cacheKey); } - + /** * Store validation result in cache */ @@ -139,31 +177,31 @@ class ValidateCommand extends TestCommand { */ async performExecute(options = {}) { this.emit('start', { isProd: this.isProd, options }); - + try { // Load cache if caching is enabled const cacheEnabled = options.cache !== false; if (cacheEnabled) { await this.loadCache(); } - + this.progress('Scanning test files for validation...'); - + const testFiles = await this.listTestFiles('*.sql'); - + if (testFiles.length === 0) { this.warn('No test files found in tests directory'); return this.validationResults; } - + this.progress(`Found ${testFiles.length} test files to validate`); - + let cachedCount = 0; let validatedCount = 0; - + // Validate each test file for (const filePath of testFiles) { - if (cacheEnabled && await this.isCacheValid(filePath)) { + if (cacheEnabled && (await this.isCacheValid(filePath))) { const fileHash = await this.calculateFileHash(filePath); const cached = this.getCachedResult(filePath, fileHash); if (cached && !cached.hasErrors) { @@ -172,10 +210,10 @@ class ValidateCommand extends TestCommand { continue; } } - + await this.validateFile(filePath); validatedCount++; - + // Cache the result if no errors if (cacheEnabled && !this.validationResults.hasErrors) { const fileHash = await this.calculateFileHash(filePath); @@ -187,29 +225,30 @@ class ValidateCommand extends TestCommand { }); } } - + // Save cache if caching is enabled if (cacheEnabled) { await this.saveCache(); } - + // Report results this.reportResults(); - + if (cachedCount > 0) { - this.success(`${cachedCount} files validated from cache, ${validatedCount} files validated`); + this.success( + `${cachedCount} files validated from cache, ${validatedCount} files validated` + ); } - + this.emit('complete', { validation: this.validationResults }); return this.validationResults; - } catch (error) { this.error('Failed to validate tests', error); this.emit('failed', { error }); throw error; } } - + /** * Validate a single SQL test file * @param {string} filePath - Path to the test file @@ -218,23 +257,22 @@ class ValidateCommand extends TestCommand { try { const content = await fs.readFile(filePath, 'utf8'); const fileName = path.basename(filePath); - + this.validationResults.filesProcessed++; - + // Basic SQL syntax validation this.validateSqlSyntax(fileName, content); - + // pgTAP function validation this.validatePgTapUsage(fileName, content); - + // Test function structure validation this.validateTestStructure(fileName, content); - } catch (error) { this.addSyntaxError(path.basename(filePath), 0, `File read error: ${error.message}`); } } - + /** * Validate basic SQL syntax * @param {string} fileName - Name of the file @@ -242,19 +280,19 @@ class ValidateCommand extends TestCommand { */ validateSqlSyntax(fileName, content) { const lines = content.split('\n'); - + for (let i = 0; i < lines.length; i++) { const line = lines[i].trim(); const lineNum = i + 1; - + // Skip comments and empty lines if (!line || line.startsWith('--')) continue; - + // Check for basic syntax errors this.checkBasicSyntax(fileName, lineNum, line); } } - + /** * Check basic SQL syntax patterns * @param {string} fileName - Name of the file @@ -265,31 +303,31 @@ class ValidateCommand extends TestCommand { // Check for unmatched parentheses in single line const openParens = (line.match(/\(/g) || []).length; const closeParens = (line.match(/\)/g) || []).length; - + // Only flag obvious single-line mismatches if (line.includes('(') && !line.includes('$$') && openParens > closeParens + 1) { this.addSyntaxError(fileName, lineNum, 'Possible unmatched opening parenthesis'); } - + // Check for common typos if (line.match(/\bSELET\b/i)) { this.addSyntaxError(fileName, lineNum, 'Typo: "SELET" should be "SELECT"'); } - + if (line.match(/\bFROM\s+FROM\b/i)) { this.addSyntaxError(fileName, lineNum, 'Duplicate FROM keyword'); } - + if (line.match(/\bWHERE\s+WHERE\b/i)) { this.addSyntaxError(fileName, lineNum, 'Duplicate WHERE keyword'); } - + // Check for semicolon issues if (line.match(/;;+/)) { this.addSyntaxError(fileName, lineNum, 'Multiple consecutive semicolons'); } } - + /** * Validate pgTAP function usage * @param {string} fileName - Name of the file @@ -297,14 +335,14 @@ class ValidateCommand extends TestCommand { */ validatePgTapUsage(fileName, content) { const lines = content.split('\n'); - + for (let i = 0; i < lines.length; i++) { const line = lines[i].trim(); const lineNum = i + 1; - + // Skip comments and empty lines if (!line || line.startsWith('--')) continue; - + // Find pgTAP function calls const tapMatch = line.match(/\btap\.(\w+)\s*\(/i); if (tapMatch) { @@ -313,14 +351,14 @@ class ValidateCommand extends TestCommand { this.addPgTapIssue(fileName, lineNum, `Unknown pgTAP function: tap.${functionName}`); } } - + // Check for RETURN NEXT patterns if (line.match(/RETURN\s+NEXT/i) && !line.match(/tap\./i)) { this.addPgTapIssue(fileName, lineNum, 'RETURN NEXT should typically use tap.* functions'); } } } - + /** * Validate test function structure * @param {string} fileName - Name of the file @@ -328,53 +366,75 @@ class ValidateCommand extends TestCommand { */ validateTestStructure(fileName, content) { // Check for test function declarations - const testFunctionRegex = /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+test\.(\w+)\s*\(([^)]*)\)\s*RETURNS\s+(\w+(?:\s+\w+)*)/gi; + const testFunctionRegex = + /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+test\.(\w+)\s*\(([^)]*)\)\s*RETURNS\s+(\w+(?:\s+\w+)*)/gi; let match; - + let hasTestFunctions = false; - + while ((match = testFunctionRegex.exec(content)) !== null) { const functionName = match[1]; const returnType = match[3].toUpperCase(); - + // Skip helper functions (they don't need to be pgTAP test functions) - const isHelperFunction = functionName.startsWith('create_') || - functionName.startsWith('cleanup_') || - functionName.startsWith('set_') || - functionName.includes('_helper') || - functionName.includes('_util'); - + const isHelperFunction = + functionName.startsWith('create_') || + functionName.startsWith('cleanup_') || + functionName.startsWith('set_') || + functionName.includes('_helper') || + functionName.includes('_util'); + if (!isHelperFunction) { hasTestFunctions = true; - + // Check return type for actual test functions if (!returnType.includes('SETOF TEXT')) { - this.addStructureWarning(fileName, 0, `Function test.${functionName} should return SETOF TEXT for pgTAP compatibility`); + this.addStructureWarning( + fileName, + 0, + `Function test.${functionName} should return SETOF TEXT for pgTAP compatibility` + ); } - + // Check function name pattern for actual test functions if (!functionName.includes('test') && !functionName.startsWith('run_')) { - this.addStructureWarning(fileName, 0, `Function test.${functionName} should include 'test' or start with 'run_' for clarity`); + this.addStructureWarning( + fileName, + 0, + `Function test.${functionName} should include 'test' or start with 'run_' for clarity` + ); } } } - + // Check if file has any test functions if (!hasTestFunctions && fileName.endsWith('.sql') && !fileName.startsWith('00_')) { - this.addStructureWarning(fileName, 0, 'File appears to be a test file but contains no test functions'); + this.addStructureWarning( + fileName, + 0, + 'File appears to be a test file but contains no test functions' + ); } - + // Check for plan() call if (hasTestFunctions && !content.match(/tap\.plan\s*\(/i)) { - this.addStructureWarning(fileName, 0, 'Test functions should include tap.plan() to specify expected test count'); + this.addStructureWarning( + fileName, + 0, + 'Test functions should include tap.plan() to specify expected test count' + ); } - + // Check for finish() call if (hasTestFunctions && !content.match(/tap\.finish\s*\(\s*\)/i)) { - this.addStructureWarning(fileName, 0, 'Test functions should include tap.finish() at the end'); + this.addStructureWarning( + fileName, + 0, + 'Test functions should include tap.finish() at the end' + ); } } - + /** * Add a syntax error to results */ @@ -382,7 +442,7 @@ class ValidateCommand extends TestCommand { this.validationResults.syntaxErrors.push({ fileName, lineNum, message }); this.validationResults.hasErrors = true; } - + /** * Add a pgTAP issue to results */ @@ -390,46 +450,47 @@ class ValidateCommand extends TestCommand { this.validationResults.pgTapIssues.push({ fileName, lineNum, message }); this.validationResults.hasErrors = true; } - + /** * Add a structure warning to results */ addStructureWarning(fileName, lineNum, message) { this.validationResults.structureWarnings.push({ fileName, lineNum, message }); } - + /** * Report validation results */ reportResults() { - const { filesProcessed, syntaxErrors, pgTapIssues, structureWarnings, hasErrors } = this.validationResults; - + const { filesProcessed, syntaxErrors, pgTapIssues, structureWarnings, hasErrors } = + this.validationResults; + this.progress(`Processed ${filesProcessed} test files`); - + // Report syntax errors if (syntaxErrors.length > 0) { this.error(`Found ${syntaxErrors.length} syntax errors:`); - syntaxErrors.forEach(error => { + syntaxErrors.forEach((error) => { this.error(` ${error.fileName}:${error.lineNum} - ${error.message}`); }); } - + // Report pgTAP issues if (pgTapIssues.length > 0) { this.error(`Found ${pgTapIssues.length} pgTAP issues:`); - pgTapIssues.forEach(issue => { + pgTapIssues.forEach((issue) => { this.error(` ${issue.fileName}:${issue.lineNum} - ${issue.message}`); }); } - + // Report structure warnings if (structureWarnings.length > 0) { this.warn(`Found ${structureWarnings.length} structure warnings:`); - structureWarnings.forEach(warning => { + structureWarnings.forEach((warning) => { this.warn(` ${warning.fileName}:${warning.lineNum} - ${warning.message}`); }); } - + // Final status if (hasErrors) { this.error('Validation failed - please fix the errors above'); @@ -444,4 +505,4 @@ class ValidateCommand extends TestCommand { } } -module.exports = ValidateCommand; \ No newline at end of file +export default ValidateCommand; diff --git a/src/commands/test/WatchCommand.js b/starfleet/data-cli/src/commands/test/WatchCommand.js similarity index 90% rename from src/commands/test/WatchCommand.js rename to starfleet/data-cli/src/commands/test/WatchCommand.js index 8b880b4..180700d 100644 --- a/src/commands/test/WatchCommand.js +++ b/starfleet/data-cli/src/commands/test/WatchCommand.js @@ -1,20 +1,20 @@ /** * Test Watch Command - P1.T006 - * + * * Watches test/ directory for changes and automatically: * 1. Compiles tests using TestCompileCommand - * 2. Runs tests using TestRunCommand + * 2. Runs tests using TestRunCommand * 3. Debounces rapid changes * 4. Clears console between runs */ -const chokidar = require('chokidar'); -const path = require('path'); -const chalk = require('chalk').default || require('chalk'); -const TestCommand = require('../../lib/TestCommand'); -const CompileCommand = require('./CompileCommand'); -const RunCommand = require('./RunCommand'); -const Config = require('../../lib/config'); +import chokidar from 'chokidar'; +import path from 'path'; +import chalk from 'chalk'; +import TestCommand from '../../lib/TestCommand.js'; +import CompileCommand from './CompileCommand.js'; +import RunCommand from './RunCommand.js'; +import Config from '../../lib/config.js'; /** * Watch for test file changes and auto-run tests @@ -22,7 +22,7 @@ const Config = require('../../lib/config'); class WatchCommand extends TestCommand { constructor( databaseUrl, - serviceRoleKey = null, + serviceRoleKey = null, testsDir, outputDir, logger = null, @@ -30,14 +30,14 @@ class WatchCommand extends TestCommand { pathResolver = null ) { super(databaseUrl, serviceRoleKey, testsDir, outputDir, logger, isProd, pathResolver); - + // Watch configuration this.debounceMs = 1000; // Default debounce delay this.isRunning = false; this.pendingTimeout = null; this.watcher = null; this.initialScanComplete = false; - + // Commands for auto-compilation and running this.compileCommand = null; this.runCommand = null; @@ -47,45 +47,45 @@ class WatchCommand extends TestCommand { * Execute test watch mode */ async performExecute(options = {}) { - this.emit('watch:start', { - isProd: this.isProd, + this.emit('watch:start', { + isProd: this.isProd, testsDir: this.testsDir, outputDir: this.outputDir, - options + options }); - + try { // Load test configuration const testConfig = await this._getTestConfig(); - + // Configure debounce delay from options or config this.debounceMs = options.debounce || testConfig.debounce_delay || 1000; - this.autoCompile = options.autoCompile !== undefined ? options.autoCompile : testConfig.auto_compile; - + this.autoCompile = + options.autoCompile !== undefined ? options.autoCompile : testConfig.auto_compile; + this.progress('Starting test watch mode...'); - + // Initialize compilation and run commands await this._initializeCommands(options); - + // Ensure test directory exists const watchDir = await this.getTestsDir(); this.success(`Watching for changes in: ${watchDir}`); - + // Setup file watcher await this._setupWatcher(watchDir, options); - + // Run initial test cycle await this._runTestCycle('Initial run'); - + this.progress(chalk.cyan('\n๐Ÿ” Watching for test file changes...')); this.progress(chalk.gray('Press Ctrl+C to stop watching\n')); - + // Keep the process alive and listen for signals await this._waitForInterrupt(); - + this.emit('watch:complete', { message: 'Test watch stopped' }); return { success: true, message: 'Test watch stopped' }; - } catch (error) { this.error('Failed to start test watcher', error); this.emit('watch:failed', { error }); @@ -101,15 +101,15 @@ class WatchCommand extends TestCommand { */ async _initializeCommands(options) { this.progress('Initializing test commands...'); - + // Create compile command instance this.compileCommand = new CompileCommand( this.testsDir, - this.outputDir, + this.outputDir, this.logger, this.isProd ); - + // Create run command instance this.runCommand = new RunCommand( this.databaseUrl, @@ -119,7 +119,7 @@ class WatchCommand extends TestCommand { this.logger, this.isProd ); - + // Forward events from child commands this._forwardCommandEvents(); } @@ -130,15 +130,15 @@ class WatchCommand extends TestCommand { */ async _setupWatcher(watchDir, options) { const watchPattern = path.join(watchDir, '**/*.sql'); - + this.watcher = chokidar.watch(watchPattern, { - ignored: /[\/\\]\./, // ignore dotfiles + ignored: /[\/\\]\./, // ignore dotfiles persistent: true, ignoreInitial: false, followSymlinks: false, - depth: 3 // reasonable depth limit + depth: 3 // reasonable depth limit }); - + // Handle file events this.watcher .on('ready', () => { @@ -167,21 +167,21 @@ class WatchCommand extends TestCommand { */ _handleFileChange(eventType, filePath) { const relativePath = path.relative(this.testsDir, filePath); - + this.emit('watch:file_change', { eventType, file: relativePath, fullPath: filePath, timestamp: new Date().toISOString() }); - + this.progress(chalk.blue(`๐Ÿ“„ ${eventType}: ${relativePath}`)); - + // Clear existing timeout if (this.pendingTimeout) { clearTimeout(this.pendingTimeout); } - + // Debounce the test run this.pendingTimeout = setTimeout(async () => { await this._runTestCycle(`File ${eventType}: ${relativePath}`); @@ -198,47 +198,47 @@ class WatchCommand extends TestCommand { this.logger.debug('Test cycle already running, skipping'); return; } - + this.isRunning = true; - + try { // Clear console for clean output this._clearConsole(); - + this.emit('watch:cycle_start', { trigger, timestamp: new Date().toISOString() }); - + const cycleStartTime = Date.now(); this.progress(chalk.yellow(`๐Ÿ”„ ${trigger} - Running test cycle...`)); - + // Step 1: Compile tests (if auto_compile is enabled) let compileResult = null; if (this.autoCompile) { this.progress('๐Ÿ“ฆ Compiling tests...'); compileResult = await this.compileCommand.performExecute(); - + if (!compileResult.success) { throw new Error('Test compilation failed'); } - + this.success(`โœ“ Compilation complete: ${compileResult.stats.filesProcessed} files`); } else { this.progress('โญ๏ธ Skipping compilation (auto_compile disabled)'); compileResult = { success: true, stats: { filesProcessed: 0 } }; } - - // Step 2: Run tests + + // Step 2: Run tests this.progress('๐Ÿงช Running tests...'); const runResult = await this.runCommand.performExecute(); - + const cycleEndTime = Date.now(); const cycleDuration = cycleEndTime - cycleStartTime; - + // Display summary this._displayCycleSummary(runResult, cycleDuration); - + this.emit('watch:cycle_complete', { trigger, compileResult, @@ -246,10 +246,9 @@ class WatchCommand extends TestCommand { duration: cycleDuration, timestamp: new Date().toISOString() }); - } catch (error) { this.error('Test cycle failed', error); - + this.emit('watch:cycle_failed', { trigger, error, @@ -257,7 +256,7 @@ class WatchCommand extends TestCommand { }); } finally { this.isRunning = false; - + // Separator for next cycle console.log(chalk.gray('โ”€'.repeat(60))); console.log(chalk.cyan('๐Ÿ” Watching for changes...')); @@ -271,7 +270,7 @@ class WatchCommand extends TestCommand { _clearConsole() { // Clear console but preserve some context process.stdout.write('\x1Bc'); // Clear screen - + // Re-display header console.log(chalk.bold.cyan('โ›ฐ๏ธ data Test Watcher')); console.log(chalk.gray(`Watching: ${this.testsDir}`)); @@ -285,10 +284,10 @@ class WatchCommand extends TestCommand { */ _displayCycleSummary(runResult, duration) { const { total, passed, failed, skipped } = runResult; - + console.log(''); console.log(chalk.bold('๐Ÿ“Š Test Results Summary:')); - + if (failed > 0) { console.log(chalk.red(` โœ— ${failed}/${total} tests failed`)); } else if (skipped > 0) { @@ -298,7 +297,7 @@ class WatchCommand extends TestCommand { } else { console.log(chalk.gray(' No tests executed')); } - + console.log(chalk.gray(` โฑ Completed in ${duration}ms`)); console.log(''); } @@ -312,25 +311,25 @@ class WatchCommand extends TestCommand { this.compileCommand.on('compilation:start', (data) => { this.emit('watch:compilation_start', data); }); - + this.compileCommand.on('compilation:complete', (data) => { this.emit('watch:compilation_complete', data); }); - + this.compileCommand.on('compilation:failed', (data) => { this.emit('watch:compilation_failed', data); }); } - + if (this.runCommand) { this.runCommand.on('start', (data) => { this.emit('watch:run_start', data); }); - + this.runCommand.on('complete', (data) => { this.emit('watch:run_complete', data); }); - + this.runCommand.on('failed', (data) => { this.emit('watch:run_failed', data); }); @@ -347,7 +346,7 @@ class WatchCommand extends TestCommand { console.log(chalk.yellow('\nโน Stopping test watcher...')); resolve(); }; - + process.on('SIGINT', handleSignal); process.on('SIGTERM', handleSignal); }); @@ -362,12 +361,12 @@ class WatchCommand extends TestCommand { clearTimeout(this.pendingTimeout); this.pendingTimeout = null; } - + if (this.watcher) { await this.watcher.close(); this.watcher = null; } - + this.logger.debug('Test watcher cleanup complete'); } @@ -413,4 +412,4 @@ class WatchCommand extends TestCommand { } } -module.exports = WatchCommand; \ No newline at end of file +export default WatchCommand; diff --git a/src/commands/test/ci/CICoverageCommand.js b/starfleet/data-cli/src/commands/test/ci/CICoverageCommand.js similarity index 96% rename from src/commands/test/ci/CICoverageCommand.js rename to starfleet/data-cli/src/commands/test/ci/CICoverageCommand.js index cce7c7d..6c23aca 100644 --- a/src/commands/test/ci/CICoverageCommand.js +++ b/starfleet/data-cli/src/commands/test/ci/CICoverageCommand.js @@ -1,11 +1,11 @@ /** * CI Coverage Command - CI-optimized test coverage analysis - * + * * Wraps CoverageCommand with machine-friendly output, JSON reports, * and proper exit codes for CI/CD environments. */ -const CoverageCommand = require('../CoverageCommand'); +import CoverageCommand from '../CoverageCommand.js'; /** * CI-friendly test coverage analysis with structured output @@ -13,7 +13,7 @@ const CoverageCommand = require('../CoverageCommand'); class CICoverageCommand extends CoverageCommand { constructor(config = null, logger = null, isProd = false) { super(config, logger, isProd); - + // Force CI mode behavior this.ciMode = true; this.suppressProgress = true; @@ -25,7 +25,7 @@ class CICoverageCommand extends CoverageCommand { async performExecute(options = {}) { const startTime = Date.now(); const isCI = process.env.CI !== 'false'; - + // Parse enforcement options with CI-friendly defaults const ciOptions = { enforce: options.enforce || false, @@ -35,23 +35,23 @@ class CICoverageCommand extends CoverageCommand { format: options.format || 'json', output: options.output || (isCI ? 'coverage' : null) }; - + try { // Emit structured start event - this.emitCIEvent('coverage_analysis_started', { + this.emitCIEvent('coverage_analysis_started', { options: ciOptions, timestamp: new Date().toISOString() }); - + // Execute coverage analysis using parent class logic const results = await super.performExecute(ciOptions); - + // Calculate execution time const duration = Date.now() - startTime; - + // Generate CI-friendly report const ciReport = this.generateCIReport(results, duration, ciOptions); - + // Output report (structured for CI consumption) if (isCI) { // Machine-readable JSON output for CI @@ -60,29 +60,29 @@ class CICoverageCommand extends CoverageCommand { // Human-readable for local development this.displayCIReport(ciReport); } - + // Write CI artifacts await this.writeCIArtifacts(results, ciReport, ciOptions); - + // Handle enforcement results const success = this.handleEnforcement(ciReport, ciOptions); - + // Emit structured completion event this.emitCIEvent('coverage_analysis_completed', { success, duration, summary: ciReport.summary }); - + // Set proper exit code const exitCode = success ? 0 : 1; process.exitCode = exitCode; - + return ciReport; - + } catch (error) { const duration = Date.now() - startTime; - + // Structured error output const errorReport = { status: 'error', @@ -93,20 +93,20 @@ class CICoverageCommand extends CoverageCommand { duration, timestamp: new Date().toISOString() }; - + if (isCI) { console.error(JSON.stringify(errorReport, null, 2)); } else { console.error(`COVERAGE_ANALYSIS_ERROR: ${error.message}`); } - + this.emitCIEvent('coverage_analysis_failed', { error: error.message, duration }); - + process.exitCode = 1; throw error; } } - + /** * Generate CI-friendly coverage report * @param {Object} results - Coverage results from parent class @@ -117,13 +117,13 @@ class CICoverageCommand extends CoverageCommand { generateCIReport(results, duration, options) { // Generate stats using parent class analyzer const stats = this.analyzer.generateCoverageStats(results.rpc, results.policies); - + // Calculate enforcement status if enabled let enforcement = null; if (options.enforce) { enforcement = this.calculateEnforcement(stats, options); } - + return { status: enforcement ? (enforcement.passed ? 'passed' : 'failed') : 'analyzed', summary: { @@ -136,7 +136,7 @@ class CICoverageCommand extends CoverageCommand { uncoveredPolicies: this.extractUncoveredPolicies(results.policies), coverageBreakdown: this.generateBreakdown(results) }, - enforcement: enforcement, + enforcement, execution: { duration, timestamp: new Date().toISOString(), @@ -148,7 +148,7 @@ class CICoverageCommand extends CoverageCommand { } }; } - + /** * Calculate enforcement results * @param {Object} stats - Coverage statistics @@ -158,7 +158,7 @@ class CICoverageCommand extends CoverageCommand { calculateEnforcement(stats, options) { const failures = []; let passed = true; - + // Check overall coverage if (stats.overall && stats.overall.percentage < options.minCoverage) { failures.push({ @@ -169,7 +169,7 @@ class CICoverageCommand extends CoverageCommand { }); passed = false; } - + // Check RPC coverage if (stats.rpc && stats.rpc.percentage < options.minRpcCoverage) { failures.push({ @@ -180,7 +180,7 @@ class CICoverageCommand extends CoverageCommand { }); passed = false; } - + // Check RLS policy coverage if (stats.policies && stats.policies.percentage < options.minRlsCoverage) { failures.push({ @@ -191,7 +191,7 @@ class CICoverageCommand extends CoverageCommand { }); passed = false; } - + return { passed, failures, @@ -202,7 +202,7 @@ class CICoverageCommand extends CoverageCommand { } }; } - + /** * Extract uncovered RPC functions * @param {Object} rpcResults - RPC analysis results @@ -210,7 +210,7 @@ class CICoverageCommand extends CoverageCommand { */ extractUncoveredRpc(rpcResults) { if (!rpcResults || !Array.isArray(rpcResults)) return []; - + return rpcResults .filter(rpc => !rpc.has_tests || rpc.has_tests === false) .map(rpc => ({ @@ -219,7 +219,7 @@ class CICoverageCommand extends CoverageCommand { signature: rpc.function_signature || `${rpc.function_name}(...)` })); } - + /** * Extract uncovered RLS policies * @param {Object} policyResults - Policy analysis results @@ -227,7 +227,7 @@ class CICoverageCommand extends CoverageCommand { */ extractUncoveredPolicies(policyResults) { if (!policyResults || !Array.isArray(policyResults)) return []; - + return policyResults .filter(policy => !policy.has_tests || policy.has_tests === false) .map(policy => ({ @@ -237,7 +237,7 @@ class CICoverageCommand extends CoverageCommand { command: policy.command_type || 'unknown' })); } - + /** * Generate detailed coverage breakdown * @param {Object} results - Coverage results @@ -248,7 +248,7 @@ class CICoverageCommand extends CoverageCommand { schemas: {}, tables: {} }; - + // Process RPC functions by schema if (results.rpc && Array.isArray(results.rpc)) { results.rpc.forEach(rpc => { @@ -266,7 +266,7 @@ class CICoverageCommand extends CoverageCommand { }); }); } - + // Process RLS policies by table if (results.policies && Array.isArray(results.policies)) { results.policies.forEach(policy => { @@ -285,22 +285,22 @@ class CICoverageCommand extends CoverageCommand { }); }); } - + return breakdown; } - + /** * Display CI report in human-readable format (for local development) * @param {Object} report - CI report */ displayCIReport(report) { const { status, summary, enforcement } = report; - + console.log(`\nCOVERAGE_STATUS: ${status.toUpperCase()}`); console.log(`OVERALL_COVERAGE: ${summary.overall.percentage}% (${summary.overall.covered}/${summary.overall.total})`); console.log(`RPC_COVERAGE: ${summary.rpcFunctions.percentage}% (${summary.rpcFunctions.covered}/${summary.rpcFunctions.total})`); console.log(`RLS_COVERAGE: ${summary.rlsPolicies.percentage}% (${summary.rlsPolicies.covered}/${summary.rlsPolicies.total})`); - + if (enforcement) { console.log(`\nENFORCEMENT: ${enforcement.passed ? 'PASSED' : 'FAILED'}`); if (enforcement.failures.length > 0) { @@ -310,10 +310,10 @@ class CICoverageCommand extends CoverageCommand { }); } } - + console.log(`\nEXECUTION_TIME: ${report.execution.duration}ms`); } - + /** * Write CI artifacts (JSON reports, coverage files) * @param {Object} results - Full coverage results @@ -325,26 +325,26 @@ class CICoverageCommand extends CoverageCommand { if (this.outputDir) { // Write structured coverage report await this.writeJSONArtifact(report, 'coverage-report.json'); - + // Write detailed results for further analysis await this.writeJSONArtifact(results, 'coverage-details.json'); - + // Write enforcement results if enabled if (options.enforce && report.enforcement) { await this.writeJSONArtifact(report.enforcement, 'coverage-enforcement.json'); } - + // Write coverage badges data for README/CI const badges = this.generateBadgeData(report.summary); await this.writeJSONArtifact(badges, 'coverage-badges.json'); } - + } catch (error) { // Don't fail coverage analysis if we can't write artifacts console.error(`Warning: Could not write coverage artifacts: ${error.message}`); } } - + /** * Generate badge data for shields.io or similar services * @param {Object} summary - Coverage summary @@ -356,7 +356,7 @@ class CICoverageCommand extends CoverageCommand { if (percentage >= 60) return 'yellow'; return 'red'; }; - + return { overall: { label: 'coverage', @@ -375,7 +375,7 @@ class CICoverageCommand extends CoverageCommand { } }; } - + /** * Write JSON artifact to output directory * @param {Object} data - Data to write @@ -384,13 +384,13 @@ class CICoverageCommand extends CoverageCommand { async writeJSONArtifact(data, filename) { try { const filePath = await this.getOutputFile(filename); - const fs = require('fs').promises; + import fs from 'fs'.promises; await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf8'); } catch (error) { throw new Error(`Failed to write ${filename}: ${error.message}`); } } - + /** * Handle enforcement logic and exit codes * @param {Object} report - CI report @@ -401,10 +401,10 @@ class CICoverageCommand extends CoverageCommand { if (!options.enforce || !report.enforcement) { return true; // No enforcement requested } - + return report.enforcement.passed; } - + /** * Emit structured CI events * @param {string} eventType - Type of event @@ -416,7 +416,7 @@ class CICoverageCommand extends CoverageCommand { ...data }); } - + /** * Override progress method to suppress output in CI mode */ @@ -426,7 +426,7 @@ class CICoverageCommand extends CoverageCommand { super.progress(message); } } - + /** * Override warn method for structured CI output */ @@ -442,7 +442,7 @@ class CICoverageCommand extends CoverageCommand { super.warn(message); } } - + /** * Override error method for structured CI output */ @@ -459,7 +459,7 @@ class CICoverageCommand extends CoverageCommand { super.error(message, error); } } - + /** * Override success method for structured CI output */ @@ -477,4 +477,4 @@ class CICoverageCommand extends CoverageCommand { } } -module.exports = CICoverageCommand; \ No newline at end of file +export default CICoverageCommand; diff --git a/src/commands/test/ci/CIRunCommand.js b/starfleet/data-cli/src/commands/test/ci/CIRunCommand.js similarity index 96% rename from src/commands/test/ci/CIRunCommand.js rename to starfleet/data-cli/src/commands/test/ci/CIRunCommand.js index f25e6cc..7a54e52 100644 --- a/src/commands/test/ci/CIRunCommand.js +++ b/starfleet/data-cli/src/commands/test/ci/CIRunCommand.js @@ -1,11 +1,11 @@ /** * CI Run Command - CI-optimized test execution - * + * * Wraps RunCommand with machine-friendly output, JUnit XML generation, * and proper exit codes for CI/CD environments. */ -const RunCommand = require('../RunCommand'); +import RunCommand from '../RunCommand.js'; /** * CI-friendly test execution with structured output @@ -13,7 +13,7 @@ const RunCommand = require('../RunCommand'); class CIRunCommand extends RunCommand { constructor(databaseUrl, serviceRoleKey = null, testsDir, outputDir, logger = null, isProd = false) { super(databaseUrl, serviceRoleKey, testsDir, outputDir, logger, isProd); - + // Force CI mode behavior this.ciMode = true; this.suppressProgress = true; @@ -25,31 +25,31 @@ class CIRunCommand extends RunCommand { async performExecute(options = {}) { const startTime = Date.now(); const isCI = process.env.CI !== 'false'; - + // Force machine-readable output by default in CI mode const ciOptions = { ...options, format: options.format || (isCI ? 'junit' : 'console'), output: options.output || (isCI ? 'test-results' : null) }; - + try { // Emit structured start event - this.emitCIEvent('test_run_started', { + this.emitCIEvent('test_run_started', { testsDir: this.testsDir, options: ciOptions, timestamp: new Date().toISOString() }); - + // Execute tests using parent class logic const results = await super.performExecute(ciOptions); - + // Calculate execution time const duration = Date.now() - startTime; - + // Generate CI-friendly summary const ciSummary = this.generateCISummary(results, duration); - + // Output summary for CI if (isCI) { // Always output summary to stdout for CI parsing @@ -58,26 +58,26 @@ class CIRunCommand extends RunCommand { // Human-readable summary for local development this.displayCISummary(ciSummary); } - + // Write additional CI artifacts await this.writeCIArtifacts(results, ciSummary, ciOptions); - + // Emit structured completion event this.emitCIEvent('test_run_completed', { success: results.failed === 0, duration, summary: ciSummary.summary }); - + // Set proper exit code based on test results const exitCode = this.getExitCode(results); process.exitCode = exitCode; - + return ciSummary; - + } catch (error) { const duration = Date.now() - startTime; - + // Structured error output const errorReport = { status: 'error', @@ -88,20 +88,20 @@ class CIRunCommand extends RunCommand { duration, timestamp: new Date().toISOString() }; - + if (isCI) { console.error(JSON.stringify(errorReport, null, 2)); } else { console.error(`TEST_RUN_ERROR: ${error.message}`); } - + this.emitCIEvent('test_run_failed', { error: error.message, duration }); - + process.exitCode = 1; throw error; } } - + /** * Generate CI-friendly test summary * @param {Object} results - Test results from parent class @@ -110,7 +110,7 @@ class CIRunCommand extends RunCommand { */ generateCISummary(results, duration) { const { total, passed, failed, skipped, testFunctions } = results; - + return { status: failed > 0 ? 'failed' : 'passed', summary: { @@ -143,21 +143,21 @@ class CIRunCommand extends RunCommand { } }; } - + /** * Display CI summary in human-readable format (for local development) * @param {Object} summary - CI summary */ displayCISummary(summary) { const { status, summary: stats, failedTests, execution } = summary; - + console.log(`\nTEST_RUN_STATUS: ${status.toUpperCase()}`); console.log(`TOTAL_TESTS: ${stats.total}`); console.log(`PASSED: ${stats.passed}`); console.log(`FAILED: ${stats.failed}`); console.log(`SKIPPED: ${stats.skipped}`); console.log(`SUCCESS: ${stats.success}`); - + if (failedTests.length > 0) { console.log('\nFAILED_TESTS:'); failedTests.forEach(test => { @@ -167,10 +167,10 @@ class CIRunCommand extends RunCommand { } }); } - + console.log(`\nEXECUTION_TIME: ${execution.duration}ms`); } - + /** * Write CI artifacts (JUnit XML, JSON reports, etc.) * @param {Object} results - Full test results @@ -182,22 +182,22 @@ class CIRunCommand extends RunCommand { // Always write JSON summary for CI consumption if (this.outputDir) { await this.writeJSONArtifact(summary, 'test-summary.json'); - + // Write detailed results if requested if (options.detailed !== false) { await this.writeJSONArtifact(results, 'test-results.json'); } } - + // JUnit XML is handled by parent class via format option // JSON format is handled by parent class via format option - + } catch (error) { // Don't fail tests if we can't write artifacts console.error(`Warning: Could not write CI artifacts: ${error.message}`); } } - + /** * Write JSON artifact to output directory * @param {Object} data - Data to write @@ -206,13 +206,13 @@ class CIRunCommand extends RunCommand { async writeJSONArtifact(data, filename) { try { const filePath = await this.getOutputFile(filename); - const fs = require('fs').promises; + import fs from 'fs'.promises; await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf8'); } catch (error) { throw new Error(`Failed to write ${filename}: ${error.message}`); } } - + /** * Emit structured CI events * @param {string} eventType - Type of event @@ -224,7 +224,7 @@ class CIRunCommand extends RunCommand { ...data }); } - + /** * Override _displayResults to suppress console output in CI mode */ @@ -235,7 +235,7 @@ class CIRunCommand extends RunCommand { } // In CI mode, output is handled by generateCISummary } - + /** * Override progress method to suppress output in CI mode */ @@ -245,7 +245,7 @@ class CIRunCommand extends RunCommand { super.progress(message); } } - + /** * Override warn method for structured CI output */ @@ -261,7 +261,7 @@ class CIRunCommand extends RunCommand { super.warn(message); } } - + /** * Override error method for structured CI output */ @@ -278,7 +278,7 @@ class CIRunCommand extends RunCommand { super.error(message, error); } } - + /** * Override success method for structured CI output */ @@ -294,7 +294,7 @@ class CIRunCommand extends RunCommand { super.success(message); } } - + /** * Get detailed test metrics for CI reporting * @param {Object} results - Test results @@ -306,7 +306,7 @@ class CIRunCommand extends RunCommand { averageTestTime: 0, testFunctionMetrics: [] }; - + // Calculate per-function metrics if available if (results.testFunctions) { results.testFunctions.forEach(func => { @@ -318,9 +318,9 @@ class CIRunCommand extends RunCommand { }); }); } - + return metrics; } } -module.exports = CIRunCommand; \ No newline at end of file +export default CIRunCommand; diff --git a/src/commands/test/ci/CIValidateCommand.js b/starfleet/data-cli/src/commands/test/ci/CIValidateCommand.js similarity index 95% rename from src/commands/test/ci/CIValidateCommand.js rename to starfleet/data-cli/src/commands/test/ci/CIValidateCommand.js index 87b0b2c..33222b7 100644 --- a/src/commands/test/ci/CIValidateCommand.js +++ b/starfleet/data-cli/src/commands/test/ci/CIValidateCommand.js @@ -1,11 +1,11 @@ /** * CI Validate Command - CI-optimized test validation - * + * * Wraps ValidateCommand with machine-friendly output and proper exit codes * for CI/CD environments. */ -const ValidateCommand = require('../ValidateCommand'); +import ValidateCommand from '../ValidateCommand.js'; /** * CI-friendly test validation with structured output @@ -21,7 +21,7 @@ class CIValidateCommand extends ValidateCommand { pathResolver = null ) { super(databaseUrl, serviceRoleKey, testsDir, outputDir, logger, isProd, pathResolver); - + // Force CI mode behavior this.ciMode = true; this.suppressProgress = true; @@ -32,26 +32,26 @@ class CIValidateCommand extends ValidateCommand { */ async performExecute(options = {}) { const startTime = Date.now(); - + // Force silent mode unless explicitly disabled const isCI = process.env.CI !== 'false'; - + try { // Emit structured start event - this.emitCIEvent('validation_started', { + this.emitCIEvent('validation_started', { testsDir: this.testsDir, timestamp: new Date().toISOString() }); - + // Execute validation (parent class handles the logic) const results = await super.performExecute(options); - + // Calculate execution time const duration = Date.now() - startTime; - + // Generate CI-friendly report const ciReport = this.generateCIReport(results, duration); - + // Output report (structured for CI consumption) if (isCI) { // Machine-readable JSON output for CI @@ -60,27 +60,27 @@ class CIValidateCommand extends ValidateCommand { // Human-readable for local development this.displayCIReport(ciReport); } - + // Write results to file if outputDir provided if (this.outputDir) { await this.writeCIResults(ciReport, 'validation-results.json'); } - + // Emit structured completion event this.emitCIEvent('validation_completed', { success: !results.hasErrors, duration, summary: ciReport.summary }); - + // Set proper exit code process.exitCode = results.hasErrors ? 1 : 0; - + return ciReport; - + } catch (error) { const duration = Date.now() - startTime; - + // Structured error output const errorReport = { status: 'error', @@ -91,20 +91,20 @@ class CIValidateCommand extends ValidateCommand { duration, timestamp: new Date().toISOString() }; - + if (isCI) { console.error(JSON.stringify(errorReport, null, 2)); } else { console.error(`VALIDATION_ERROR: ${error.message}`); } - + this.emitCIEvent('validation_failed', { error: error.message, duration }); - + process.exitCode = 1; throw error; } } - + /** * Generate CI-friendly report * @param {Object} results - Validation results from parent class @@ -113,7 +113,7 @@ class CIValidateCommand extends ValidateCommand { */ generateCIReport(results, duration) { const { filesProcessed, syntaxErrors, pgTapIssues, structureWarnings, hasErrors } = results; - + return { status: hasErrors ? 'failed' : 'passed', summary: { @@ -153,44 +153,44 @@ class CIValidateCommand extends ValidateCommand { } }; } - + /** * Display CI report in human-readable format (for local development) * @param {Object} report - CI report */ displayCIReport(report) { const { status, summary, details } = report; - + console.log(`\nVALIDATION_STATUS: ${status.toUpperCase()}`); console.log(`FILES_PROCESSED: ${summary.filesProcessed}`); console.log(`TOTAL_ISSUES: ${summary.totalIssues}`); console.log(`ERRORS: ${summary.errors}`); console.log(`WARNINGS: ${summary.warnings}`); - + if (details.syntaxErrors.length > 0) { console.log('\nSYNTAX_ERRORS:'); details.syntaxErrors.forEach(error => { console.log(` ${error.file}:${error.line} - ${error.message}`); }); } - + if (details.pgTapIssues.length > 0) { console.log('\nPGTAP_ISSUES:'); details.pgTapIssues.forEach(issue => { console.log(` ${issue.file}:${issue.line} - ${issue.message}`); }); } - + if (details.structureWarnings.length > 0) { console.log('\nSTRUCTURE_WARNINGS:'); details.structureWarnings.forEach(warning => { console.log(` ${warning.file}:${warning.line} - ${warning.message}`); }); } - + console.log(`\nEXECUTION_TIME: ${report.execution.duration}ms`); } - + /** * Write CI results to file * @param {Object} report - CI report @@ -199,14 +199,14 @@ class CIValidateCommand extends ValidateCommand { async writeCIResults(report, filename) { try { const filePath = await this.getOutputFile(filename); - const fs = require('fs').promises; + import fs from 'fs'.promises; await fs.writeFile(filePath, JSON.stringify(report, null, 2), 'utf8'); } catch (error) { // Don't fail the entire validation if we can't write results console.error(`Warning: Could not write validation results to file: ${error.message}`); } } - + /** * Emit structured CI events * @param {string} eventType - Type of event @@ -218,7 +218,7 @@ class CIValidateCommand extends ValidateCommand { ...data }); } - + /** * Override progress method to suppress output in CI mode */ @@ -228,7 +228,7 @@ class CIValidateCommand extends ValidateCommand { super.progress(message); } } - + /** * Override warn method for structured CI output */ @@ -244,7 +244,7 @@ class CIValidateCommand extends ValidateCommand { super.warn(message); } } - + /** * Override error method for structured CI output */ @@ -261,7 +261,7 @@ class CIValidateCommand extends ValidateCommand { super.error(message, error); } } - + /** * Override success method for structured CI output */ @@ -279,4 +279,4 @@ class CIValidateCommand extends ValidateCommand { } } -module.exports = CIValidateCommand; \ No newline at end of file +export default CIValidateCommand; diff --git a/starfleet/data-cli/src/commands/test/index.js b/starfleet/data-cli/src/commands/test/index.js new file mode 100644 index 0000000..ff442c3 --- /dev/null +++ b/starfleet/data-cli/src/commands/test/index.js @@ -0,0 +1,34 @@ +/** + * Test Commands for data CLI + */ + +import CompileCommand from './CompileCommand.js'; +import RunCommand from './RunCommand.js'; +import DevCycleCommand from './DevCycleCommand.js'; +import CoverageCommand from './CoverageCommand.js'; +import WatchCommand from './WatchCommand.js'; +import ValidateCommand from './ValidateCommand.js'; +import GenerateCommand from './GenerateCommand.js'; +import GenerateTemplateCommand from './GenerateTemplateCommand.js'; +import CacheCommand from './CacheCommand.js'; + +// CI Commands for automated testing +import CIValidateCommand from './ci/CIValidateCommand.js'; +import CIRunCommand from './ci/CIRunCommand.js'; +import CICoverageCommand from './ci/CICoverageCommand.js'; + +export { + CompileCommand, + RunCommand, + DevCycleCommand, + CoverageCommand, + WatchCommand, + ValidateCommand, + GenerateCommand, + GenerateTemplateCommand, + CacheCommand, + // CI Commands + CIValidateCommand, + CIRunCommand, + CICoverageCommand +}; diff --git a/starfleet/data-cli/src/commands/thin/db/migrate/apply.js b/starfleet/data-cli/src/commands/thin/db/migrate/apply.js new file mode 100644 index 0000000..ff48d51 --- /dev/null +++ b/starfleet/data-cli/src/commands/thin/db/migrate/apply.js @@ -0,0 +1,50 @@ +/** + * Thin command wrapper for migrate apply + * All business logic is in the use-case + */ + +export async function run({ services }, flags) { + // Parse command-line flags + const sqlRoot = flags.sqlRoot || flags['sql-dir'] || 'sql'; + const dryRun = flags['dry-run'] || flags.dryRun || false; + const skipSafety = flags['skip-safety'] || false; + + // Run safety checks unless skipped + if (!skipSafety && !dryRun) { + const policy = { + requireClean: true, + allowedBranches: ['main', 'master', 'develop'], + requireTests: false, // Can be enabled via flag + requireUpToDate: false + }; + + const safetyResult = await services.useCases.verifySafetyGates.execute(policy); + + if (!safetyResult.passed) { + services.ports.logger.error( + { failures: safetyResult.failures }, + 'Safety checks failed. Use --skip-safety to override (dangerous!)' + ); + services.ports.proc.exit(1); + } + } + + // Generate the migration plan + const plan = await services.useCases.generateMigrationPlan.execute({ + sqlRoot + }); + + // Apply the migration + const result = await services.useCases.applyMigrationPlan.execute({ + plan, + dryRun + }); + + // Handle result + if (!result.success && !dryRun) { + services.ports.logger.error({ errors: result.errors }, 'Migration failed'); + services.ports.proc.exit(1); + } + + return result; +} diff --git a/starfleet/data-cli/src/commands/thin/db/migrate/generate.js b/starfleet/data-cli/src/commands/thin/db/migrate/generate.js new file mode 100644 index 0000000..2605b20 --- /dev/null +++ b/starfleet/data-cli/src/commands/thin/db/migrate/generate.js @@ -0,0 +1,29 @@ +/** + * Thin command wrapper for migrate generate + * All business logic is in the use-case + */ + +export async function run({ services }, flags) { + // Parse command-line flags + const sqlRoot = flags.sqlRoot || flags['sql-dir'] || 'sql'; + const outputFile = flags.out || flags.output; + const migrationName = flags.name; + + // Execute use-case + const plan = await services.useCases.generateMigrationPlan.execute({ + sqlRoot, + migrationName + }); + + // Write output if requested + if (outputFile) { + const outputPath = `${outputFile}`; + await services.ports.fs.writeFile(outputPath, plan.preview); + services.ports.logger.info({ file: outputPath }, `๐Ÿ“ Migration written to ${outputPath}`); + } else { + // Output to console if no file specified + console.log('\n' + plan.preview); + } + + return plan; +} diff --git a/starfleet/data-cli/src/config/ConfigLoader.js b/starfleet/data-cli/src/config/ConfigLoader.js new file mode 100644 index 0000000..5150fc6 --- /dev/null +++ b/starfleet/data-cli/src/config/ConfigLoader.js @@ -0,0 +1,231 @@ +/** + * Configuration management for data CLI + */ + +import { promises as fs } from 'fs'; +import path from 'path'; +import os from 'os'; +import { safeParsedataConfig, mergeConfigs } from './schemas/dataConfigSchema.js'; + +/** + * Configuration class for data CLI + */ +class Config { + constructor(data = null, envVars = null) { + // Use provided environment variables or process.env as fallback + this.envVars = envVars || process.env; + // Use provided data or defaults + this.data = data || this.getDefaultConfig(); + } + + /** + * Get default configuration with environment variables + */ + getDefaultConfig() { + // Build config with environment variable defaults + const config = { + environments: { + local: { + db: + this.envVars.DATABASE_URL || + this.envVars.data_DATABASE_URL || + 'postgresql://postgres:postgres@127.0.0.1:54332/postgres', + supabase_url: this.envVars.SUPABASE_URL || this.envVars.data_SUPABASE_URL, + supabase_anon_key: this.envVars.SUPABASE_ANON_KEY || this.envVars.data_ANON_KEY, + supabase_service_role_key: + this.envVars.SUPABASE_SERVICE_ROLE_KEY || this.envVars.data_SERVICE_ROLE_KEY + } + }, + paths: { + sql_dir: this.envVars.data_SQL_DIR || './sql', + tests_dir: this.envVars.data_TESTS_DIR || './tests', + migrations_dir: this.envVars.data_MIGRATIONS_DIR || './migrations', + functions_dir: this.envVars.data_FUNCTIONS_DIR || './functions', + schemas_dir: this.envVars.data_SCHEMAS_DIR || './schemas' + }, + test: { + minimum_coverage: 80, + test_timeout: 300, + output_formats: ['console', 'json'] + }, + safety: { + require_prod_flag: true, + require_confirmation: true + } + }; + + // Add prod environment if variables are present + if (this.envVars.PROD_DATABASE_URL || this.envVars.PROD_SUPABASE_URL) { + config.environments.prod = { + db: this.envVars.PROD_DATABASE_URL || '', + supabase_url: this.envVars.PROD_SUPABASE_URL, + supabase_anon_key: this.envVars.PROD_SUPABASE_ANON_KEY, + supabase_service_role_key: this.envVars.PROD_SUPABASE_SERVICE_ROLE_KEY + }; + } + + return config; + } + + /** + * Load configuration from file or defaults + */ + static async load(configPath = null, envVars = null) { + // Determine config file paths to check + const paths = [ + configPath, + path.join(process.cwd(), '.datarc.json'), + path.join(process.cwd(), '.datarc'), + path.join(os.homedir(), '.datarc.json'), + path.join(os.homedir(), '.datarc') + ].filter(Boolean); + + // Try to load config from each path + const configPromises = paths.map(async (configFile) => { + try { + const content = await fs.readFile(configFile, 'utf8'); + const rawConfig = JSON.parse(content); + + // Create new Config with defaults + const config = new Config(null, envVars); + const defaults = config.getDefaultConfig(); + + // Validate and merge with Zod + const parseResult = safeParsedataConfig(rawConfig); + if (parseResult.success) { + // Merge validated config with defaults + config.data = mergeConfigs(defaults, parseResult.data); + } else { + // Log validation errors but use what we can + console.warn(`Configuration validation warnings in ${configFile}:`); + parseResult.error.errors.forEach((err) => { + console.warn(` - ${err.path.join('.')}: ${err.message}`); + }); + // Fall back to manual merge for partial configs + config.data = config.merge(defaults, rawConfig); + } + + return config; + } catch { + // Continue to next path + return null; + } + }); + + const configs = await Promise.all(configPromises); + const validConfig = configs.find((config) => config !== null); + + if (validConfig) { + return validConfig; + } + + // Return default config if no file found + return new Config(null, envVars); + } + + /** + * Deep merge configuration objects (fallback for invalid configs) + */ + merge(defaults, overrides) { + const result = { ...defaults }; + + for (const key in overrides) { + if ( + typeof overrides[key] === 'object' && + !Array.isArray(overrides[key]) && + overrides[key] !== null + ) { + result[key] = this.merge(defaults[key] || {}, overrides[key]); + } else { + result[key] = overrides[key]; + } + } + + return result; + } + + /** + * Get environment configuration + */ + getEnvironment(isProd = false) { + return isProd ? this.data.environments.prod : this.data.environments.local; + } + + /** + * Save configuration to file + */ + async save(configPath = null) { + const filePath = configPath || path.join(process.cwd(), '.datarc.json'); + + // Validate before saving + const parseResult = safeParsedataConfig(this.data); + if (!parseResult.success) { + throw new Error(`Cannot save invalid configuration: ${parseResult.error.message}`); + } + + // Add schema reference for IDE support + const configWithSchema = { + $schema: './datarc.schema.json', + ...parseResult.data + }; + + const content = JSON.stringify(configWithSchema, null, 2); + await fs.writeFile(filePath, content, 'utf8'); + } + + /** + * Get a configuration value by path + */ + get(path) { + const keys = path.split('.'); + let value = this.data; + + for (const key of keys) { + if (value && typeof value === 'object') { + value = value[key]; + } else { + return undefined; + } + } + + return value; + } + + /** + * Set a configuration value by path + */ + set(path, value) { + const keys = path.split('.'); + const lastKey = keys.pop(); + let target = this.data; + + for (const key of keys) { + if (!target[key] || typeof target[key] !== 'object') { + target[key] = {}; + } + target = target[key]; + } + + target[lastKey] = value; + } + + /** + * Get test configuration + */ + getTestConfig() { + return this.get('test') || {}; + } + + /** + * Validate entire configuration + */ + validate() { + const result = safeParsedataConfig(this.data); + if (!result.success) { + return { valid: false, errors: result.error.errors }; + } + return { valid: true, data: result.data }; + } +} + +export default Config; diff --git a/starfleet/data-cli/src/container/buildServices.js b/starfleet/data-cli/src/container/buildServices.js new file mode 100644 index 0000000..212e834 --- /dev/null +++ b/starfleet/data-cli/src/container/buildServices.js @@ -0,0 +1,152 @@ +/** + * Composition Root - Wire all dependencies together + * This is the ONLY place where we instantiate adapters and wire dependencies + */ + +import { ensurePort } from '@starfleet/data-core/ports/ensurePort.js'; +import { Events } from '@starfleet/data-core/events/EventTypes.js'; +import { makeGenerateMigrationPlan } from '@starfleet/data-core/application/GenerateMigrationPlan.js'; +import { makeApplyMigrationPlan } from '@starfleet/data-core/application/ApplyMigrationPlan.js'; +import { makeVerifySafetyGates } from '@starfleet/data-core/application/VerifySafetyGates.js'; + +import { FileSystemAdapter } from '@starfleet/data-host-node/adapters/FileSystemAdapter.js'; +import { GlobAdapter } from '@starfleet/data-host-node/adapters/GlobAdapter.js'; +import { ClockAdapter } from '@starfleet/data-host-node/adapters/ClockAdapter.js'; +import { EnvironmentAdapter } from '@starfleet/data-host-node/adapters/EnvironmentAdapter.js'; +import { LoggerConsoleAdapter } from '@starfleet/data-host-node/adapters/LoggerConsoleAdapter.js'; +import { EventBusNodeAdapter } from '@starfleet/data-host-node/adapters/EventBusNodeAdapter.js'; +import { GitPortNodeAdapter } from '@starfleet/data-host-node/adapters/GitPortNodeAdapter.js'; +import { DbPortNodeAdapter } from '@starfleet/data-host-node/adapters/DbPortNodeAdapter.js'; +import { ProcessPortNodeAdapter } from '@starfleet/data-host-node/adapters/ProcessPortNodeAdapter.js'; +import { CryptoPortNodeAdapter } from '@starfleet/data-host-node/adapters/CryptoPortNodeAdapter.js'; + +import { attachCliReporter } from '../reporters/attachCliReporter.js'; + +/** + * Build and wire all services + * @param {Object} [config] - Optional configuration + * @param {string} [config.databaseUrl] - Database connection string + * @param {boolean} [config.debug] - Enable debug logging + * @returns {Object} Services container + */ +export function buildServices(config = {}) { + // Get database URL from config or environment + const databaseUrl = + config.databaseUrl || process.env.DATABASE_URL || process.env.DATA_DATABASE_URL; + + // Instantiate adapters with runtime validation + const fs = ensurePort('FileSystemPort', FileSystemAdapter, [ + 'readFile', + 'writeFile', + 'exists', + 'mkdirp', + 'rm', + 'readdir', + 'stat' + ]); + + const glob = ensurePort('GlobPort', GlobAdapter, ['find']); + + const clock = ensurePort('ClockPort', ClockAdapter, ['now', 'nowMs']); + + const env = ensurePort('EnvironmentPort', EnvironmentAdapter, ['get', 'has']); + + const git = ensurePort('GitPort', new GitPortNodeAdapter(), [ + 'status', + 'tag', + 'latestTag', + 'revParse' + ]); + + const db = ensurePort('DbPort', new DbPortNodeAdapter(databaseUrl), [ + 'apply', + 'query', + 'runPgTap', + 'withTransaction' + ]); + + const proc = ensurePort('ProcessPort', new ProcessPortNodeAdapter(), [ + 'spawn', + 'exec', + 'exit', + 'cwd', + 'chdir', + 'which' + ]); + + const crypto = ensurePort('CryptoPort', new CryptoPortNodeAdapter(), [ + 'hash', + 'randomUUID', + 'randomBytes', + 'timingSafeEqual' + ]); + + // Logger with context bindings + const logger = ensurePort( + 'LoggerPort', + new LoggerConsoleAdapter({ + service: 'data-cli', + version: '1.0.0' + }), + ['info', 'warn', 'error', 'debug', 'child'] + ); + + // Event bus for decoupled communication + const bus = new EventBusNodeAdapter(); + + // Wire up use-cases with dependencies + const generateMigrationPlan = makeGenerateMigrationPlan({ + fs, + glob, + crypto, + logger, + clock, + bus + }); + + const applyMigrationPlan = makeApplyMigrationPlan({ + db, + logger, + clock, + bus + }); + + const verifySafetyGates = makeVerifySafetyGates({ + git, + db, + logger, + bus + }); + + // Attach CLI reporter for formatted output + attachCliReporter({ bus, logger }); + + // Return service container + return { + // Ports for direct access when needed + ports: { + fs, + glob, + clock, + env, + git, + db, + proc, + crypto, + logger, + bus + }, + + // Use-cases for business logic + useCases: { + generateMigrationPlan, + applyMigrationPlan, + verifySafetyGates + }, + + // Cleanup function + async shutdown() { + await db.close?.(); + } + }; +} diff --git a/starfleet/data-cli/src/dev/smoke.js b/starfleet/data-cli/src/dev/smoke.js new file mode 100644 index 0000000..49d40b7 --- /dev/null +++ b/starfleet/data-cli/src/dev/smoke.js @@ -0,0 +1,87 @@ +#!/usr/bin/env node +/** + * Smoke test - Verify DI container and basic use-cases work + * Run with: node packages/data-cli/src/dev/smoke.js + */ + +import { buildServices } from '../container/buildServices.js'; + +console.log('๐Ÿ”ฅ Running smoke test...\n'); + +try { + // Build the DI container + console.log('1. Building services container...'); + const services = buildServices(); + console.log(' โœ… Container built successfully'); + + // Verify all ports are wired + console.log('\n2. Verifying ports...'); + const portNames = Object.keys(services.ports); + console.log(` โœ… ${portNames.length} ports available: ${portNames.join(', ')}`); + + // Verify use-cases are wired + console.log('\n3. Verifying use-cases...'); + const useCaseNames = Object.keys(services.useCases); + console.log(` โœ… ${useCaseNames.length} use-cases available: ${useCaseNames.join(', ')}`); + + // Test a simple use-case with fake data + console.log('\n4. Testing generateMigrationPlan with mock SQL directory...'); + + // Create a temporary test directory + const testDir = '/tmp/smoke-test-sql'; + await services.ports.fs.mkdirp(testDir); + await services.ports.fs.writeFile( + `${testDir}/001_test.sql`, + 'CREATE TABLE test_table (id serial PRIMARY KEY);' + ); + + const plan = await services.useCases.generateMigrationPlan.execute({ + sqlRoot: testDir + }); + + console.log(` โœ… Generated plan with ${plan.steps.length} step(s)`); + console.log(` ๐Ÿ“„ Plan checksum: ${plan.checksum}`); + + // Test safety gates with current repo + console.log('\n5. Testing verifySafetyGates...'); + const safetyResult = await services.useCases.verifySafetyGates.execute({ + requireClean: false, // Don't require clean for smoke test + allowedBranches: [], // Allow any branch for smoke test + requireTests: false // Don't run tests for smoke test + }); + + console.log(` โœ… Safety gates checked: ${safetyResult.passed ? 'PASSED' : 'FAILED'}`); + if (safetyResult.failures.length > 0) { + console.log(` โš ๏ธ Failures: ${safetyResult.failures.join(', ')}`); + } + + // Test event bus + console.log('\n6. Testing event bus...'); + let eventReceived = false; + const unsubscribe = services.ports.bus.on('test.event', () => { + eventReceived = true; + }); + services.ports.bus.emit('test.event', { test: true }); + + if (eventReceived) { + console.log(' โœ… Event bus working'); + } else { + throw new Error('Event bus not working'); + } + + // Test unsubscribe + unsubscribe(); + + // Cleanup + console.log('\n7. Cleaning up...'); + await services.ports.fs.rm(testDir, { recursive: true, force: true }); + await services.shutdown(); + console.log(' โœ… Cleanup complete'); + + console.log('\nโœ… All smoke tests passed!\n'); + process.exit(0); +} catch (error) { + console.error('\nโŒ Smoke test failed:', error.message); + console.error(error.stack); + process.exit(1); +} diff --git a/src/index.js b/starfleet/data-cli/src/index.js old mode 100644 new mode 100755 similarity index 75% rename from src/index.js rename to starfleet/data-cli/src/index.js index b8fed1b..dd54751 --- a/src/index.js +++ b/starfleet/data-cli/src/index.js @@ -1,10 +1,18 @@ +#!/usr/bin/env node + /** * data CLI Main Entry Point */ -const { Command } = require('commander'); -const { displayLogo } = require('./ui/logo'); -const { version } = require('../package.json'); +import { Command } from 'commander'; +import { displayLogo } from './ui/logo.js'; +import { readFileSync } from 'fs'; +import { fileURLToPath } from 'url'; +import { dirname, join } from 'path'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); +const { version } = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8')); // Note: Commands are loaded dynamically in their respective action handlers @@ -14,27 +22,27 @@ const { version } = require('../package.json'); async function cli(argv) { // Check if this is a help request or no arguments (which shows help) const isHelpRequest = argv.includes('--help') || argv.includes('-h') || argv.length <= 2; - + // Display logo for interactive sessions and help requests if ((process.stdout.isTTY && !process.env.CI) || isHelpRequest) { await displayLogo(); } - + // Configuration now handled via CLI args and env vars - + // Create main command const program = new Command(); - + // Initialize paths and database credentials in preAction hook let paths = null; let databaseUrl = null; let serviceRoleKey = null; let anonKey = null; let outputConfig = null; - - program.hook('preAction', (thisCommand) => { + + program.hook('preAction', async (thisCommand) => { const opts = thisCommand.opts(); - + // Collect path options paths = { // Input paths @@ -46,14 +54,14 @@ async function cli(argv) { buildDir: opts.buildDir || process.env.data_BUILD_DIR || './build', reportsDir: opts.reportsDir || process.env.data_REPORTS_DIR || './reports' }; - + // Get database credentials from environment databaseUrl = process.env.DATABASE_URL || process.env.data_DATABASE_URL; serviceRoleKey = process.env.data_SERVICE_ROLE_KEY; anonKey = process.env.data_ANON_KEY; - + // Initialize OutputConfig - const OutputConfig = require('./lib/OutputConfig'); + const { default: OutputConfig } = await import('./lib/OutputConfig.js'); outputConfig = new OutputConfig( opts.config, null, // cliSupabaseDir @@ -64,7 +72,7 @@ async function cli(argv) { paths.buildDir, null // cliProjectRoot ); - + // Debug output if requested if (process.env.data_DEBUG_PATHS) { console.log('data Path Configuration:'); @@ -80,7 +88,7 @@ async function cli(argv) { }); } }); - + program .name('data') .description('โ›ฐ๏ธ Advanced Resource Command Hub for PostgreSQL') @@ -97,43 +105,42 @@ async function cli(argv) { .option('--migrations-dir ', 'Directory for migration output') .option('--build-dir ', 'Directory for build artifacts') .option('--reports-dir ', 'Directory for test reports and coverage'); - + // Add init command program .command('init') .description('Initialize a new D.A.T.A. project structure') .option('--path ', 'Path to initialize project (default: current directory)') .action(async (options) => { - const InitCommand = require('./commands/InitCommand'); - const CliReporter = require('./reporters/CliReporter'); - + const { default: InitCommand } = await import('./commands/InitCommand.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new InitCommand({ path: options.path || process.cwd() }); const reporter = new CliReporter(program.opts().json); reporter.attach(command); - + try { await command.execute(); } catch (error) { if (!program.opts().json) { + console.error('Command failed:', error.message); process.exit(1); } } }); // Add database commands - const db = program - .command('db') - .description('Database operations'); - + const db = program.command('db').description('Database operations'); + db.command('reset') .description('Reset the local database') - .action(async (options) => { + .action(async () => { const parentOpts = program.opts(); - const ResetCommand = require('./commands/db/ResetCommand'); - const CliReporter = require('./reporters/CliReporter'); - + const { default: ResetCommand } = await import('./commands/db/ResetCommand.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new ResetCommand( databaseUrl, serviceRoleKey, @@ -145,24 +152,25 @@ async function cli(argv) { command.outputConfig = outputConfig; const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - + db.command('query ') .description('Run an SQL query') .option('-f, --file', 'Treat input as file path instead of SQL') .action(async (sql, options) => { const parentOpts = program.opts(); - const { QueryCommand } = require('./commands/db'); - const CliReporter = require('./reporters/CliReporter'); - + const { QueryCommand } = await import('./commands/db/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new QueryCommand( databaseUrl, serviceRoleKey, @@ -172,16 +180,17 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(sql, options.file); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - + db.command('compile') .description('Compile SQL sources into migration with optional functions deployment') .option('--deploy-functions', 'Deploy Edge Functions after successful compilation') @@ -190,18 +199,13 @@ async function cli(argv) { .option('--debug-functions', 'Enable debug output for function deployment') .action(async (options) => { const parentOpts = program.opts(); - const { CompileCommand } = require('./commands/db'); - const CliReporter = require('./reporters/CliReporter'); - - const command = new CompileCommand( - paths.sqlDir, - paths.migrationsDir, - null, - parentOpts.prod - ); + const { CompileCommand } = await import('./commands/db/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + + const command = new CompileCommand(paths.sqlDir, paths.migrationsDir, null, parentOpts.prod); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + // Prepare compile options with functions deployment const compileOptions = { deployFunctions: options.deployFunctions, @@ -209,22 +213,22 @@ async function cli(argv) { skipImportMap: options.skipImportMap, debug: options.debugFunctions }; - + try { await command.execute(compileOptions); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - + // Add migrate subcommands - const migrate = db - .command('migrate') - .description('Database migration management'); - - migrate.command('generate') + const migrate = db.command('migrate').description('Database migration management'); + + migrate + .command('generate') .description('Generate migration from schema diff') .option('--name ', 'Migration name (required)') .option('--skip-compile', 'Skip source compilation step') @@ -233,17 +237,17 @@ async function cli(argv) { .option('--desired-db ', 'Desired database URL (defaults to compiled SQL)') .action(async (options) => { const parentOpts = program.opts(); - const MigrateGenerateCommand = require('./commands/db/migrate/generate'); - const CliReporter = require('./reporters/CliReporter'); - + const { default: MigrateGenerateCommand } = await import('./commands/db/migrate/generate.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new MigrateGenerateCommand( null, // config will use default - null, // logger will be added by CliReporter + null, // logger will be added by CliReporter parentOpts.prod ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { // Convert commander options to args array for our command const args = []; @@ -262,24 +266,26 @@ async function cli(argv) { if (options.desiredDb) { args.push('--desired-db', options.desiredDb); } - + await command.execute(args); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - migrate.command('promote') + migrate + .command('promote') .description('Promote tested migration to production') .option('-m, --migration ', 'Migration to promote', 'current') .option('--no-git', 'Skip Git staging') .action(async (options) => { const parentOpts = program.opts(); - const MigratePromoteCommand = require('./commands/db/migrate/promote'); - const CliReporter = require('./reporters/CliReporter'); - + const { default: MigratePromoteCommand } = await import('./commands/db/migrate/promote.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new MigratePromoteCommand( null, // config will use default null, // logger will be added by CliReporter @@ -287,11 +293,12 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(options); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } @@ -302,86 +309,86 @@ async function cli(argv) { .alias('fn') .description('Edge Functions deployment and management'); - functions.command('deploy [functions...]') + functions + .command('deploy [functions...]') .description('Deploy Edge Functions to Supabase') .option('--no-verify-jwt', 'Skip JWT verification during deployment') .option('--debug', 'Enable debug output') .option('--skip-import-map', 'Skip using import map in production') .action(async (functionNames, options) => { const parentOpts = program.opts(); - const { DeployCommand } = require('./commands/functions'); - const CliReporter = require('./reporters/CliReporter'); - + const { DeployCommand } = await import('./commands/functions/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new DeployCommand(paths.functionsDir, null, parentOpts.prod); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(functionNames, options); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - functions.command('validate [functions...]') + functions + .command('validate [functions...]') .description('Validate Edge Functions without deploying') - .action(async (functionNames, options) => { + .action(async (functionNames, _options) => { const parentOpts = program.opts(); - const { ValidateCommand } = require('./commands/functions'); - const CliReporter = require('./reporters/CliReporter'); - - const command = new ValidateCommand( - paths.testsDir, - paths.reportsDir, - null, - parentOpts.prod - ); + const { ValidateCommand } = await import('./commands/functions/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + + const command = new ValidateCommand(paths.testsDir, paths.reportsDir, null, parentOpts.prod); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(functionNames); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - functions.command('status [functions...]') + functions + .command('status [functions...]') .description('Show Edge Functions deployment status') - .action(async (functionNames, options) => { + .action(async (functionNames, _options) => { const parentOpts = program.opts(); - const { StatusCommand } = require('./commands/functions'); - const CliReporter = require('./reporters/CliReporter'); - + const { StatusCommand } = await import('./commands/functions/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new StatusCommand(paths.functionsDir, null, parentOpts.prod); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(functionNames); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); // Add test commands - const test = program - .command('test') - .description('Database and application testing'); + const test = program.command('test').description('Database and application testing'); - test.command('compile') + test + .command('compile') .description('Compile tests for execution') - .action(async (options) => { + .action(async () => { const parentOpts = program.opts(); - const { CompileCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { CompileCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new CompileCommand( paths.testsDir, paths.migrationsDir, @@ -390,17 +397,19 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - test.command('run') + test + .command('run') .description('Run compiled tests') .option('--pattern ', 'Pattern to match test function names') .option('--suite ', 'Run only tests in this suite') @@ -411,9 +420,9 @@ async function cli(argv) { .option('--output ', 'Output file for junit/json formats') .action(async (options) => { const parentOpts = program.opts(); - const { RunCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { RunCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new RunCommand( databaseUrl, serviceRoleKey, @@ -424,10 +433,10 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { const results = await command.execute(options); - + // Set proper exit code based on test results if (results && command.getExitCode) { const exitCode = command.getExitCode(results); @@ -437,12 +446,14 @@ async function cli(argv) { } } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - test.command('dev-cycle') + test + .command('dev-cycle') .description('Run full development cycle: compile โ†’ reset โ†’ test') .option('--pattern ', 'Pattern to match test function names') .option('--suite ', 'Run only tests in this suite') @@ -451,9 +462,9 @@ async function cli(argv) { .option('--output ', 'Output file for junit/json formats') .action(async (options) => { const parentOpts = program.opts(); - const DevCycleCommand = require('./commands/test/DevCycleCommand'); - const CliReporter = require('./reporters/CliReporter'); - + const { default: DevCycleCommand } = await import('./commands/test/DevCycleCommand.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new DevCycleCommand( databaseUrl, serviceRoleKey, @@ -464,10 +475,10 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { const results = await command.execute(options); - + // Set proper exit code based on test results if (results && command.getExitCode) { const exitCode = command.getExitCode(results); @@ -477,12 +488,14 @@ async function cli(argv) { } } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - test.command('coverage') + test + .command('coverage') .description('Generate test coverage reports') .option('--format ', 'Output format (html, json, lcov)', 'html') .option('--output ', 'Output directory', 'coverage') @@ -492,9 +505,9 @@ async function cli(argv) { .option('--min-rls-coverage ', 'Minimum RLS policy coverage percentage', '70') .action(async (options) => { const parentOpts = program.opts(); - const { CoverageCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { CoverageCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new CoverageCommand( databaseUrl, serviceRoleKey, @@ -505,25 +518,27 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(options); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - test.command('watch') + test + .command('watch') .description('Watch for changes and re-run tests') .option('--pattern ', 'Pattern to match test files') .option('--ignore ', 'Pattern to ignore files') .action(async (options) => { const parentOpts = program.opts(); - const { WatchCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { WatchCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new WatchCommand( databaseUrl, serviceRoleKey, @@ -534,24 +549,26 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(options); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - test.command('validate') + test + .command('validate') .description('Validate test configuration and setup') .option('--fix', 'Attempt to fix validation issues') .action(async (options) => { const parentOpts = program.opts(); - const { ValidateCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { ValidateCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new ValidateCommand( databaseUrl, serviceRoleKey, @@ -562,25 +579,27 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(options); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - test.command('generate') + test + .command('generate') .description('Generate pgTAP test templates for RPC functions and RLS policies') .option('--rpc ', 'Generate RPC function test template') .option('--rls ', 'Generate RLS policy test template') .action(async (options) => { const parentOpts = program.opts(); - const { GenerateCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { GenerateCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + // Determine test type and name from options let testType, testName; if (options.rpc) { @@ -593,30 +612,32 @@ async function cli(argv) { console.error('Error: Must specify either --rpc or --rls '); process.exit(1); } - - const command = new GenerateCommand( - paths.testsDir, - paths.reportsDir, - null, - parentOpts.prod - ); + + const command = new GenerateCommand(paths.testsDir, paths.reportsDir, null, parentOpts.prod); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute({ type: testType, name: testName }); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); - - test.command('generate-template') - .description('Generate pgTAP test templates using TestTemplateGenerator and TestRequirementAnalyzer') + + test + .command('generate-template') + .description( + 'Generate pgTAP test templates using TestTemplateGenerator and TestRequirementAnalyzer' + ) .option('--migration ', 'Migration file to analyze for test requirements') .option('--type ', 'Test type (rpc, rls, trigger, constraint, function)') - .option('--name ', 'Name of entity to generate tests for (required if not using --migration)') + .option( + '--name ', + 'Name of entity to generate tests for (required if not using --migration)' + ) .option('--output ', 'Output file path (default: stdout)') .option('--schema ', 'Schema name (default: public)') .option('--parameters ', 'Comma-separated function parameters for RPC tests') @@ -624,9 +645,9 @@ async function cli(argv) { .option('--description ', 'Description for the test') .action(async (options) => { const parentOpts = program.opts(); - const { GenerateTemplateCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { GenerateTemplateCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new GenerateTemplateCommand( paths.testsDir, paths.reportsDir, @@ -635,25 +656,27 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(options); } catch (error) { if (!parentOpts.json) { + console.error('Command failed:', error.message); process.exit(1); } } }); // CI Commands - Optimized for continuous integration - test.command('ci-validate') + test + .command('ci-validate') .description('CI-optimized test validation with machine-readable output') .option('--output ', 'Output file for validation results (JSON format)') .action(async (options) => { const parentOpts = program.opts(); - const { CIValidateCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { CIValidateCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new CIValidateCommand( databaseUrl, serviceRoleKey, @@ -664,16 +687,18 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(options); } catch (error) { // CI commands always exit with proper codes + console.error('CI command failed:', error.message); process.exit(1); } }); - test.command('ci-run') + test + .command('ci-run') .description('CI-optimized test execution with JUnit/JSON output') .option('--pattern ', 'Pattern to match test function names') .option('--suite ', 'Run only tests in this suite') @@ -682,9 +707,9 @@ async function cli(argv) { .option('--detailed', 'Include detailed results in JSON output', true) .action(async (options) => { const parentOpts = program.opts(); - const { CIRunCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { CIRunCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new CIRunCommand( databaseUrl, serviceRoleKey, @@ -695,19 +720,21 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { const results = await command.execute(options); - + // CI commands handle their own exit codes const exitCode = command.getExitCode(results); process.exit(exitCode); } catch (error) { + console.error('CI command failed:', error.message); process.exit(1); } }); - test.command('ci-coverage') + test + .command('ci-coverage') .description('CI-optimized coverage analysis with enforcement') .option('--enforce', 'Enforce coverage thresholds (default: false)', false) .option('--min-coverage ', 'Minimum overall coverage percentage', '80') @@ -717,9 +744,9 @@ async function cli(argv) { .option('--output ', 'Output file prefix for coverage reports') .action(async (options) => { const parentOpts = program.opts(); - const { CICoverageCommand } = require('./commands/test'); - const CliReporter = require('./reporters/CliReporter'); - + const { CICoverageCommand } = await import('./commands/test/index.js'); + const { default: CliReporter } = await import('./reporters/CliReporter.js'); + const command = new CICoverageCommand( null, // config - uses default null, // logger - added by reporter @@ -727,11 +754,12 @@ async function cli(argv) { ); const reporter = new CliReporter(parentOpts.json); reporter.attach(command); - + try { await command.execute(options); // CI coverage command handles its own exit codes via process.exitCode } catch (error) { + console.error('CI command failed:', error.message); process.exit(1); } }); @@ -741,8 +769,8 @@ async function cli(argv) { // .command('maintenance') // .alias('maint') // .description('Maintenance mode management'); - - // TODO: Add status command when implemented + + // TODO: Add status command when implemented // program // .command('status') // .description('Show comprehensive system status') @@ -750,14 +778,20 @@ async function cli(argv) { // const parentOpts = program.opts(); // await statusCommand.execute({ ...options, ...parentOpts, config }); // }); - + // Parse arguments await program.parseAsync(argv); - + // Show help if no command provided if (argv.length === 2) { program.help(); } } -module.exports = { cli }; \ No newline at end of file +export { cli }; +export default cli; + +// Auto-run if called directly +if (import.meta.url === `file://${process.argv[1]}`) { + cli(process.argv).catch(console.error); +} diff --git a/src/lib/BuildCommand.js b/starfleet/data-cli/src/lib/BuildCommand.js similarity index 78% rename from src/lib/BuildCommand.js rename to starfleet/data-cli/src/lib/BuildCommand.js index c9d724e..596e535 100644 --- a/src/lib/BuildCommand.js +++ b/starfleet/data-cli/src/lib/BuildCommand.js @@ -1,15 +1,28 @@ -const Command = require('./Command'); -const PathResolver = require('./PathResolver'); -const { +/** + * @fileoverview BuildCommand - Base class for compilation/build operations + * + * Commands that transform or compile files without database interaction. + * Provides path resolution and file handling utilities with event-driven + * progress tracking for build operations. + * + * @module BuildCommand + * @requires Command + * @requires PathResolver + * @since 1.0.0 + */ + +import Command from './Command.js'; +import PathResolver from './PathResolver.js'; +import { BuildProgressEvent, BuildStartEvent, BuildCompleteEvent, BuildFailedEvent -} = require('./events/CommandEvents'); +} from './events/CommandEvents.js'; /** * BuildCommand - Base class for compilation/build operations - * + * * Commands that transform or compile files without database interaction. * Provides path resolution and file handling utilities. */ @@ -22,27 +35,21 @@ class BuildCommand extends Command { * @param {boolean} isProd - Whether running in production mode * @param {PathResolver} pathResolver - Optional PathResolver instance */ - constructor( - inputDir, - outputDir, - logger = null, - isProd = false, - pathResolver = null - ) { + constructor(inputDir, outputDir, logger = null, isProd = false, pathResolver = null) { // Call parent with minimal config super(null, logger, isProd, null); - + // Store paths this.inputDir = inputDir; this.outputDir = outputDir; - + // Path resolver for ensuring directories exist this.pathResolver = pathResolver || new PathResolver(); - + // Build operations typically don't need production confirmation this.requiresProductionConfirmation = false; } - + /** * Ensure input directory exists and is readable * @returns {Promise} Resolved input directory path @@ -50,7 +57,7 @@ class BuildCommand extends Command { getInputDir() { return this.pathResolver.resolveDirectoryForRead(this.inputDir); } - + /** * Ensure output directory exists and is writable * @returns {Promise} Resolved output directory path @@ -58,58 +65,54 @@ class BuildCommand extends Command { getOutputDir() { return this.pathResolver.resolveDirectoryForWrite(this.outputDir); } - + /** * Get a specific input file path * @param {string} filename - The filename relative to input dir * @returns {Promise} Resolved file path */ async getInputFile(filename) { - const path = require('path'); + const { join } = await import('path'); const dir = await this.getInputDir(); - return this.pathResolver.resolveFileForRead(path.join(dir, filename)); + return this.pathResolver.resolveFileForRead(join(dir, filename)); } - + /** * Get a specific output file path * @param {string} filename - The filename relative to output dir * @returns {Promise} Resolved file path */ async getOutputFile(filename) { - const path = require('path'); + const { join } = await import('path'); const dir = await this.getOutputDir(); - return this.pathResolver.resolveFileForWrite(path.join(dir, filename)); + return this.pathResolver.resolveFileForWrite(join(dir, filename)); } - + /** * List files in input directory * @param {string} pattern - Glob pattern (optional) * @returns {Promise} List of file paths */ async listInputFiles(pattern = '*') { - const glob = require('glob'); - const path = require('path'); + const { glob } = await import('glob'); + const { join } = await import('path'); const dir = await this.getInputDir(); - - return new Promise((resolve, reject) => { - glob(path.join(dir, pattern), (err, files) => { - if (err) reject(err); - else resolve(files); - }); - }); + + const files = await glob(join(dir, pattern)); + return files; } - + /** * Read a file from input directory * @param {string} filename - The filename to read * @returns {Promise} File contents */ async readInputFile(filename) { - const fs = require('fs').promises; + const fs = await import('fs/promises'); const filePath = await this.getInputFile(filename); return fs.readFile(filePath, 'utf8'); } - + /** * Write a file to output directory * @param {string} filename - The filename to write @@ -117,11 +120,11 @@ class BuildCommand extends Command { * @returns {Promise} */ async writeOutputFile(filename, content) { - const fs = require('fs').promises; + const fs = await import('fs/promises'); const filePath = await this.getOutputFile(filename); await fs.writeFile(filePath, content, 'utf8'); } - + /** * Emit build progress events * @param {string} stage - Current build stage @@ -131,7 +134,7 @@ class BuildCommand extends Command { const event = new BuildProgressEvent(stage, this.inputDir, this.outputDir, details); this.emit('build:progress', event.toEventData()); } - + /** * Emit build start event * @param {string} type - Type of build operation @@ -141,7 +144,7 @@ class BuildCommand extends Command { const event = new BuildStartEvent(type, this.inputDir, this.outputDir, details); this.emit('build:start', event.toEventData()); } - + /** * Emit build complete event * @param {Object} result - Build result details @@ -151,7 +154,7 @@ class BuildCommand extends Command { const event = new BuildCompleteEvent(result, details); this.emit('build:complete', event.toEventData()); } - + /** * Emit build failure event * @param {Error} error - The error that caused the build to fail @@ -163,4 +166,5 @@ class BuildCommand extends Command { } } -module.exports = BuildCommand; \ No newline at end of file +export { BuildCommand }; +export default BuildCommand; diff --git a/starfleet/data-cli/src/lib/Command.js b/starfleet/data-cli/src/lib/Command.js new file mode 100644 index 0000000..ceec6a5 --- /dev/null +++ b/starfleet/data-cli/src/lib/Command.js @@ -0,0 +1,416 @@ +/** + * @fileoverview Base Command Class for Event-Driven Architecture + * + * Provides a common foundation for all CLI commands with event emission, + * logging, production safety checks, and user interaction capabilities. + * All commands in the D.A.T.A. system extend from this base class. + * + * @module Command + * @requires EventEmitter + * @requires pino + * @since 1.0.0 + */ + +import { EventEmitter } from 'events'; +import pino from 'pino'; +import { + ProgressEvent, + WarningEvent, + ErrorEvent, + SuccessEvent, + StartEvent, + CompleteEvent, + CancelledEvent, + validateCommandEvent +} from './events/CommandEvents.js'; + +/** + * Base command class that all commands extend from. + * + * Provides event-driven architecture with production safety features, + * logging capabilities, and standardized user interaction patterns. + * + * @class + * @extends EventEmitter + * @example + * class MyCommand extends Command { + * async performExecute(options) { + * this.progress('Starting operation...'); + * // Do work here + * this.success('Operation completed!'); + * return result; + * } + * } + */ +class Command extends EventEmitter { + /** + * Creates a new Command instance. + * + * @param {Object|null} legacyConfig - Legacy configuration object (Config class instance) + * @param {Object|null} logger - Pino logger instance (optional, will create default if null) + * @param {boolean} isProd - Whether running in production mode (affects confirmation behavior) + * @param {Object|null} outputConfig - Output configuration for paths (OutputConfig class instance) + */ + constructor( + legacyConfig = null, // Config class instance is OK - it's a typed class + logger = null, + isProd = false, + outputConfig = null // OutputConfig class instance for paths + ) { + super(); + // Store the Config instance (this is fine - it's a proper class) + this.config = legacyConfig; + + // Logging and environment + this.isProd = isProd; + this.logger = logger || this.createLogger(); + + // Path configuration via dependency injection + this.outputConfig = outputConfig; + + // Command behavior flags + this.requiresProductionConfirmation = true; // Can be overridden by subclasses + } + + /** + * Creates a default pino logger with development-friendly configuration. + * + * @returns {Object} Configured pino logger instance + * @private + */ + createLogger() { + const isDev = process.env.NODE_ENV !== 'production'; + + return pino({ + level: this.config?.get ? this.config.get('logging.level') : 'info', + transport: isDev + ? { + target: 'pino-pretty', + options: { + colorize: true, + translateTime: 'HH:MM:ss', + ignore: 'pid,hostname' + } + } + : undefined + }); + } + + /** + * Executes the command with production safety checks and event emission. + * + * This is the main entry point for command execution. It handles: + * - Start event emission + * - Production confirmation (if required) + * - Delegation to performExecute() + * - Completion event emission + * - Error handling and cleanup + * + * @param {...*} args - Arguments to pass to performExecute() + * @returns {Promise<*>} Result from performExecute() or undefined if cancelled + * @throws {Error} Any error thrown by performExecute() + * @emits start - When command execution begins + * @emits complete - When command execution succeeds + * @emits cancelled - When command is cancelled by user + * @emits error - When command execution fails + */ + async execute(...args) { + // Emit start event + const startEvent = new StartEvent(`Starting ${this.constructor.name}`, { isProd: this.isProd }); + this.emit('start', { + message: startEvent.message, + data: startEvent.details, + timestamp: startEvent.timestamp, + type: startEvent.type, + isProd: this.isProd + }); + + try { + // Check for production confirmation if needed + if (this.isProd && this.requiresProductionConfirmation) { + const confirmed = await this.confirmProduction(); + if (!confirmed) { + this.success('Operation cancelled'); + const cancelledEvent = new CancelledEvent('Operation cancelled'); + this.emit('cancelled', { + message: cancelledEvent.message, + data: cancelledEvent.details, + timestamp: cancelledEvent.timestamp, + type: cancelledEvent.type + }); + return; + } + } + + // Call the actual implementation + const result = await this.performExecute(...args); + + // Emit completion event + const completeEvent = new CompleteEvent( + `${this.constructor.name} completed successfully`, + result + ); + this.emit('complete', { + message: completeEvent.message, + result: completeEvent.result, + data: completeEvent.details, + timestamp: completeEvent.timestamp, + type: completeEvent.type + }); + + return result; + } catch (error) { + this.error(`${this.constructor.name} failed`, error); + throw error; + } + } + + /** + * The actual execution logic that must be implemented by subclasses. + * + * This abstract method contains the core command logic. Subclasses must + * override this method to provide their specific functionality. + * + * @abstract + * @param {...*} args - Command-specific arguments + * @returns {Promise<*>} Command execution result + * @throws {Error} Must be implemented by subclass + */ + // eslint-disable-next-line require-await + async performExecute(..._args) { + throw new Error('Command.performExecute() must be implemented by subclass'); + } + + /** + * Prompts user to confirm production operation with safety warnings. + * + * Displays warning about production environment and requests explicit + * user confirmation before proceeding with potentially dangerous operations. + * + * @returns {Promise} True if user confirms, false otherwise + * @private + */ + async confirmProduction() { + this.warn('Production operation requested!', { + environment: 'PRODUCTION', + command: this.constructor.name + }); + + return this.confirm('Are you sure you want to perform this operation in PRODUCTION?'); + } + + /** + * Emits a progress event with optional data payload. + * + * Used to communicate ongoing operation status to event listeners, + * typically for progress bars or status updates in CLI interfaces. + * + * @param {string} message - Progress description + * @param {Object} [data={}] - Additional progress data + * @emits progress - Progress event with message and data + */ + progress(message, data = {}) { + const event = new ProgressEvent(message, null, data); // null percentage for indeterminate progress + // Emit typed event - maintain existing event object structure for backward compatibility + this.emit('progress', { + message: event.message, + data: event.details, + timestamp: event.timestamp, + type: event.type, + percentage: event.percentage + }); + this.logger.info({ ...data }, message); + } + + /** + * Emits a warning event for non-fatal issues. + * + * Used to communicate potential problems or important information + * that doesn't prevent command execution from continuing. + * + * @param {string} message - Warning message + * @param {Object} [data={}] - Additional warning context + * @emits warning - Warning event with message and data + */ + warn(message, data = {}) { + const event = new WarningEvent(message, data); + // Emit typed event - maintain existing event object structure for backward compatibility + this.emit('warning', { + message: event.message, + data: event.details, + timestamp: event.timestamp, + type: event.type + }); + this.logger.warn({ ...data }, message); + } + + /** + * Emits an error event for command failures. + * + * Used to communicate command execution errors with full context + * including error objects and additional debugging information. + * + * @param {string} message - Error description + * @param {Error|null} [error=null] - Error object with stack trace + * @param {Object} [data={}] - Additional error context + * @emits error - Error event with message, error object, and data + */ + error(message, error = null, data = {}) { + // Extract code from data if provided + const code = data.code || error?.code || null; + const event = new ErrorEvent(message, error, code, data); + // Emit typed event - maintain existing event object structure for backward compatibility + this.emit('error', { + message: event.message, + error: event.error, + data: event.details, + timestamp: event.timestamp, + type: event.type + }); + this.logger.error({ err: error, ...data }, message); + } + + /** + * Emits a success event for completed operations. + * + * Used to communicate successful command execution with result data + * for display in CLI interfaces or logging. + * + * @param {string} message - Success message + * @param {Object} [data={}] - Additional success data + * @emits success - Success event with message and data + */ + success(message, data = {}) { + const event = new SuccessEvent(message, data); + // Emit typed event - maintain existing event object structure for backward compatibility + this.emit('success', { + message: event.message, + data: event.details, + timestamp: event.timestamp, + type: event.type + }); + this.logger.info({ ...data }, message); + } + + /** + * Emits a prompt event and waits for user response. + * + * Creates an interactive prompt that waits for user input through + * the event system. Used by CLI interfaces for user interaction. + * + * @param {string} type - Type of prompt (confirm, input, select, etc.) + * @param {Object} options - Prompt configuration options + * @returns {Promise<*>} User response value + * @emits prompt - Prompt event with type, options, and resolve callback + */ + prompt(type, options) { + return new Promise((resolve) => { + this.emit('prompt', { type, options, resolve }); + }); + } + + /** + * Prompts user for yes/no confirmation. + * + * Convenience method for boolean confirmation prompts with + * optional default value handling. + * + * @param {string} message - Confirmation question + * @param {boolean} [defaultValue=false] - Default response if user presses enter + * @returns {Promise} True if confirmed, false otherwise + */ + async confirm(message, defaultValue = false) { + return this.prompt('confirm', { message, default: defaultValue }); + } + + /** + * Prompts user for text input. + * + * Convenience method for text input prompts with optional + * validation and default value handling. + * + * @param {string} message - Input prompt message + * @param {Object} [options={}] - Input options (default, validation, etc.) + * @returns {Promise} User input string + */ + async input(message, options = {}) { + return this.prompt('input', { message, ...options }); + } + + /** + * Validates an event object against expected class type using instanceof checks. + * + * Provides runtime type validation for event objects to ensure they conform + * to expected event class structures and contain required properties. + * + * @param {Object} event - The event object to validate + * @param {Function|null} [expectedClass=null] - Expected event class constructor for instanceof validation + * @returns {Object} Validation result object + * @returns {boolean} returns.success - True if validation passes + * @returns {string|null} returns.error - Error message if validation fails, null if success + * @example + * const result = command.validateEvent(progressEvent, ProgressEvent); + * if (!result.success) { + * console.error('Invalid event:', result.error); + * } + */ + validateEvent(event, expectedClass = null) { + if (!expectedClass) { + // If no specific class expected, just check if it has the basic event structure + return { + success: !!(event && event.type && event.message && event.timestamp), + error: + event && event.type && event.message && event.timestamp ? null : 'Invalid event structure' + }; + } + + try { + validateCommandEvent(event, expectedClass); + return { success: true, error: null }; + } catch (error) { + return { success: false, error: error.message }; + } + } + + /** + * Emits a typed event with optional validation and automatic format conversion. + * + * Provides event emission with runtime validation against expected class types + * and automatic conversion of CommandEvent instances to the standard event format + * required by the CLI interface for backward compatibility. + * + * @param {string} eventName - The event name to emit + * @param {Object} eventData - The event data or CommandEvent instance + * @param {Function|null} [expectedClass=null] - Optional expected event class for instanceof validation + * @emits eventName - The specified event with standardized format + * @example + * const progressEvent = new ProgressEvent('Processing...', 50); + * command.emitTypedEvent('progress', progressEvent, ProgressEvent); + */ + emitTypedEvent(eventName, eventData, expectedClass = null) { + const validation = this.validateEvent(eventData, expectedClass); + if (!validation.success) { + this.logger.warn( + { validationError: validation.error }, + `Invalid event data for ${eventName}` + ); + // Still emit the event for backward compatibility, but log the validation issue + } + + // If eventData is a CommandEvent instance, convert it to the expected format + if (eventData && typeof eventData.toJSON === 'function') { + const jsonData = eventData.toJSON(); + this.emit(eventName, { + message: jsonData.message, + data: jsonData.details || {}, + timestamp: new Date(jsonData.timestamp), + type: jsonData.type + }); + } else { + this.emit(eventName, eventData); + } + } +} + +export { Command }; +export default Command; diff --git a/src/lib/CommandRouter.js b/starfleet/data-cli/src/lib/CommandRouter.js similarity index 81% rename from src/lib/CommandRouter.js rename to starfleet/data-cli/src/lib/CommandRouter.js index 2691789..c257aa0 100644 --- a/src/lib/CommandRouter.js +++ b/starfleet/data-cli/src/lib/CommandRouter.js @@ -1,28 +1,41 @@ /** - * CommandRouter - Fluent routing system with Zod schema validation - * - * Example usage: - * const router = new CommandRouter(); - * const { z } = require('zod'); - * - * router - * .command("migrate") - * .subcommand("generate") - * .schema(z.object({ - * name: z.string().describe("Migration name"), - * type: z.enum(["up", "down", "both"]).default("up").describe("Migration type"), - * batchSize: z.number().min(1).max(1000).optional().describe("Records per batch"), - * verbose: z.boolean().default(false).describe("Enable verbose output"), - * outputDir: z.string().describe("Output directory") - * })) - * .handler(async (args) => { - * // args is fully typed and validated - * return new GenerateCommand().execute(args); - * }); + * @fileoverview CommandRouter - Fluent routing system with Zod schema validation + * + * Provides a type-safe, fluent API for command routing with automatic + * argument validation, help generation, and middleware support. Integrates + * with Zod schemas for runtime type safety and error reporting. + * + * @module CommandRouter + * @requires EventEmitter + * @requires zod + * @since 1.0.0 + * + * @example + * ```javascript + * import CommandRouter from './CommandRouter.js'; + * import { z } from 'zod'; + * + * const router = new CommandRouter(); + * + * router + * .command("migrate") + * .subcommand("generate") + * .schema(z.object({ + * name: z.string().describe("Migration name"), + * type: z.enum(["up", "down", "both"]).default("up").describe("Migration type"), + * batchSize: z.number().min(1).max(1000).optional().describe("Records per batch"), + * verbose: z.boolean().default(false).describe("Enable verbose output"), + * outputDir: z.string().describe("Output directory") + * })) + * .handler(async (args) => { + * // args is fully typed and validated + * return new GenerateCommand().execute(args); + * }); + * ``` */ -const EventEmitter = require('events'); -const { z } = require('zod'); +import { EventEmitter } from 'events'; +import { z } from 'zod'; class CommandRouter extends EventEmitter { constructor() { @@ -67,7 +80,7 @@ class CommandRouter extends EventEmitter { */ async execute(commandPath, rawArgs = {}) { const route = this.findRoute(commandPath); - + if (!route) { throw new Error(`No handler registered for command: ${commandPath}`); } @@ -88,38 +101,37 @@ class CommandRouter extends EventEmitter { try { // Run global middleware - await Promise.all(this.globalMiddleware.map(middleware => middleware(context))); + await Promise.all(this.globalMiddleware.map((middleware) => middleware(context))); // Parse and validate arguments with Zod schema let parsedArgs = rawArgs; if (route.schema) { // Convert CLI args to match schema shape const argsToValidate = this.prepareArgsForSchema(rawArgs, route); - + // Validate with Zod const result = await route.schema.safeParseAsync(argsToValidate); - + if (!result.success) { const errors = result.error.format(); this.showValidationErrors(commandPath, errors, route); throw new Error('Validation failed'); } - + parsedArgs = result.data; } context.args = parsedArgs; // Run route-specific middleware - await Promise.all(route.middleware.map(middleware => middleware(context))); + await Promise.all(route.middleware.map((middleware) => middleware(context))); // Execute the handler if (!route.handler) { throw new Error(`No handler defined for command: ${commandPath}`); } - return await route.handler(parsedArgs, context); - + return route.handler(parsedArgs, context); } catch (error) { this.emit('error', { path: commandPath, error }); throw error; @@ -133,14 +145,14 @@ class CommandRouter extends EventEmitter { */ prepareArgsForSchema(rawArgs, route) { const prepared = {}; - + for (const [key, value] of Object.entries(rawArgs)) { // Skip special args if (key === '_' || key === '$0') continue; - + // Convert --kebab-case to camelCase const propName = key.replace(/^-+/, '').replace(/-([a-z])/g, (g) => g[1].toUpperCase()); - + // Handle boolean flags (presence = true) if (value === true || value === undefined) { prepared[propName] = true; @@ -152,7 +164,7 @@ class CommandRouter extends EventEmitter { prepared[propName] = value; } } - + // Apply any custom mappings from route config if (route.argMappings) { for (const [from, to] of Object.entries(route.argMappings)) { @@ -161,7 +173,7 @@ class CommandRouter extends EventEmitter { } } } - + return prepared; } @@ -172,44 +184,44 @@ class CommandRouter extends EventEmitter { showHelp(commandPath, route) { const parts = commandPath.split('/'); const commandName = parts.join(' '); - + console.log(`\nUsage: data ${commandName} [OPTIONS]\n`); - + if (route.description) { console.log(`${route.description}\n`); } if (route.schema) { console.log('Options:'); - + // Extract schema shape for help generation const shape = route.schema._def.shape || route.schema.shape || {}; - + for (const [key, field] of Object.entries(shape)) { let line = ' '; - + // Convert camelCase to kebab-case for CLI - const cliName = key.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`); + const cliName = key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`); line += `--${cliName}`; - + // Get type from Zod schema const typeName = this.getZodTypeName(field); if (typeName !== 'boolean') { line += ` <${typeName}>`; } - + // Add description if available const description = field.description || field._def?.description; if (description) { line = line.padEnd(30) + description; } - + // Add constraints const constraints = this.getZodConstraints(field); if (constraints.length > 0) { line += ` (${constraints.join(', ')})`; } - + console.log(line); } } @@ -230,7 +242,7 @@ class CommandRouter extends EventEmitter { */ getZodTypeName(schema) { const def = schema._def; - + if (def.typeName === 'ZodString') return 'string'; if (def.typeName === 'ZodNumber') return 'number'; if (def.typeName === 'ZodBoolean') return 'boolean'; @@ -239,7 +251,7 @@ class CommandRouter extends EventEmitter { if (def.typeName === 'ZodOptional') return this.getZodTypeName(def.innerType); if (def.typeName === 'ZodDefault') return this.getZodTypeName(def.innerType); if (def.typeName === 'ZodNullable') return this.getZodTypeName(def.innerType); - + return 'value'; } @@ -250,20 +262,20 @@ class CommandRouter extends EventEmitter { getZodConstraints(schema) { const constraints = []; const def = schema._def; - + // Check if optional if (def.typeName === 'ZodOptional') { constraints.push('optional'); return [...constraints, ...this.getZodConstraints(def.innerType)]; } - + // Check for default if (def.typeName === 'ZodDefault') { const defaultValue = def.defaultValue(); constraints.push(`default: ${JSON.stringify(defaultValue)}`); return [...constraints, ...this.getZodConstraints(def.innerType)]; } - + // String constraints if (def.typeName === 'ZodString') { if (def.checks) { @@ -274,7 +286,7 @@ class CommandRouter extends EventEmitter { } } } - + // Number constraints if (def.typeName === 'ZodNumber') { if (def.checks) { @@ -285,12 +297,12 @@ class CommandRouter extends EventEmitter { } } } - + // Enum values if (def.typeName === 'ZodEnum') { constraints.push(`values: ${def.values.join(', ')}`); } - + return constraints; } @@ -300,17 +312,17 @@ class CommandRouter extends EventEmitter { */ showValidationErrors(commandPath, errors, _route) { console.error(`\nValidation errors for command: ${commandPath}\n`); - + // Remove the _errors property which is just metadata delete errors._errors; - + for (const [field, fieldErrors] of Object.entries(errors)) { if (fieldErrors._errors && fieldErrors._errors.length > 0) { - const cliName = field.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`); + const cliName = field.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`); console.error(` --${cliName}: ${fieldErrors._errors.join(', ')}`); } } - + console.error('\nRun with --help for usage information\n'); } @@ -448,21 +460,30 @@ class CommandBuilder { // It's a class - wrap it this.config.handler = async (args, context) => { const instance = new handler(context.router.config, context.router.logger, args.prod); - + // Forward events from subcommand to router if (instance.on) { - ['start', 'progress', 'warning', 'error', 'success', 'complete', 'failed', 'cancelled', 'prompt'] - .forEach(event => { - instance.on(event, (data) => context.router.emit(event, data)); - }); + [ + 'start', + 'progress', + 'warning', + 'error', + 'success', + 'complete', + 'failed', + 'cancelled', + 'prompt' + ].forEach((event) => { + instance.on(event, (data) => context.router.emit(event, data)); + }); } - - return await instance.execute(args); + + return instance.execute(args); }; } else { this.config.handler = handler; } - + this.router.registerRoute(this.path, this.config); return this.router; } @@ -481,62 +502,63 @@ class CommandBuilder { CommandRouter.schemas = { // Common CLI argument types port: z.number().int().min(1).max(65535), - + url: z.string().url(), - + email: z.string().email(), - + path: z.string(), - + existingPath: z.string().refine( - (val) => { - const fs = require('fs'); + async (val) => { try { - fs.accessSync(val); + const fs = await import('fs/promises'); + await fs.access(val); return true; } catch { return false; } }, - { message: "Path does not exist" } + { message: 'Path does not exist' } ), - + directory: z.string().refine( - (val) => { - const fs = require('fs'); + async (val) => { try { - const stats = fs.statSync(val); + const fs = await import('fs/promises'); + const stats = await fs.stat(val); return stats.isDirectory(); } catch { return false; } }, - { message: "Path must be a directory" } + { message: 'Path must be a directory' } ), - + file: z.string().refine( - (val) => { - const fs = require('fs'); + async (val) => { try { - const stats = fs.statSync(val); + const fs = await import('fs/promises'); + const stats = await fs.stat(val); return stats.isFile(); } catch { return false; } }, - { message: "Path must be a file" } + { message: 'Path must be a file' } ), - + // Common flag combinations - verbose: z.boolean().default(false).describe("Enable verbose output"), - - quiet: z.boolean().default(false).describe("Suppress output"), - - force: z.boolean().default(false).describe("Force operation without confirmation"), - - dryRun: z.boolean().default(false).describe("Preview changes without applying them"), - - prod: z.boolean().default(false).describe("Target production environment") + verbose: z.boolean().default(false).describe('Enable verbose output'), + + quiet: z.boolean().default(false).describe('Suppress output'), + + force: z.boolean().default(false).describe('Force operation without confirmation'), + + dryRun: z.boolean().default(false).describe('Preview changes without applying them'), + + prod: z.boolean().default(false).describe('Target production environment') }; -module.exports = CommandRouter; \ No newline at end of file +export { CommandRouter, CommandBuilder }; +export default CommandRouter; diff --git a/src/lib/DatabaseCommand.js b/starfleet/data-cli/src/lib/DatabaseCommand.js similarity index 88% rename from src/lib/DatabaseCommand.js rename to starfleet/data-cli/src/lib/DatabaseCommand.js index 23b169f..0890441 100644 --- a/src/lib/DatabaseCommand.js +++ b/starfleet/data-cli/src/lib/DatabaseCommand.js @@ -1,11 +1,15 @@ -const Command = require('./Command'); +import Command from './Command.js'; /** * DatabaseCommand - Base class for commands that interact with the database - * + * * This class provides database connection handling for commands that need * to execute SQL queries or manage database state. */ +/** + * DatabaseCommand class + * @class + */ class DatabaseCommand extends Command { /** * Create a DatabaseCommand instance @@ -26,31 +30,31 @@ class DatabaseCommand extends Command { ) { // Call parent with minimal config super(null, logger, isProd, null); - + // Store database credentials this.databaseUrl = databaseUrl; this.serviceRoleKey = serviceRoleKey; this.anonKey = anonKey; - + // Set confirmation requirement based on params this.requiresProductionConfirmation = isProd && requiresConfirmation; - + // Database connection will be created on demand this.db = null; } - + /** * Get database connection (lazy initialization) * @returns {Object} Database connection */ async getDatabase() { if (!this.db) { - const DatabaseUtils = require('./db-utils'); + const { default: DatabaseUtils } = await import('./db-utils.js'); this.db = await DatabaseUtils.createConnection(this.databaseUrl); } return this.db; } - + /** * Execute a SQL query * @param {string} sql - The SQL query to execute @@ -61,18 +65,18 @@ class DatabaseCommand extends Command { const db = await this.getDatabase(); return db.query(sql, params); } - + /** * Execute a SQL file * @param {string} filePath - Path to the SQL file * @returns {Promise} Query result */ async executeFile(filePath) { - const fs = require('fs').promises; + const { promises: fs } = await import('fs'); const sql = await fs.readFile(filePath, 'utf8'); return this.query(sql); } - + /** * Clean up database connection */ @@ -82,17 +86,18 @@ class DatabaseCommand extends Command { this.db = null; } } - + /** * Override execute to ensure cleanup */ async execute(...args) { try { - return await super.execute(...args); + return super.execute(...args); } finally { await this.cleanup(); } } } -module.exports = DatabaseCommand; \ No newline at end of file +export { DatabaseCommand }; +export default DatabaseCommand; diff --git a/src/lib/SupabaseCommand.js b/starfleet/data-cli/src/lib/SupabaseCommand.js similarity index 55% rename from src/lib/SupabaseCommand.js rename to starfleet/data-cli/src/lib/SupabaseCommand.js index 1e4b6d4..a884623 100644 --- a/src/lib/SupabaseCommand.js +++ b/starfleet/data-cli/src/lib/SupabaseCommand.js @@ -1,21 +1,63 @@ /** - * SupabaseCommand - Base class for commands that use Supabase API - * - * Replaces raw PostgreSQL connections with Supabase client - * Provides automatic connection management and cleanup + * @fileoverview SupabaseCommand - Base class for commands that use Supabase API + * + * Replaces raw PostgreSQL connections with Supabase client for better + * integration with modern PostgreSQL/Supabase ecosystems. Provides + * automatic connection management, cleanup, and schema utilities. + * + * @module SupabaseCommand + * @requires Command + * @requires @supabase/supabase-js + * @since 1.0.0 */ -const Command = require('./Command'); -const { createClient } = require('@supabase/supabase-js'); +import Command from './Command.js'; +import { createClient } from '@supabase/supabase-js'; +/** + * @typedef {Object} SqlExecutionResult + * @property {boolean} success - Whether SQL execution succeeded + * @property {string} [error] - Error message if execution failed + * @property {number} [rows_affected] - Number of rows affected by the operation + */ + +/** + * @typedef {Object} SchemaOperationOptions + * @property {boolean} [cascade=true] - Whether to use CASCADE when dropping objects + * @property {string} [schemaName] - Custom schema name for operations + */ + +/** + * Base class for commands that interact with Supabase/PostgreSQL databases. + * + * Extends the Command class with Supabase-specific functionality including + * client management, RPC execution, schema operations, and automatic cleanup. + * Uses lazy initialization for optimal resource usage. + * + * @class + * @extends Command + * @example + * class MyDatabaseCommand extends SupabaseCommand { + * async performExecute() { + * const supabase = this.getSupabase(); + * const { data } = await supabase.from('users').select('*'); + * return data; + * } + * } + */ class SupabaseCommand extends Command { /** - * Create a SupabaseCommand instance - * @param {string} supabaseUrl - Supabase project URL (optional, uses env var) - * @param {string} serviceRoleKey - Service role key for admin operations (optional, uses env var) - * @param {Object} logger - Logger instance (optional) - * @param {boolean} isProd - Whether running in production mode - * @param {boolean} requiresConfirmation - Whether to require confirmation in production (default: true) + * Creates a new SupabaseCommand instance with credentials and configuration. + * + * Initializes Supabase connection parameters with fallback to environment variables. + * Validates that at least one authentication key is available before proceeding. + * + * @param {string|null} [supabaseUrl=null] - Supabase project URL (falls back to SUPABASE_URL env var or localhost) + * @param {string|null} [serviceRoleKey=null] - Service role key for admin operations (falls back to env var) + * @param {Object|null} [logger=null] - Pino logger instance (optional) + * @param {boolean} [isProd=false] - Whether running in production mode + * @param {boolean} [requiresConfirmation=true] - Whether to require user confirmation in production + * @throws {Error} When neither SUPABASE_SERVICE_ROLE_KEY nor SUPABASE_ANON_KEY is available */ constructor( supabaseUrl = null, @@ -25,37 +67,49 @@ class SupabaseCommand extends Command { requiresConfirmation = true ) { super(null, logger, isProd, null); - + // Get Supabase credentials from params or environment this.supabaseUrl = supabaseUrl || process.env.SUPABASE_URL || 'http://localhost:54321'; this.serviceRoleKey = serviceRoleKey || process.env.SUPABASE_SERVICE_ROLE_KEY; this.anonKey = process.env.SUPABASE_ANON_KEY; - + // Validate we have necessary credentials if (!this.serviceRoleKey && !this.anonKey) { throw new Error('Either SUPABASE_SERVICE_ROLE_KEY or SUPABASE_ANON_KEY is required'); } - + // Set confirmation requirement this.requiresProductionConfirmation = isProd && requiresConfirmation; - + // Supabase client will be created on demand this.supabase = null; } - + /** - * Get Supabase client (lazy initialization) - * @param {boolean} useServiceRole - Use service role key (default: true) - * @returns {Object} Supabase client + * Gets or creates a Supabase client with lazy initialization. + * + * Creates the Supabase client on first access with appropriate authentication + * key based on the useServiceRole parameter. Configures client for optimal + * CLI usage with disabled session persistence and auto-refresh. + * + * @param {boolean} [useServiceRole=true] - Whether to use service role key (admin) or anon key (read-only) + * @returns {Object} Configured Supabase client instance + * @throws {Error} When required authentication key is not configured + * @example + * // Get admin client for DDL operations + * const supabase = this.getSupabase(true); + * + * // Get read-only client for queries + * const supabase = this.getSupabase(false); */ getSupabase(useServiceRole = true) { if (!this.supabase) { const key = useServiceRole ? this.serviceRoleKey : this.anonKey; - + if (!key) { throw new Error(`${useServiceRole ? 'Service role' : 'Anon'} key not configured`); } - + this.supabase = createClient(this.supabaseUrl, key, { auth: { persistSession: false, @@ -65,16 +119,16 @@ class SupabaseCommand extends Command { schema: 'public' } }); - + this.progress('Supabase client initialized'); } return this.supabase; } - + /** * Execute arbitrary SQL using Supabase RPC * Requires an exec_sql function in your database: - * + * * CREATE OR REPLACE FUNCTION exec_sql(sql text) * RETURNS json * LANGUAGE plpgsql @@ -94,39 +148,50 @@ class SupabaseCommand extends Command { */ async executeSql(sql) { const supabase = this.getSupabase(true); // Need service role for DDL - + const { data, error } = await supabase.rpc('exec_sql', { sql }); - + if (error) { throw new Error(`SQL execution failed: ${error.message}`); } - + if (data && !data.success) { throw new Error(`SQL error: ${data.error}`); } - + return data; } - + /** - * Call an RPC function - * @param {string} functionName - Name of the RPC function - * @param {Object} params - Parameters to pass to the function - * @param {boolean} useServiceRole - Use service role key (default: false for RPC) - * @returns {Promise} RPC result + * Executes a PostgreSQL RPC (Remote Procedure Call) function. + * + * Calls a stored procedure or function in the database through Supabase RPC interface. + * Automatically handles authentication and error processing. + * + * @param {string} functionName - Name of the PostgreSQL function to call + * @param {Object} [params={}] - Parameters to pass to the function as key-value pairs + * @param {boolean} [useServiceRole=false] - Whether to use service role for admin functions + * @returns {Promise<*>} Function return value (type depends on the PostgreSQL function) + * @throws {Error} When RPC call fails or function returns error + * @example + * // Call a custom function with parameters + * const result = await this.rpc('get_user_stats', { user_id: 123 }); + * + * // Call admin function with service role + * const result = await this.rpc('admin_cleanup', {}, true); */ async rpc(functionName, params = {}, useServiceRole = false) { const supabase = this.getSupabase(useServiceRole); - + const { data, error } = await supabase.rpc(functionName, params); - + if (error) { throw new Error(`RPC ${functionName} failed: ${error.message}`); } - + return data; } - + /** * Query a table using Supabase client * @param {string} table - Table name @@ -136,7 +201,7 @@ class SupabaseCommand extends Command { const supabase = this.getSupabase(); return supabase.from(table); } - + /** * Clean up Supabase connection */ @@ -145,30 +210,30 @@ class SupabaseCommand extends Command { try { // Sign out if authenticated await this.supabase.auth.signOut(); - + // Remove all realtime channels this.supabase.removeAllChannels(); - + this.progress('Supabase client cleaned up'); } catch (error) { this.warn(`Cleanup warning: ${error.message}`); } - + this.supabase = null; } } - + /** * Override execute to ensure cleanup */ async execute(...args) { try { - return await super.execute(...args); + return super.execute(...args); } finally { await this.cleanup(); } } - + /** * Helper to create a temporary schema for testing * @param {string} schemaName - Name for the schema (optional) @@ -176,13 +241,13 @@ class SupabaseCommand extends Command { */ async createTempSchema(schemaName = null) { const name = schemaName || `"@data.temp.${Math.floor(Date.now() / 1000)}"`; - + await this.executeSql(`CREATE SCHEMA IF NOT EXISTS ${name}`); this.success(`Created temporary schema: ${name}`); - + return name; } - + /** * Helper to drop a schema * @param {string} schemaName - Name of schema to drop @@ -190,11 +255,11 @@ class SupabaseCommand extends Command { */ async dropSchema(schemaName, cascade = true) { const cascadeClause = cascade ? 'CASCADE' : ''; - + await this.executeSql(`DROP SCHEMA IF EXISTS ${schemaName} ${cascadeClause}`); this.success(`Dropped schema: ${schemaName}`); } - + /** * Check if we have exec_sql function available * @returns {Promise} True if exec_sql exists @@ -202,16 +267,16 @@ class SupabaseCommand extends Command { async hasExecSqlFunction() { try { const supabase = this.getSupabase(true); - const { error } = await supabase.rpc('exec_sql', { - sql: 'SELECT 1' + const { error } = await supabase.rpc('exec_sql', { + sql: 'SELECT 1' }); - + return !error; } catch { return false; } } - + /** * Install exec_sql function if needed * This allows arbitrary SQL execution via RPC @@ -220,7 +285,7 @@ class SupabaseCommand extends Command { if (await this.hasExecSqlFunction()) { return; } - + this.warn('exec_sql function not found. You need to add it to your migrations:'); this.warn(` CREATE OR REPLACE FUNCTION exec_sql(sql text) @@ -239,9 +304,10 @@ EXCEPTION END; $$; `); - + throw new Error('exec_sql function required for DDL operations'); } } -module.exports = SupabaseCommand; \ No newline at end of file +export { SupabaseCommand }; +export default SupabaseCommand; diff --git a/src/lib/SupabaseTestCommand.js b/starfleet/data-cli/src/lib/SupabaseTestCommand.js similarity index 86% rename from src/lib/SupabaseTestCommand.js rename to starfleet/data-cli/src/lib/SupabaseTestCommand.js index 4cf5ea8..8261668 100644 --- a/src/lib/SupabaseTestCommand.js +++ b/starfleet/data-cli/src/lib/SupabaseTestCommand.js @@ -1,14 +1,21 @@ /** - * SupabaseTestCommand - Base class for test operations using Supabase API - * - * Replaces TestCommand's raw PostgreSQL with Supabase client + * @fileoverview SupabaseTestCommand - Base class for test operations using Supabase API + * + * Replaces TestCommand's raw PostgreSQL with Supabase client for better + * integration with modern PostgreSQL/Supabase ecosystems. Provides test + * compilation, execution, and TAP output parsing capabilities. + * + * @module SupabaseTestCommand + * @requires SupabaseCommand + * @requires PathResolver + * @since 1.0.0 */ -const SupabaseCommand = require('./SupabaseCommand'); -const PathResolver = require('./PathResolver'); -const fs = require('fs').promises; -const path = require('path'); -const { glob } = require('glob'); +import SupabaseCommand from './SupabaseCommand.js'; +import PathResolver from './PathResolver.js'; +import fs from 'fs/promises'; +import path from 'path'; +import { glob } from 'glob'; class SupabaseTestCommand extends SupabaseCommand { /** @@ -32,17 +39,19 @@ class SupabaseTestCommand extends SupabaseCommand { ) { // Call parent with Supabase config super(supabaseUrl, serviceRoleKey, logger, isProd, false); - + // Initialize path resolver - this.pathResolver = pathResolver || new PathResolver({ - testsDir: testsDir || path.join(process.cwd(), 'supabase', 'test'), - outputDir: outputDir || path.join(process.cwd(), 'supabase', 'test-output') - }); - + this.pathResolver = + pathResolver || + new PathResolver({ + testsDir: testsDir || path.join(process.cwd(), 'supabase', 'test'), + outputDir: outputDir || path.join(process.cwd(), 'supabase', 'test-output') + }); + // Store resolved paths this.testsDir = this.pathResolver.resolve('testsDir'); this.outputDir = this.pathResolver.resolve('outputDir'); - + // Test configuration this.testConfig = { timeout: 30000, @@ -50,7 +59,7 @@ class SupabaseTestCommand extends SupabaseCommand { maxConcurrency: 5 }; } - + /** * List test files in the tests directory * @param {string} pattern - Glob pattern (default: '**\/*.sql') @@ -62,7 +71,7 @@ class SupabaseTestCommand extends SupabaseCommand { const files = await glob(searchPattern); return files.sort(); } - + /** * Discover test functions in the database * @param {string} schema - Schema to search (default: 'test') @@ -77,20 +86,20 @@ class SupabaseTestCommand extends SupabaseCommand { AND routine_name LIKE '%test%' ORDER BY routine_name `; - + const result = await this.executeSql(sql.replace('$1', `'${schema}'`)); - + if (!result || !result.data) { return []; } - - return result.data.map(row => row.routine_name); + + return result.data.map((row) => row.routine_name); } catch (error) { this.warn(`Failed to discover test functions: ${error.message}`); return []; } } - + /** * Run a test function and get TAP output * @param {string} functionName - Name of test function @@ -103,9 +112,9 @@ class SupabaseTestCommand extends SupabaseCommand { if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(functionName)) { throw new Error(`Invalid function name: ${functionName}`); } - + const result = await this.rpc(functionName, {}, true); - + return { success: true, function: functionName, @@ -119,7 +128,7 @@ class SupabaseTestCommand extends SupabaseCommand { }; } } - + /** * Compile test files into a single migration * @param {Object} options - Compilation options @@ -127,54 +136,54 @@ class SupabaseTestCommand extends SupabaseCommand { */ async compileTests(_options = {}) { const testFiles = await this.listTestFiles(); - + if (testFiles.length === 0) { throw new Error('No test files found'); } - + let compiledSql = '-- Compiled test migration\n\n'; - + // Add pgTAP extension compiledSql += 'CREATE EXTENSION IF NOT EXISTS pgtap;\n\n'; - + // Compile each test file const filePromises = testFiles.map(async (filePath) => { const content = await fs.readFile(filePath, 'utf8'); const fileName = path.basename(filePath); - + return `-- Source: ${fileName}\n${content}\n\n`; }); - + const fileContents = await Promise.all(filePromises); compiledSql += fileContents.join(''); - + // Write to output const timestamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15); const outputFile = path.join(this.outputDir, `${timestamp}_compiled_tests.sql`); - + await fs.mkdir(this.outputDir, { recursive: true }); await fs.writeFile(outputFile, compiledSql); - + return { outputFile, filesCompiled: testFiles.length, size: compiledSql.length }; } - + /** * Create a temporary test schema * @returns {Promise} Schema name */ async createTestSchema() { const schemaName = `"@data.tests.${Math.floor(Date.now() / 1000)}"`; - + await this.executeSql(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`); this.success(`Created test schema: ${schemaName}`); - + return schemaName; } - + /** * Apply migration to test schema * @param {string} schemaName - Target schema @@ -182,18 +191,18 @@ class SupabaseTestCommand extends SupabaseCommand { */ async applyMigrationToSchema(schemaName, migrationFile) { const migrationSql = await fs.readFile(migrationFile, 'utf8'); - + // Wrap in schema context const wrappedSql = ` SET search_path TO ${schemaName}, public; ${migrationSql} SET search_path TO public; `; - + await this.executeSql(wrappedSql); this.success(`Applied migration to ${schemaName}`); } - + /** * Clean up test schema * @param {string} schemaName - Schema to drop @@ -201,7 +210,7 @@ class SupabaseTestCommand extends SupabaseCommand { async cleanupTestSchema(schemaName) { await this.dropSchema(schemaName, true); } - + /** * Parse TAP output * @param {Array|string} output - TAP output @@ -211,15 +220,15 @@ class SupabaseTestCommand extends SupabaseCommand { if (!output) { return { total: 0, passed: 0, failed: 0, skipped: 0 }; } - + const lines = Array.isArray(output) ? output : output.split('\n'); let passed = 0; let failed = 0; let skipped = 0; - + for (const line of lines) { const str = typeof line === 'object' ? JSON.stringify(line) : line; - + if (str.includes('ok ')) { passed++; } else if (str.includes('not ok ')) { @@ -228,7 +237,7 @@ class SupabaseTestCommand extends SupabaseCommand { skipped++; } } - + return { total: passed + failed + skipped, passed, @@ -238,4 +247,5 @@ class SupabaseTestCommand extends SupabaseCommand { } } -module.exports = SupabaseTestCommand; \ No newline at end of file +export { SupabaseTestCommand }; +export default SupabaseTestCommand; diff --git a/src/lib/TestCommand.js b/starfleet/data-cli/src/lib/TestCommand.js similarity index 85% rename from src/lib/TestCommand.js rename to starfleet/data-cli/src/lib/TestCommand.js index 28ff0da..f5b0f2f 100644 --- a/src/lib/TestCommand.js +++ b/starfleet/data-cli/src/lib/TestCommand.js @@ -1,12 +1,16 @@ -const DatabaseCommand = require('./DatabaseCommand'); -const PathResolver = require('./PathResolver'); +import DatabaseCommand from './DatabaseCommand.js'; +import PathResolver from './PathResolver.js'; /** * TestCommand - Base class for test operations - * + * * Commands that compile and run tests need both database access * and file system operations. */ +/** + * TestCommand class + * @class + */ class TestCommand extends DatabaseCommand { /** * Create a TestCommand instance @@ -29,70 +33,70 @@ class TestCommand extends DatabaseCommand { ) { // Call parent with database config super(databaseUrl, serviceRoleKey, null, logger, isProd); - + // Store test paths this.testsDir = testsDir; this.outputDir = outputDir; - + // Path resolver for ensuring directories exist this.pathResolver = pathResolver || new PathResolver(); - + // Test operations typically don't need production confirmation this.requiresProductionConfirmation = false; } - + /** * Ensure tests directory exists and is readable * @returns {Promise} Resolved tests directory path */ async getTestsDir() { - return await this.pathResolver.resolveDirectoryForRead(this.testsDir); + return this.pathResolver.resolveDirectoryForRead(this.testsDir); } - + /** * Ensure output directory exists and is writable * @returns {Promise} Resolved output directory path */ async getOutputDir() { - return await this.pathResolver.resolveDirectoryForWrite(this.outputDir); + return this.pathResolver.resolveDirectoryForWrite(this.outputDir); } - + /** * Get a specific test file path * @param {string} filename - The filename relative to tests dir * @returns {Promise} Resolved file path */ async getTestFile(filename) { - const path = require('path'); + const { join } = await import('path'); const dir = await this.getTestsDir(); - return await this.pathResolver.resolveFileForRead(path.join(dir, filename)); + return this.pathResolver.resolveFileForRead(join(dir, filename)); } - + /** * Get a specific output file path * @param {string} filename - The filename relative to output dir * @returns {Promise} Resolved file path */ async getOutputFile(filename) { - const path = require('path'); + const { join } = await import('path'); const dir = await this.getOutputDir(); - return await this.pathResolver.resolveFileForWrite(path.join(dir, filename)); + return this.pathResolver.resolveFileForWrite(join(dir, filename)); } - + /** * List test files * @param {string} pattern - Glob pattern (optional) * @returns {Promise} List of test file paths */ async listTestFiles(pattern = '*.sql') { - const fs = require('fs').promises; - const path = require('path'); + const { promises: fs } = await import('fs'); + const { join } = await import('path'); const dir = await this.getTestsDir(); - + try { const files = await fs.readdir(dir); return files - .filter(file => { + .filter((file) => { if (pattern === '*.sql') { return file.endsWith('.sql'); } @@ -103,30 +107,30 @@ class TestCommand extends DatabaseCommand { } return file.includes(pattern); }) - .map(file => path.join(dir, file)); + .map((file) => join(dir, file)); } catch (error) { throw new Error(`Failed to list test files in ${dir}: ${error.message}`); } } - + /** * Compile test files into a single migration * @returns {Promise} Compiled SQL content */ async compileTests() { - const fs = require('fs').promises; + const { promises: fs } = await import('fs'); const testFiles = await this.listTestFiles(); - + const readPromises = testFiles.map(async (file) => { const content = await fs.readFile(file, 'utf8'); return `-- Test file: ${file}\n${content}`; }); - + const contents = await Promise.all(readPromises); - + return contents.join('\n\n'); } - + /** * Run a test query and parse results * @param {string} sql - The test SQL to execute @@ -136,7 +140,7 @@ class TestCommand extends DatabaseCommand { const result = await this.query(sql); return this.parseTestResults(result); } - + /** * Parse pgTAP test results * @param {Object} queryResult - Raw query result @@ -151,9 +155,9 @@ class TestCommand extends DatabaseCommand { skipped: 0, tests: [] }; - + if (queryResult.rows) { - queryResult.rows.forEach(row => { + queryResult.rows.forEach((row) => { // Parse TAP output format const tapLine = row[Object.keys(row)[0]]; if (typeof tapLine === 'string') { @@ -170,10 +174,10 @@ class TestCommand extends DatabaseCommand { } }); } - + return results; } - + /** * Write test results to file * @param {Object} results - Test results @@ -182,9 +186,9 @@ class TestCommand extends DatabaseCommand { * @returns {Promise} */ async writeResults(results, filename, format = 'json') { - const fs = require('fs').promises; + const { promises: fs } = await import('fs'); const filePath = await this.getOutputFile(filename); - + let content; if (format === 'json') { content = JSON.stringify(results, null, 2); @@ -193,10 +197,10 @@ class TestCommand extends DatabaseCommand { } else { content = JSON.stringify(results); } - + await fs.writeFile(filePath, content, 'utf8'); } - + /** * Format results as JUnit XML * @param {Object} results - Test results @@ -205,8 +209,10 @@ class TestCommand extends DatabaseCommand { formatAsJUnit(results) { const xml = []; xml.push(''); - xml.push(``); - + xml.push( + `` + ); + results.tests.forEach((test, i) => { xml.push(` `); if (test.status === 'failed') { @@ -214,11 +220,11 @@ class TestCommand extends DatabaseCommand { } xml.push(' '); }); - + xml.push(''); return xml.join('\n'); } - + /** * Emit test progress events */ @@ -230,7 +236,7 @@ class TestCommand extends DatabaseCommand { ...details }); } - + /** * Emit test results */ @@ -242,4 +248,5 @@ class TestCommand extends DatabaseCommand { } } -module.exports = TestCommand; \ No newline at end of file +export { TestCommand }; +export default TestCommand; diff --git a/starfleet/data-cli/src/lib/events/CommandEvents.cjs b/starfleet/data-cli/src/lib/events/CommandEvents.cjs new file mode 100644 index 0000000..87d2691 --- /dev/null +++ b/starfleet/data-cli/src/lib/events/CommandEvents.cjs @@ -0,0 +1,658 @@ +/** + * @fileoverview Comprehensive Command Event System with Runtime Type Safety + * + * This module provides a complete event class hierarchy for the D.A.T.A. CLI system + * with runtime instanceof validation, zero dependencies, and pure JavaScript power. + * + * Key Features: + * - Runtime type safety via instanceof checks + * - Immutable event objects with structured data + * - Comprehensive JSDoc documentation + * - Zero Node.js dependencies (pure JavaScript) + * - Memory-efficient object design + * - Standardized JSON serialization + * + * @module CommandEvents + * @since 2.0.0 + * @author JavaScript Pro (via Claude Code) + */ + +'use strict'; + +// ============================================================================= +// BASE EVENT CLASS +// ============================================================================= + +/** + * @typedef {Object} EventDetails + * @property {string} [directoryName] - Name of directory being processed + * @property {number} [filesProcessed] - Count of files processed + * @property {number} [totalFiles] - Total number of files to process + * @property {Error} [error] - Error object if applicable + * @property {string} [code] - Error code for categorization + * @property {string} [phase] - Current operation phase + * @property {Array} [warnings] - List of warning messages + * @property {Object} [metadata] - Additional structured metadata + * @property {boolean} [isProd] - Whether running in production mode + * @property {*} [result] - Operation result data + */ + +/** + * Base class for all command events with immutable structure and runtime validation. + * + * Provides the foundation for the event-driven architecture with guaranteed type safety + * at runtime through instanceof checks. All events are immutable after construction + * and include standardized timestamp, type, and structured data fields. + * + * @class + * @abstract + * @example + * // Never instantiate directly - use subclasses + * const progress = new ProgressEvent('Processing files...', 45); + * if (progress instanceof CommandEvent) { + * console.log('Runtime type safety confirmed!'); + * } + */ +class CommandEvent { + /** + * Creates a new CommandEvent instance with immutable properties. + * + * @param {string} type - Event type identifier (must be non-empty string) + * @param {string} message - Human-readable message (must be non-empty string) + * @param {EventDetails} [details={}] - Additional structured data + * @throws {TypeError} When type or message are invalid + * @throws {Error} When attempting to instantiate base class directly + */ + constructor(type, message, details = {}) { + // Prevent direct instantiation of base class + if (this.constructor === CommandEvent) { + throw new Error('CommandEvent is abstract and cannot be instantiated directly'); + } + + // Runtime validation with helpful error messages + if (typeof type !== 'string' || type.trim().length === 0) { + throw new TypeError('Event type must be a non-empty string'); + } + + if (typeof message !== 'string' || message.trim().length === 0) { + throw new TypeError('Event message must be a non-empty string'); + } + + if (details !== null && (typeof details !== 'object' || Array.isArray(details))) { + throw new TypeError('Event details must be an object or null'); + } + + // Set properties for immutability - this is SOLID JavaScript design + Object.defineProperties(this, { + type: { + value: type.trim(), + writable: false, + enumerable: true, + configurable: false + }, + message: { + value: message.trim(), + writable: false, + enumerable: true, + configurable: false + }, + details: { + value: Object.freeze({ ...(details || {}) }), + writable: false, + enumerable: true, + configurable: false + }, + timestamp: { + value: Object.freeze(new Date()), + writable: false, + enumerable: true, + configurable: false + } + }); + + // Don't freeze here - let subclasses add their properties first + } + + /** + * Finalizes the event object by making it immutable. + * Called by subclasses after they've added their properties. + * + * @protected + */ + _freeze() { + Object.freeze(this); + } + + /** + * Converts event to JSON-serializable object. + * + * Provides standardized serialization for logging, API responses, + * and persistent storage while preserving all event data. + * + * @returns {Object} JSON-serializable representation + * @example + * const event = new ProgressEvent('Working...', 50); + * const json = event.toJSON(); + * // { type: 'progress', message: 'Working...', details: {...}, timestamp: '...' } + */ + toJSON() { + return { + type: this.type, + message: this.message, + details: this.details, + timestamp: this.timestamp.toISOString() + }; + } + + /** + * Returns string representation for debugging and logging. + * + * @returns {string} Human-readable event description + * @example + * console.log(event.toString()); // "ProgressEvent: Working... (50%)" + */ + toString() { + const className = this.constructor.name; + const timestamp = this.timestamp.toISOString(); + return `${className}: ${this.message} [${timestamp}]`; + } + + /** + * Checks if this event is of a specific type using instanceof. + * + * Provides runtime type checking that actually works at runtime, + * unlike TypeScript's compile-time only checking. + * + * @param {Function} EventClass - Event class constructor to check against + * @returns {boolean} True if event is instance of specified class + * @example + * if (event.isType(ProgressEvent)) { + * console.log(`Progress: ${event.percentage}%`); + * } + */ + isType(EventClass) { + return this instanceof EventClass; + } + + /** + * Creates a shallow clone with updated details. + * + * Since events are immutable, this provides a way to create + * modified versions while preserving the original event. + * + * @param {EventDetails} newDetails - Details to merge with existing + * @returns {CommandEvent} New event instance with merged details + * @example + * const updated = event.withDetails({ phase: 'complete' }); + */ + withDetails(newDetails = {}) { + const Constructor = this.constructor; + const mergedDetails = { ...this.details, ...newDetails }; + + // Handle special properties for subclass constructors + if (this.percentage !== undefined) { + return new Constructor(this.message, this.percentage, mergedDetails); + } + if (this.error !== undefined) { + return new Constructor(this.message, this.error, this.code, mergedDetails); + } + if (this.result !== undefined) { + return new Constructor(this.message, this.result, mergedDetails); + } + + return new Constructor(this.message, mergedDetails); + } +} + +// ============================================================================= +// CORE EVENT CLASSES +// ============================================================================= + +/** + * Progress event for long-running operations with optional percentage tracking. + * + * Used to communicate ongoing operation status with precise progress information. + * Supports both determinate (with percentage) and indeterminate progress reporting. + * + * @class + * @extends CommandEvent + * @example + * // Determinate progress + * const progress = new ProgressEvent('Processing files...', 45.5); + * + * // Indeterminate progress + * const working = new ProgressEvent('Analyzing data...', null, { phase: 'scan' }); + */ +class ProgressEvent extends CommandEvent { + /** + * Creates a new ProgressEvent instance. + * + * @param {string} message - Progress description + * @param {number|null} [percentage=null] - Completion percentage (0-100) or null for indeterminate + * @param {EventDetails} [details={}] - Additional progress context + * @throws {TypeError} When percentage is invalid number + */ + constructor(message, percentage = null, details = {}) { + super('progress', message, details); + + // Validate percentage if provided + if (percentage !== null) { + if (typeof percentage !== 'number' || isNaN(percentage) || percentage < 0 || percentage > 100) { + throw new TypeError('Percentage must be a number between 0 and 100, or null'); + } + } + + Object.defineProperty(this, 'percentage', { + value: percentage, + writable: false, + enumerable: true, + configurable: false + }); + + // Only freeze if this is the actual ProgressEvent, not a subclass + if (this.constructor === ProgressEvent) { + this._freeze(); + } + } + + /** + * Checks if this progress event has a defined percentage. + * + * @returns {boolean} True if percentage is available + */ + isDeterminate() { + return this.percentage !== null; + } + + /** + * Gets completion ratio as decimal (0.0 to 1.0). + * + * @returns {number|null} Completion ratio or null if indeterminate + */ + getRatio() { + return this.percentage !== null ? this.percentage / 100 : null; + } + + /** + * @override + */ + toJSON() { + return { + ...super.toJSON(), + percentage: this.percentage + }; + } + + /** + * @override + */ + toString() { + const base = super.toString(); + const progress = this.percentage !== null ? ` (${this.percentage}%)` : ' (indeterminate)'; + return base.replace(']', progress + ']'); + } +} + +/** + * Error event for operation failures with comprehensive error context. + * + * Provides structured error reporting with error objects, categorization codes, + * and additional debugging context. Supports both JavaScript Error objects + * and custom error information. + * + * @class + * @extends CommandEvent + * @example + * // With Error object + * const error = new ErrorEvent('Database connection failed', dbError, 'DB_CONNECT'); + * + * // With error details + * const validation = new ErrorEvent('Invalid input', null, 'VALIDATION', { + * field: 'email', + * reason: 'Invalid format' + * }); + */ +class ErrorEvent extends CommandEvent { + /** + * Creates a new ErrorEvent instance. + * + * @param {string} message - Error description + * @param {Error|null} [error=null] - The actual error object with stack trace + * @param {string|null} [code=null] - Error code for categorization + * @param {EventDetails} [details={}] - Additional error context + */ + constructor(message, error = null, code = null, details = {}) { + // Merge error info into details for structured access + const errorDetails = { ...details }; + if (error && error.code) { + errorDetails.originalCode = error.code; + } + if (error && error.stack) { + errorDetails.stack = error.stack; + } + if (code) { + errorDetails.code = code; + } + + super('error', message, errorDetails); + + Object.defineProperties(this, { + error: { + value: error, + writable: false, + enumerable: true, + configurable: false + }, + code: { + value: code, + writable: false, + enumerable: true, + configurable: false + } + }); + + // Only freeze if this is the actual ErrorEvent, not a subclass + if (this.constructor === ErrorEvent) { + this._freeze(); + } + } + + /** + * Checks if this error has a JavaScript Error object. + * + * @returns {boolean} True if error object is present + */ + hasErrorObject() { + return this.error instanceof Error; + } + + /** + * Gets the error stack trace if available. + * + * @returns {string|null} Stack trace or null + */ + getStackTrace() { + return this.error && this.error.stack ? this.error.stack : null; + } + + /** + * @override + */ + toJSON() { + return { + ...super.toJSON(), + error: this.error ? { + name: this.error.name, + message: this.error.message, + stack: this.error.stack + } : null, + code: this.code + }; + } +} + +/** + * Success event for completed operations with optional result data. + * + * Communicates successful command execution with structured result information + * for display, logging, or further processing. + * + * @class + * @extends CommandEvent + * @example + * const success = new SuccessEvent('Migration completed', { + * migrationsApplied: 3, + * tablesCreated: ['users', 'posts'], + * duration: 1250 + * }); + */ +class SuccessEvent extends CommandEvent { + /** + * Creates a new SuccessEvent instance. + * + * @param {string} message - Success message + * @param {EventDetails} [details={}] - Additional success data and context + */ + constructor(message, details = {}) { + super('success', message, details); + // Only freeze if this is the actual SuccessEvent, not a subclass + if (this.constructor === SuccessEvent) { + this._freeze(); + } + } + + /** + * Extracts result data from details if present. + * + * @returns {*} Result data or null + */ + getResult() { + return this.details.result || null; + } +} + +/** + * Warning event for non-fatal issues requiring attention. + * + * Used to communicate potential problems, deprecated usage, or important + * information that doesn't prevent command execution from continuing. + * + * @class + * @extends CommandEvent + * @example + * const warning = new WarningEvent('Using deprecated API', { + * api: 'v1/users', + * replacement: 'v2/users', + * deprecationDate: '2024-12-01' + * }); + */ +class WarningEvent extends CommandEvent { + /** + * Creates a new WarningEvent instance. + * + * @param {string} message - Warning message + * @param {EventDetails} [details={}] - Additional warning context + */ + constructor(message, details = {}) { + super('warning', message, details); + // Only freeze if this is the actual WarningEvent, not a subclass + if (this.constructor === WarningEvent) { + this._freeze(); + } + } + + /** + * Gets the warning severity level from details. + * + * @returns {string} Severity level ('low', 'medium', 'high', or 'unknown') + */ + getSeverity() { + return this.details.severity || 'unknown'; + } +} + +// ============================================================================= +// EXECUTION EVENT CLASSES +// ============================================================================= + +/** + * Start event emitted when command execution begins. + * + * Marks the beginning of command execution with environment and configuration context. + * + * @class + * @extends CommandEvent + * @example + * const start = new StartEvent('Starting DatabaseCommand', { isProd: false }); + */ +class StartEvent extends CommandEvent { + /** + * Creates a new StartEvent instance. + * + * @param {string} message - Start message + * @param {EventDetails} [details={}] - Execution context + */ + constructor(message, details = {}) { + super('start', message, details); + this._freeze(); + } +} + +/** + * Complete event emitted when command execution succeeds. + * + * Marks successful completion of command execution with final result data. + * + * @class + * @extends CommandEvent + * @example + * const complete = new CompleteEvent('Command completed', { rowsAffected: 42 }); + */ +class CompleteEvent extends CommandEvent { + /** + * Creates a new CompleteEvent instance. + * + * @param {string} message - Completion message + * @param {*} [result=null] - Command execution result + * @param {EventDetails} [details={}] - Additional completion context + */ + constructor(message, result = null, details = {}) { + const completeDetails = { ...details, result }; + super('complete', message, completeDetails); + + Object.defineProperty(this, 'result', { + value: result, + writable: false, + enumerable: true, + configurable: false + }); + + this._freeze(); + } +} + +/** + * Cancelled event emitted when command execution is cancelled by user. + * + * Marks user-initiated cancellation of command execution, typically due to + * production confirmation denial or explicit user interruption. + * + * @class + * @extends CommandEvent + * @example + * const cancelled = new CancelledEvent('User cancelled production operation'); + */ +class CancelledEvent extends CommandEvent { + /** + * Creates a new CancelledEvent instance. + * + * @param {string} message - Cancellation message + * @param {EventDetails} [details={}] - Cancellation context + */ + constructor(message, details = {}) { + super('cancelled', message, details); + this._freeze(); + } +} + +// ============================================================================= +// RUNTIME VALIDATION UTILITY +// ============================================================================= + +/** + * Validates an event object against expected class type using instanceof checks. + * + * Provides comprehensive runtime type validation for event objects to ensure + * they conform to expected event class structures and contain required properties. + * This is the heart of our runtime type safety system. + * + * @param {Object} event - The event object to validate + * @param {Function|null} [expectedClass=null] - Expected event class constructor for instanceof validation + * @throws {TypeError} When event fails validation + * @example + * try { + * validateCommandEvent(progressEvent, ProgressEvent); + * console.log('Event is valid!'); + * } catch (error) { + * console.error('Invalid event:', error.message); + * } + */ +function validateCommandEvent(event, expectedClass = null) { + // Basic structure validation + if (!event || typeof event !== 'object') { + throw new TypeError('Event must be an object'); + } + + if (!event.type || typeof event.type !== 'string') { + throw new TypeError('Event must have a valid type string'); + } + + if (!event.message || typeof event.message !== 'string') { + throw new TypeError('Event must have a valid message string'); + } + + if (!event.timestamp || !(event.timestamp instanceof Date)) { + throw new TypeError('Event must have a valid timestamp Date object'); + } + + // Specific class validation using instanceof - this is REAL runtime type safety + if (expectedClass) { + if (typeof expectedClass !== 'function') { + throw new TypeError('Expected class must be a constructor function'); + } + + if (!(event instanceof expectedClass)) { + throw new TypeError(`Event must be an instance of ${expectedClass.name}, got ${event.constructor.name}`); + } + + // Additional validation for specific event types + if (expectedClass === ProgressEvent) { + if (event.percentage !== null && (typeof event.percentage !== 'number' || + isNaN(event.percentage) || event.percentage < 0 || event.percentage > 100)) { + throw new TypeError('ProgressEvent percentage must be null or number between 0-100'); + } + } else if (expectedClass === ErrorEvent) { + if (event.error !== null && !(event.error instanceof Error)) { + throw new TypeError('ErrorEvent error must be null or Error instance'); + } + } + } + + // Validate that event is actually a CommandEvent + if (!(event instanceof CommandEvent)) { + throw new TypeError('Event must extend CommandEvent base class'); + } +} + +// ============================================================================= +// EXPORTS +// ============================================================================= + +module.exports = { + // Base class + CommandEvent, + + // Core events + ProgressEvent, + ErrorEvent, + SuccessEvent, + WarningEvent, + + // Execution events + StartEvent, + CompleteEvent, + CancelledEvent, + + // Validation utility + validateCommandEvent +}; + +// Export class hierarchy for instanceof checks +module.exports.CommandEvent = CommandEvent; +module.exports.ProgressEvent = ProgressEvent; +module.exports.ErrorEvent = ErrorEvent; +module.exports.SuccessEvent = SuccessEvent; +module.exports.WarningEvent = WarningEvent; +module.exports.StartEvent = StartEvent; +module.exports.CompleteEvent = CompleteEvent; +module.exports.CancelledEvent = CancelledEvent; \ No newline at end of file diff --git a/starfleet/data-cli/src/lib/events/MigrationEvents.cjs b/starfleet/data-cli/src/lib/events/MigrationEvents.cjs new file mode 100644 index 0000000..9a926ba --- /dev/null +++ b/starfleet/data-cli/src/lib/events/MigrationEvents.cjs @@ -0,0 +1,518 @@ +/** + * @fileoverview Migration-Specific Event Classes for Database Operations + * + * Specialized event classes for database migration operations including schema changes, + * data transformations, rollbacks, and migration lifecycle management. + * + * These events provide detailed context for migration operations with runtime type safety + * and comprehensive tracking of database state changes. + * + * @module MigrationEvents + * @requires CommandEvents + * @since 2.0.0 + * @author JavaScript Pro (via Claude Code) + */ + +'use strict'; + +const { + CommandEvent, + ProgressEvent, + ErrorEvent, + SuccessEvent, + WarningEvent +} = require('./CommandEvents.cjs'); + +// ============================================================================= +// MIGRATION LIFECYCLE EVENTS +// ============================================================================= + +/** + * @typedef {Object} MigrationDetails + * @property {string} [migrationId] - Unique migration identifier + * @property {string} [migrationName] - Human-readable migration name + * @property {string} [version] - Migration version number + * @property {string} [schema] - Target database schema + * @property {Array} [tables] - Tables affected by migration + * @property {Array} [operations] - List of operations performed + * @property {number} [estimatedDuration] - Expected duration in milliseconds + * @property {number} [actualDuration] - Actual duration in milliseconds + * @property {boolean} [isRollback] - Whether this is a rollback operation + * @property {string} [rollbackReason] - Reason for rollback if applicable + * @property {Object} [metadata] - Additional migration metadata + */ + +/** + * Event emitted when a database migration begins execution. + * + * Provides comprehensive context about the migration being executed, + * including affected tables, operations, and execution environment. + * + * @class + * @extends CommandEvent + * @example + * const migration = new MigrationStartEvent('Starting migration 001_create_users', { + * migrationId: '001', + * migrationName: 'create_users', + * tables: ['users'], + * operations: ['CREATE_TABLE', 'CREATE_INDEX'], + * schema: 'public' + * }); + */ +class MigrationStartEvent extends CommandEvent { + /** + * Creates a new MigrationStartEvent instance. + * + * @param {string} message - Migration start message + * @param {MigrationDetails} [details={}] - Migration context and metadata + */ + constructor(message, details = {}) { + super('migration_start', message, details); + + Object.defineProperties(this, { + migrationId: { + value: details.migrationId || null, + writable: false, + enumerable: true, + configurable: false + }, + operations: { + value: Object.freeze([...(details.operations || [])]), + writable: false, + enumerable: true, + configurable: false + } + }); + + this._freeze(); + } + + /** + * Checks if this migration affects specific tables. + * + * @param {Array} tableNames - Table names to check + * @returns {boolean} True if migration affects any of the specified tables + */ + affectsTables(tableNames) { + const migrationTables = this.details.tables || []; + return tableNames.some(table => migrationTables.includes(table)); + } + + /** + * Gets the estimated completion time. + * + * @returns {Date|null} Estimated completion time or null if unknown + */ + getEstimatedCompletion() { + if (!this.details.estimatedDuration) return null; + return new Date(this.timestamp.getTime() + this.details.estimatedDuration); + } +} + +/** + * Event emitted for individual migration steps or operations. + * + * Provides granular progress tracking for complex migrations with multiple + * database operations, allowing for detailed monitoring and debugging. + * + * @class + * @extends ProgressEvent + * @example + * const step = new MigrationStepEvent('Creating users table', 25, { + * operation: 'CREATE_TABLE', + * table: 'users', + * sql: 'CREATE TABLE users (id SERIAL PRIMARY KEY...)' + * }); + */ +class MigrationStepEvent extends ProgressEvent { + /** + * Creates a new MigrationStepEvent instance. + * + * @param {string} message - Step description + * @param {number|null} [percentage=null] - Step completion percentage + * @param {MigrationDetails} [details={}] - Step-specific details + */ + constructor(message, percentage = null, details = {}) { + super(message, percentage, details); + + Object.defineProperty(this, 'operation', { + value: details.operation || 'UNKNOWN', + writable: false, + enumerable: true, + configurable: false + }); + + this._freeze(); + } + + /** + * Gets the migration-specific event type. + * + * @returns {string} Migration step event type + */ + getEventType() { + return 'migration_step'; + } + + /** + * Checks if this step is a destructive operation. + * + * @returns {boolean} True if operation can cause data loss + */ + isDestructive() { + const destructiveOps = ['DROP_TABLE', 'DROP_COLUMN', 'DROP_INDEX', 'TRUNCATE', 'DELETE']; + return destructiveOps.includes(this.operation); + } + + /** + * Gets the SQL being executed if available. + * + * @returns {string|null} SQL statement or null + */ + getSQL() { + return this.details.sql || null; + } +} + +/** + * Event emitted when a migration completes successfully. + * + * Contains comprehensive results of the migration including tables created, + * data migrated, indexes built, and performance metrics. + * + * @class + * @extends SuccessEvent + * @example + * const complete = new MigrationCompleteEvent('Migration 001 completed', { + * migrationId: '001', + * actualDuration: 1250, + * tablesCreated: ['users'], + * indexesCreated: ['idx_users_email'], + * rowsMigrated: 0 + * }); + */ +class MigrationCompleteEvent extends SuccessEvent { + /** + * Creates a new MigrationCompleteEvent instance. + * + * @param {string} message - Completion message + * @param {MigrationDetails} [details={}] - Migration results and metrics + */ + constructor(message, details = {}) { + super(message, details); + + // Migration-specific event type available via getEventType() + + this._freeze(); + } + + /** + * Gets migration performance metrics. + * + * @returns {Object} Performance data + */ + getMetrics() { + return { + duration: this.details.actualDuration || 0, + tablesCreated: (this.details.tablesCreated || []).length, + indexesCreated: (this.details.indexesCreated || []).length, + rowsMigrated: this.details.rowsMigrated || 0, + estimatedVsActual: this.details.estimatedDuration ? + (this.details.actualDuration / this.details.estimatedDuration) : null + }; + } +} + +/** + * Event emitted when a migration fails. + * + * Provides detailed error context including the failing operation, + * database state, and recovery suggestions. + * + * @class + * @extends ErrorEvent + * @example + * const failed = new MigrationFailedEvent('Table creation failed', dbError, 'CREATE_TABLE', { + * migrationId: '001', + * operation: 'CREATE_TABLE', + * table: 'users', + * sql: 'CREATE TABLE...', + * canRollback: true + * }); + */ +class MigrationFailedEvent extends ErrorEvent { + /** + * Creates a new MigrationFailedEvent instance. + * + * @param {string} message - Failure message + * @param {Error|null} [error=null] - The database error + * @param {string|null} [code=null] - Error code + * @param {MigrationDetails} [details={}] - Failure context + */ + constructor(message, error = null, code = null, details = {}) { + super(message, error, code, details); + + // Migration-specific event type available via getEventType() + + this._freeze(); + } + + /** + * Checks if the migration can be safely rolled back. + * + * @returns {boolean} True if rollback is possible + */ + canRollback() { + return Boolean(this.details.canRollback); + } + + /** + * Gets suggested recovery actions. + * + * @returns {Array} List of recovery suggestions + */ + getRecoveryActions() { + return this.details.recoveryActions || [ + 'Check database connection', + 'Verify migration syntax', + 'Review database logs', + 'Consider manual rollback' + ]; + } +} + +// ============================================================================= +// ROLLBACK EVENTS +// ============================================================================= + +/** + * Event emitted when a migration rollback begins. + * + * Provides context about the rollback operation including the reason + * for rollback and affected database objects. + * + * @class + * @extends CommandEvent + * @example + * const rollback = new MigrationRollbackEvent('Rolling back migration 001', { + * migrationId: '001', + * rollbackReason: 'Deployment failed validation', + * affectedTables: ['users'], + * rollbackStrategy: 'DROP_TABLES' + * }); + */ +class MigrationRollbackEvent extends CommandEvent { + /** + * Creates a new MigrationRollbackEvent instance. + * + * @param {string} message - Rollback message + * @param {MigrationDetails} [details={}] - Rollback context + */ + constructor(message, details = {}) { + super('migration_rollback', message, details); + + Object.defineProperty(this, 'rollbackReason', { + value: details.rollbackReason || 'Unknown', + writable: false, + enumerable: true, + configurable: false + }); + + this._freeze(); + } + + /** + * Checks if rollback is due to a critical failure. + * + * @returns {boolean} True if rollback is due to critical issue + */ + isCritical() { + const criticalReasons = ['DATA_LOSS', 'CORRUPTION', 'SECURITY_BREACH']; + return criticalReasons.some(reason => + this.rollbackReason.toUpperCase().includes(reason) + ); + } +} + +// ============================================================================= +// VALIDATION AND SAFETY EVENTS +// ============================================================================= + +/** + * Event emitted when migration validation detects issues. + * + * Used for pre-migration checks, syntax validation, dependency verification, + * and production safety warnings. + * + * @class + * @extends WarningEvent + * @example + * const validation = new MigrationValidationEvent('Destructive operation detected', { + * validationType: 'SAFETY_CHECK', + * severity: 'high', + * operation: 'DROP_COLUMN', + * table: 'users', + * column: 'old_email' + * }); + */ +class MigrationValidationEvent extends WarningEvent { + /** + * Creates a new MigrationValidationEvent instance. + * + * @param {string} message - Validation warning message + * @param {MigrationDetails} [details={}] - Validation context + */ + constructor(message, details = {}) { + super(message, details); + + // Migration-specific event type available via getEventType() + + Object.defineProperty(this, 'validationType', { + value: details.validationType || 'GENERAL', + writable: false, + enumerable: true, + configurable: false + }); + + this._freeze(); + } + + /** + * Checks if validation should block migration execution. + * + * @returns {boolean} True if migration should be blocked + */ + shouldBlock() { + const blockingTypes = ['SYNTAX_ERROR', 'DEPENDENCY_MISSING', 'DATA_LOSS_RISK']; + const highSeverity = this.getSeverity() === 'high'; + const isBlockingType = blockingTypes.includes(this.validationType); + + return highSeverity && isBlockingType; + } +} + +// ============================================================================= +// SCHEMA DIFF EVENTS +// ============================================================================= + +/** + * Event emitted when schema differences are detected. + * + * Used during migration generation to report differences between + * current schema and target schema, including structural changes. + * + * @class + * @extends CommandEvent + * @example + * const diff = new SchemaDiffEvent('Schema changes detected', { + * additions: ['users.created_at'], + * modifications: ['users.email'], + * deletions: ['users.old_field'], + * impactLevel: 'medium' + * }); + */ +class SchemaDiffEvent extends CommandEvent { + /** + * Creates a new SchemaDiffEvent instance. + * + * @param {string} message - Schema diff message + * @param {Object} [details={}] - Schema change details + * @param {Array} [details.additions] - New schema objects + * @param {Array} [details.modifications] - Modified schema objects + * @param {Array} [details.deletions] - Removed schema objects + * @param {string} [details.impactLevel] - Change impact level + */ + constructor(message, details = {}) { + super('schema_diff', message, details); + + Object.defineProperties(this, { + additions: { + value: Object.freeze([...(details.additions || [])]), + writable: false, + enumerable: true, + configurable: false + }, + modifications: { + value: Object.freeze([...(details.modifications || [])]), + writable: false, + enumerable: true, + configurable: false + }, + deletions: { + value: Object.freeze([...(details.deletions || [])]), + writable: false, + enumerable: true, + configurable: false + } + }); + + this._freeze(); + } + + /** + * Gets total number of changes detected. + * + * @returns {number} Total change count + */ + getChangeCount() { + return this.additions.length + this.modifications.length + this.deletions.length; + } + + /** + * Checks if changes include destructive operations. + * + * @returns {boolean} True if any destructive changes detected + */ + hasDestructiveChanges() { + return this.deletions.length > 0 || + this.modifications.some(mod => mod.includes('DROP') || mod.includes('TRUNCATE')); + } + + /** + * Gets impact assessment of changes. + * + * @returns {Object} Impact analysis + */ + getImpactAnalysis() { + return { + level: this.details.impactLevel || 'unknown', + changeCount: this.getChangeCount(), + hasDestructive: this.hasDestructiveChanges(), + affectedObjects: [ + ...this.additions, + ...this.modifications, + ...this.deletions + ] + }; + } +} + +// ============================================================================= +// EXPORTS +// ============================================================================= + +module.exports = { + // Lifecycle events + MigrationStartEvent, + MigrationStepEvent, + MigrationCompleteEvent, + MigrationFailedEvent, + + // Rollback events + MigrationRollbackEvent, + + // Validation events + MigrationValidationEvent, + + // Schema events + SchemaDiffEvent +}; + +// Export for instanceof checks +module.exports.MigrationStartEvent = MigrationStartEvent; +module.exports.MigrationStepEvent = MigrationStepEvent; +module.exports.MigrationCompleteEvent = MigrationCompleteEvent; +module.exports.MigrationFailedEvent = MigrationFailedEvent; +module.exports.MigrationRollbackEvent = MigrationRollbackEvent; +module.exports.MigrationValidationEvent = MigrationValidationEvent; +module.exports.SchemaDiffEvent = SchemaDiffEvent; \ No newline at end of file diff --git a/starfleet/data-cli/src/lib/events/TestEvents.cjs b/starfleet/data-cli/src/lib/events/TestEvents.cjs new file mode 100644 index 0000000..c30a450 --- /dev/null +++ b/starfleet/data-cli/src/lib/events/TestEvents.cjs @@ -0,0 +1,672 @@ +/** + * @fileoverview Test-Specific Event Classes for pgTAP and Coverage Operations + * + * Specialized event classes for database testing operations including pgTAP test execution, + * coverage analysis, test discovery, and validation reporting. Provides comprehensive + * test lifecycle management with runtime type safety. + * + * These events support both unit-style database tests and integration testing workflows + * with detailed metrics and reporting capabilities. + * + * @module TestEvents + * @requires CommandEvents + * @since 2.0.0 + * @author JavaScript Pro (via Claude Code) + */ + +'use strict'; + +const { + CommandEvent, + ProgressEvent, + ErrorEvent, + SuccessEvent, + WarningEvent +} = require('./CommandEvents.cjs'); + +// ============================================================================= +// TEST EXECUTION EVENTS +// ============================================================================= + +/** + * @typedef {Object} TestDetails + * @property {string} [testSuite] - Name of test suite being executed + * @property {string} [testFile] - Path to test file + * @property {Array} [testNames] - Names of individual tests + * @property {number} [totalTests] - Total number of tests to run + * @property {number} [passedTests] - Number of tests that passed + * @property {number} [failedTests] - Number of tests that failed + * @property {number} [skippedTests] - Number of tests that were skipped + * @property {number} [duration] - Test execution duration in milliseconds + * @property {number} [coverage] - Code coverage percentage + * @property {Object} [coverageDetails] - Detailed coverage information + * @property {Array} [failures] - Details of failed tests + * @property {string} [framework] - Testing framework used (pgTAP, etc.) + * @property {boolean} [isIntegration] - Whether this is an integration test + * @property {string} [database] - Database being tested + * @property {string} [schema] - Schema being tested + */ + +/** + * Event emitted when a test run begins execution. + * + * Provides comprehensive context about the test execution including + * test suite information, expected test count, and execution environment. + * + * @class + * @extends CommandEvent + * @example + * const testRun = new TestRunEvent('Starting pgTAP test suite', { + * testSuite: 'user_management', + * testFile: 'tests/001_users.sql', + * totalTests: 15, + * framework: 'pgTAP', + * database: 'test_db', + * schema: 'public' + * }); + */ +class TestRunEvent extends CommandEvent { + /** + * Creates a new TestRunEvent instance. + * + * @param {string} message - Test run start message + * @param {TestDetails} [details={}] - Test execution context + */ + constructor(message, details = {}) { + super('test_run', message, details); + + Object.defineProperties(this, { + testSuite: { + value: details.testSuite || null, + writable: false, + enumerable: true, + configurable: false + }, + totalTests: { + value: details.totalTests || 0, + writable: false, + enumerable: true, + configurable: false + }, + framework: { + value: details.framework || 'unknown', + writable: false, + enumerable: true, + configurable: false + } + }); + + this._freeze(); + } + + /** + * Checks if this is a pgTAP test run. + * + * @returns {boolean} True if using pgTAP framework + */ + isPgTAP() { + return this.framework.toLowerCase() === 'pgtap'; + } + + /** + * Gets estimated completion time based on historical data. + * + * @param {number} [avgTimePerTest=500] - Average milliseconds per test + * @returns {Date|null} Estimated completion time + */ + getEstimatedCompletion(avgTimePerTest = 500) { + if (this.totalTests === 0) return null; + const estimatedDuration = this.totalTests * avgTimePerTest; + return new Date(this.timestamp.getTime() + estimatedDuration); + } +} + +/** + * Event emitted for individual test progress during execution. + * + * Provides real-time updates on test execution progress with details + * about current test, pass/fail status, and overall completion percentage. + * + * @class + * @extends ProgressEvent + * @example + * const progress = new TestProgressEvent('Running test: user_creation', 40, { + * currentTest: 'test_user_creation', + * testIndex: 6, + * totalTests: 15, + * passedSoFar: 5, + * failedSoFar: 1 + * }); + */ +class TestProgressEvent extends ProgressEvent { + /** + * Creates a new TestProgressEvent instance. + * + * @param {string} message - Current test description + * @param {number|null} [percentage=null] - Overall completion percentage + * @param {TestDetails} [details={}] - Test progress details + */ + constructor(message, percentage = null, details = {}) { + super(message, percentage, details); + + // Test-specific event type available via getEventType() + + Object.defineProperties(this, { + currentTest: { + value: details.currentTest || null, + writable: false, + enumerable: true, + configurable: false + }, + testIndex: { + value: details.testIndex || 0, + writable: false, + enumerable: true, + configurable: false + } + }); + + this._freeze(); + } + + /** + * Gets current test statistics. + * + * @returns {Object} Test execution statistics + */ + getStats() { + return { + current: this.testIndex, + total: this.details.totalTests || 0, + passed: this.details.passedSoFar || 0, + failed: this.details.failedSoFar || 0, + successRate: this.getSuccessRate() + }; + } + + /** + * Calculates current success rate. + * + * @returns {number} Success rate as percentage (0-100) + */ + getSuccessRate() { + const completed = (this.details.passedSoFar || 0) + (this.details.failedSoFar || 0); + if (completed === 0) return 0; + return Math.round((this.details.passedSoFar || 0) / completed * 100); + } +} + +/** + * Event emitted when test execution completes successfully. + * + * Contains comprehensive test results including pass/fail counts, + * execution time, coverage metrics, and detailed test outcomes. + * + * @class + * @extends SuccessEvent + * @example + * const result = new TestResultEvent('Test suite completed', { + * testSuite: 'user_management', + * totalTests: 15, + * passedTests: 13, + * failedTests: 2, + * skippedTests: 0, + * duration: 2340, + * coverage: 87.5, + * framework: 'pgTAP' + * }); + */ +class TestResultEvent extends SuccessEvent { + /** + * Creates a new TestResultEvent instance. + * + * @param {string} message - Test completion message + * @param {TestDetails} [details={}] - Test results and metrics + */ + constructor(message, details = {}) { + super(message, details); + + // Test-specific event type available via getEventType() + + this._freeze(); + } + + /** + * Calculates test success rate. + * + * @returns {number} Success rate as percentage (0-100) + */ + getSuccessRate() { + const total = this.details.totalTests || 0; + if (total === 0) return 0; + const passed = this.details.passedTests || 0; + return Math.round(passed / total * 100); + } + + /** + * Checks if all tests passed. + * + * @returns {boolean} True if no test failures + */ + allTestsPassed() { + return (this.details.failedTests || 0) === 0; + } + + /** + * Gets comprehensive test metrics. + * + * @returns {Object} Detailed test metrics + */ + getMetrics() { + const total = this.details.totalTests || 0; + const passed = this.details.passedTests || 0; + const failed = this.details.failedTests || 0; + const skipped = this.details.skippedTests || 0; + + return { + total, + passed, + failed, + skipped, + successRate: this.getSuccessRate(), + duration: this.details.duration || 0, + coverage: this.details.coverage || 0, + testsPerSecond: this.details.duration ? + Math.round(total / (this.details.duration / 1000) * 100) / 100 : 0 + }; + } + + /** + * Gets failure details if any tests failed. + * + * @returns {Array} Array of failure information + */ + getFailures() { + return this.details.failures || []; + } +} + +/** + * Event emitted when test execution fails catastrophically. + * + * Different from individual test failures - this represents system-level + * test execution problems like database connection failures, syntax errors, etc. + * + * @class + * @extends ErrorEvent + * @example + * const failed = new TestFailedEvent('Test execution failed', dbError, 'DB_CONNECTION', { + * testSuite: 'user_management', + * failurePoint: 'database_connection', + * testsCompleted: 3, + * totalTests: 15 + * }); + */ +class TestFailedEvent extends ErrorEvent { + /** + * Creates a new TestFailedEvent instance. + * + * @param {string} message - Test failure message + * @param {Error|null} [error=null] - The underlying error + * @param {string|null} [code=null] - Error classification code + * @param {TestDetails} [details={}] - Test failure context + */ + constructor(message, error = null, code = null, details = {}) { + super(message, error, code, details); + + // Test-specific event type available via getEventType() + + this._freeze(); + } + + /** + * Gets the point of failure in test execution. + * + * @returns {string} Failure point description + */ + getFailurePoint() { + return this.details.failurePoint || 'unknown'; + } + + /** + * Checks if tests can be retried safely. + * + * @returns {boolean} True if retry is possible + */ + canRetry() { + const retryableCodes = ['DB_CONNECTION', 'TIMEOUT', 'RESOURCE_BUSY']; + return retryableCodes.includes(this.code); + } +} + +// ============================================================================= +// COVERAGE EVENTS +// ============================================================================= + +/** + * @typedef {Object} CoverageDetails + * @property {number} [linesCovered] - Number of lines covered + * @property {number} [totalLines] - Total number of lines + * @property {number} [functionsCovered] - Number of functions covered + * @property {number} [totalFunctions] - Total number of functions + * @property {number} [branchesCovered] - Number of branches covered + * @property {number} [totalBranches] - Total number of branches + * @property {Object} [fileCoverage] - Per-file coverage details + * @property {Array} [uncoveredLines] - Lines without coverage + * @property {Array} [uncoveredFunctions] - Functions without coverage + * @property {number} [threshold] - Coverage threshold requirement + * @property {boolean} [meetsThreshold] - Whether coverage meets threshold + */ + +/** + * Event emitted when code coverage analysis completes. + * + * Provides detailed coverage metrics including line coverage, function coverage, + * branch coverage, and threshold compliance for database code. + * + * @class + * @extends CommandEvent + * @example + * const coverage = new CoverageEvent('Coverage analysis complete', { + * linesCovered: 234, + * totalLines: 280, + * functionsCovered: 18, + * totalFunctions: 22, + * threshold: 80, + * meetsThreshold: true + * }); + */ +class CoverageEvent extends CommandEvent { + /** + * Creates a new CoverageEvent instance. + * + * @param {string} message - Coverage analysis message + * @param {CoverageDetails} [details={}] - Coverage metrics and details + */ + constructor(message, details = {}) { + super('coverage', message, details); + + this._freeze(); + } + + /** + * Calculates line coverage percentage. + * + * @returns {number} Line coverage percentage (0-100) + */ + getLineCoverage() { + const total = this.details.totalLines || 0; + if (total === 0) return 0; + const covered = this.details.linesCovered || 0; + return Math.round(covered / total * 10000) / 100; // Two decimal places + } + + /** + * Calculates function coverage percentage. + * + * @returns {number} Function coverage percentage (0-100) + */ + getFunctionCoverage() { + const total = this.details.totalFunctions || 0; + if (total === 0) return 0; + const covered = this.details.functionsCovered || 0; + return Math.round(covered / total * 10000) / 100; + } + + /** + * Calculates branch coverage percentage. + * + * @returns {number} Branch coverage percentage (0-100) + */ + getBranchCoverage() { + const total = this.details.totalBranches || 0; + if (total === 0) return 0; + const covered = this.details.branchesCovered || 0; + return Math.round(covered / total * 10000) / 100; + } + + /** + * Gets overall coverage summary. + * + * @returns {Object} Comprehensive coverage metrics + */ + getSummary() { + return { + lines: { + covered: this.details.linesCovered || 0, + total: this.details.totalLines || 0, + percentage: this.getLineCoverage() + }, + functions: { + covered: this.details.functionsCovered || 0, + total: this.details.totalFunctions || 0, + percentage: this.getFunctionCoverage() + }, + branches: { + covered: this.details.branchesCovered || 0, + total: this.details.totalBranches || 0, + percentage: this.getBranchCoverage() + }, + threshold: this.details.threshold || 0, + meetsThreshold: Boolean(this.details.meetsThreshold), + overall: this.getLineCoverage() // Use line coverage as overall metric + }; + } + + /** + * Checks if coverage meets the required threshold. + * + * @returns {boolean} True if threshold is met + */ + meetsThreshold() { + return Boolean(this.details.meetsThreshold); + } + + /** + * Gets areas that need additional test coverage. + * + * @returns {Object} Coverage gaps information + */ + getCoverageGaps() { + return { + uncoveredLines: this.details.uncoveredLines || [], + uncoveredFunctions: this.details.uncoveredFunctions || [], + filesNeedingCoverage: this.getFilesNeedingCoverage() + }; + } + + /** + * Identifies files that need additional coverage. + * + * @returns {Array} Files with low coverage + */ + getFilesNeedingCoverage() { + const fileCoverage = this.details.fileCoverage || {}; + const threshold = this.details.threshold || 80; + + return Object.entries(fileCoverage) + .filter(([_, coverage]) => coverage < threshold) + .map(([file, coverage]) => ({ file, coverage, needed: threshold - coverage })) + .sort((a, b) => a.coverage - b.coverage); + } +} + +// ============================================================================= +// TEST DISCOVERY AND VALIDATION EVENTS +// ============================================================================= + +/** + * Event emitted when test discovery finds test files and functions. + * + * Reports discovered test files, test functions, and any issues + * with test structure or naming conventions. + * + * @class + * @extends CommandEvent + * @example + * const discovery = new TestDiscoveryEvent('Found 5 test files', { + * testFiles: ['001_users.sql', '002_posts.sql'], + * totalTests: 42, + * testsByFile: { '001_users.sql': 15, '002_posts.sql': 27 }, + * issues: ['Missing test plan in 003_comments.sql'] + * }); + */ +class TestDiscoveryEvent extends CommandEvent { + /** + * Creates a new TestDiscoveryEvent instance. + * + * @param {string} message - Discovery results message + * @param {Object} [details={}] - Discovery details + * @param {Array} [details.testFiles] - Discovered test files + * @param {number} [details.totalTests] - Total number of tests found + * @param {Object} [details.testsByFile] - Test count per file + * @param {Array} [details.issues] - Issues found during discovery + */ + constructor(message, details = {}) { + super('test_discovery', message, details); + + Object.defineProperty(this, 'testFiles', { + value: Object.freeze([...(details.testFiles || [])]), + writable: false, + enumerable: true, + configurable: false + }); + + this._freeze(); + } + + /** + * Gets the number of test files discovered. + * + * @returns {number} Test file count + */ + getFileCount() { + return this.testFiles.length; + } + + /** + * Gets the total number of tests across all files. + * + * @returns {number} Total test count + */ + getTotalTestCount() { + return this.details.totalTests || 0; + } + + /** + * Checks if any issues were found during discovery. + * + * @returns {boolean} True if issues were detected + */ + hasIssues() { + return (this.details.issues || []).length > 0; + } + + /** + * Gets detailed breakdown of tests per file. + * + * @returns {Array} Test distribution information + */ + getTestDistribution() { + const testsByFile = this.details.testsByFile || {}; + return this.testFiles.map(file => ({ + file, + testCount: testsByFile[file] || 0 + })); + } +} + +/** + * Event emitted when test validation detects problems. + * + * Used for validating pgTAP test structure, naming conventions, + * test plans, and other quality checks. + * + * @class + * @extends WarningEvent + * @example + * const validation = new TestValidationEvent('Test plan mismatch detected', { + * testFile: '001_users.sql', + * expectedTests: 15, + * actualTests: 13, + * severity: 'medium', + * validationType: 'TEST_PLAN' + * }); + */ +class TestValidationEvent extends WarningEvent { + /** + * Creates a new TestValidationEvent instance. + * + * @param {string} message - Validation warning message + * @param {TestDetails} [details={}] - Validation context + */ + constructor(message, details = {}) { + super(message, details); + + // Test-specific event type available via getEventType() + + Object.defineProperty(this, 'validationType', { + value: details.validationType || 'GENERAL', + writable: false, + enumerable: true, + configurable: false + }); + + this._freeze(); + } + + /** + * Checks if validation issue should block test execution. + * + * @returns {boolean} True if tests should not run + */ + shouldBlockExecution() { + const blockingTypes = ['SYNTAX_ERROR', 'MISSING_DEPENDENCY', 'INVALID_STRUCTURE']; + const highSeverity = this.getSeverity() === 'high'; + return blockingTypes.includes(this.validationType) && highSeverity; + } + + /** + * Gets suggested fixes for the validation issue. + * + * @returns {Array} List of suggested fixes + */ + getSuggestedFixes() { + const fixes = { + 'TEST_PLAN': ['Update test plan count', 'Add missing tests', 'Remove extra tests'], + 'NAMING': ['Follow pgTAP naming conventions', 'Use descriptive test names'], + 'STRUCTURE': ['Add proper test setup', 'Include test teardown', 'Fix test organization'], + 'SYNTAX_ERROR': ['Check SQL syntax', 'Verify pgTAP function usage', 'Fix test assertions'] + }; + + return fixes[this.validationType] || ['Review test documentation', 'Check test best practices']; + } +} + +// ============================================================================= +// EXPORTS +// ============================================================================= + +module.exports = { + // Test execution events + TestRunEvent, + TestProgressEvent, + TestResultEvent, + TestFailedEvent, + + // Coverage events + CoverageEvent, + + // Discovery and validation events + TestDiscoveryEvent, + TestValidationEvent +}; + +// Export for instanceof checks +module.exports.TestRunEvent = TestRunEvent; +module.exports.TestProgressEvent = TestProgressEvent; +module.exports.TestResultEvent = TestResultEvent; +module.exports.TestFailedEvent = TestFailedEvent; +module.exports.CoverageEvent = CoverageEvent; +module.exports.TestDiscoveryEvent = TestDiscoveryEvent; +module.exports.TestValidationEvent = TestValidationEvent; \ No newline at end of file diff --git a/starfleet/data-cli/src/lib/events/demo.js b/starfleet/data-cli/src/lib/events/demo.js new file mode 100755 index 0000000..7c36f2b --- /dev/null +++ b/starfleet/data-cli/src/lib/events/demo.js @@ -0,0 +1,330 @@ +#!/usr/bin/env node +/** + * @fileoverview Runtime Type Safety Demonstration - JavaScript Event Classes + * + * This demonstration shows off the power of runtime instanceof validation + * in pure JavaScript without TypeScript compilation overhead. Watch as we + * create, validate, and manipulate events with complete type safety. + * + * Run with: node src/lib/events/demo.js + * + * @author JavaScript Pro (via Claude Code) + */ + +'use strict'; + +import { + ProgressEvent, + ErrorEvent, + MigrationStartEvent, + TestResultEvent, + CoverageEvent, + validateEvent, + isEventType, + createTypeGuard, + getEventHierarchy, + EventFactory +} from './index.js'; + +// ============================================================================= +// DEMONSTRATION FUNCTIONS +// ============================================================================= + +/** + * Demonstrates basic event creation and validation. + */ +function demonstrateBasicEvents() { + console.log('\n๐Ÿš€ === BASIC EVENT CREATION AND VALIDATION ===\n'); + + try { + // Create a progress event + const progress = new ProgressEvent('Processing database migration...', 45.5, { + phase: 'schema_validation', + tablesProcessed: 3, + totalTables: 7 + }); + + console.log('โœ… Created ProgressEvent:', progress.toString()); + console.log('๐Ÿ“Š Progress:', `${progress.percentage}%`); + console.log('๐Ÿ”„ Is determinate:', progress.isDeterminate()); + console.log('๐Ÿ“ˆ Completion ratio:', progress.getRatio()); + + // Runtime instanceof validation - THIS ACTUALLY WORKS! + if (progress instanceof ProgressEvent) { + console.log('๐ŸŽฏ Runtime type check PASSED: instanceof ProgressEvent'); + } + + // Create an error event with full context + const dbError = new Error('Connection timeout'); + dbError.code = 'ETIMEDOUT'; + + const error = new ErrorEvent( + 'Database connection failed during migration', + dbError, + 'DB_CONNECTION_FAILED', + { + host: 'localhost', + port: 5432, + database: 'test_migrations', + retryCount: 3 + } + ); + + console.log('โŒ Created ErrorEvent:', error.toString()); + console.log('๐Ÿ” Has error object:', error.hasErrorObject()); + console.log('๐Ÿ“‹ Error code:', error.code); + console.log('๐Ÿ”ข Original error code:', error.error.code); + } catch (err) { + console.error('๐Ÿ’ฅ Demonstration failed:', err.message); + } +} + +/** + * Demonstrates migration-specific events. + */ +function demonstrateMigrationEvents() { + console.log('\n๐Ÿ—„๏ธ === MIGRATION EVENT LIFECYCLE ===\n'); + + try { + // Migration starts + const migrationStart = new MigrationStartEvent('Starting migration 004_add_user_preferences', { + migrationId: '004', + migrationName: 'add_user_preferences', + version: '1.4.0', + tables: ['users', 'user_preferences'], + operations: ['CREATE_TABLE', 'ALTER_TABLE', 'CREATE_INDEX'], + estimatedDuration: 15000, + schema: 'public' + }); + + console.log('๐ŸŽฌ Migration started:', migrationStart.toString()); + console.log('๐ŸŽฏ Migration ID:', migrationStart.migrationId); + console.log('๐Ÿ—๏ธ Operations:', migrationStart.operations.join(', ')); + console.log('โฐ Estimated completion:', migrationStart.getEstimatedCompletion()); + console.log('๐Ÿ“Š Affects user tables:', migrationStart.affectsTables(['users', 'profiles'])); + + // Runtime validation of migration event + validateEvent(migrationStart, MigrationStartEvent); + console.log('โœ… Migration event validation PASSED'); + } catch (err) { + console.error('๐Ÿ’ฅ Migration demonstration failed:', err.message); + } +} + +/** + * Demonstrates test execution events. + */ +function demonstrateTestEvents() { + console.log('\n๐Ÿงช === TEST EXECUTION EVENTS ===\n'); + + try { + // Test results + const testResults = new TestResultEvent('User management test suite completed', { + testSuite: 'user_management', + totalTests: 42, + passedTests: 38, + failedTests: 3, + skippedTests: 1, + duration: 2340, + coverage: 87.5, + framework: 'pgTAP', + failures: [ + { test: 'test_user_deletion', reason: 'Foreign key constraint' }, + { test: 'test_email_validation', reason: 'Invalid regex pattern' } + ] + }); + + console.log('๐ŸŽฏ Test completed:', testResults.toString()); + console.log('๐Ÿ“ˆ Success rate:', `${testResults.getSuccessRate()}%`); + console.log('โœ… All tests passed:', testResults.allTestsPassed()); + + const metrics = testResults.getMetrics(); + console.log('๐Ÿ“Š Test metrics:', { + total: metrics.total, + passed: metrics.passed, + failed: metrics.failed, + duration: `${metrics.duration}ms`, + coverage: `${metrics.coverage}%`, + speed: `${metrics.testsPerSecond} tests/sec` + }); + + console.log('๐Ÿ”ฅ Failures:', testResults.getFailures().length); + + // Coverage analysis + const coverage = new CoverageEvent('Code coverage analysis completed', { + linesCovered: 1847, + totalLines: 2156, + functionsCovered: 89, + totalFunctions: 103, + branchesCovered: 234, + totalBranches: 267, + threshold: 80, + meetsThreshold: true + }); + + console.log('๐Ÿ“ Coverage analysis:', coverage.toString()); + console.log('๐Ÿ“ˆ Line coverage:', `${coverage.getLineCoverage()}%`); + console.log('๐ŸŽฏ Function coverage:', `${coverage.getFunctionCoverage()}%`); + console.log('๐Ÿ”€ Branch coverage:', `${coverage.getBranchCoverage()}%`); + console.log('โœ… Meets threshold:', coverage.meetsThreshold()); + + const summary = coverage.getSummary(); + console.log('๐Ÿ“Š Coverage summary:', { + overall: `${summary.overall}%`, + threshold: `${summary.threshold}%`, + meetsThreshold: summary.meetsThreshold + }); + } catch (err) { + console.error('๐Ÿ’ฅ Test demonstration failed:', err.message); + } +} + +/** + * Demonstrates runtime type checking utilities. + */ +function demonstrateTypeChecking() { + console.log('\n๐Ÿ” === RUNTIME TYPE CHECKING MAGIC ===\n'); + + const events = [ + new ProgressEvent('Loading...', 25), + new ErrorEvent('Something went wrong', new Error('Test error')), + new MigrationStartEvent('Starting migration', { migrationId: '001' }), + new TestResultEvent('Tests done', { totalTests: 10, passedTests: 10 }) + ]; + + console.log('๐ŸŽฏ Created mixed event array with', events.length, 'events'); + + // Type checking with isEventType + events.forEach((event, index) => { + console.log(`\n๐Ÿ“‹ Event ${index + 1}:`); + console.log(' Type:', event.constructor.name); + console.log(' Message:', event.message); + console.log(' Is ProgressEvent:', isEventType(event, ProgressEvent)); + console.log(' Is ErrorEvent:', isEventType(event, ErrorEvent)); + console.log( + ' Is Migration/Test event:', + isEventType(event, [MigrationStartEvent, TestResultEvent]) + ); + }); + + // Type guards in action + const isProgress = createTypeGuard(ProgressEvent); + const progressEvents = events.filter(isProgress); + console.log('\n๐ŸŽฏ Found', progressEvents.length, 'progress events using type guard'); + + // Event hierarchy analysis + events.forEach((event, index) => { + const hierarchy = getEventHierarchy(event); + console.log(`\n๐Ÿ—๏ธ Event ${index + 1} hierarchy:`, hierarchy.join(' โ†’ ')); + }); +} + +/** + * Demonstrates advanced validation scenarios. + */ +function demonstrateAdvancedValidation() { + console.log('\n๐Ÿ›ก๏ธ === ADVANCED VALIDATION SCENARIOS ===\n'); + + try { + // Valid event + const validEvent = EventFactory.progress('Processing...', 75, { phase: 'final' }); + console.log('โœ… Factory created valid event:', validEvent.constructor.name); + + // Validate with strict mode + const strictResult = validateEvent(validEvent, ProgressEvent, { + strict: true, + throwOnError: false + }); + console.log('๐Ÿ” Strict validation result:', strictResult.valid ? 'PASSED' : 'FAILED'); + + // Test invalid percentage + try { + new ProgressEvent('Invalid progress', 150); // Over 100% + } catch (error) { + console.log('โŒ Caught invalid percentage error:', error.message); + } + + // Test multiple type validation + const mixedTypes = [ProgressEvent, ErrorEvent]; + const testEvent = new ProgressEvent('Test', 50); + const multiResult = validateEvent(testEvent, mixedTypes, { throwOnError: false }); + console.log('๐ŸŽฏ Multi-type validation:', multiResult.valid ? 'PASSED' : 'FAILED'); + + // Event immutability test + const immutableEvent = new ProgressEvent('Immutable test', 25); + console.log('๐Ÿ”’ Event is frozen (immutable):', Object.isFrozen(immutableEvent)); + + try { + immutableEvent.message = 'Try to change this'; // Should fail silently or throw + console.log('๐Ÿ›ก๏ธ Immutability preserved - message unchanged:', immutableEvent.message); + } catch (error) { + console.log('๐Ÿ” Immutability enforced:', error.message); + } + } catch (err) { + console.error('๐Ÿ’ฅ Advanced validation failed:', err.message); + } +} + +/** + * Demonstrates event serialization and JSON handling. + */ +function demonstrateEventSerialization() { + console.log('\n๐Ÿ“ค === EVENT SERIALIZATION AND JSON ===\n'); + + try { + const event = new MigrationStartEvent('Complex migration with rich data', { + migrationId: '007', + operations: ['CREATE_TABLE', 'CREATE_INDEX'], + metadata: { priority: 'high', category: 'schema' } + }); + + // JSON serialization + const json = event.toJSON(); + console.log('๐Ÿ“„ Event JSON:', JSON.stringify(json, null, 2)); + + // Verify JSON structure + console.log('โœ… JSON has type:', Boolean(json.type)); + console.log('โœ… JSON has message:', Boolean(json.message)); + console.log('โœ… JSON has timestamp:', Boolean(json.timestamp)); + console.log('โœ… JSON has details:', Boolean(json.details)); + + // String representation + console.log('๐Ÿ”ค String representation:', event.toString()); + + // Demonstrate event cloning with new details + const updatedEvent = event.withDetails({ phase: 'execution', progress: 0.5 }); + console.log('๐Ÿ”„ Cloned event with updates:', updatedEvent.toString()); + console.log('๐Ÿ”’ Original event unchanged:', event.details.phase === undefined); + console.log('โœจ New event has updates:', updatedEvent.details.phase === 'execution'); + } catch (err) { + console.error('๐Ÿ’ฅ Serialization demonstration failed:', err.message); + } +} + +// ============================================================================= +// MAIN DEMONSTRATION +// ============================================================================= + +function runDemonstration() { + console.log('๐ŸŽ‰ === JAVASCRIPT EVENT CLASSES - RUNTIME TYPE SAFETY DEMO ==='); + console.log('๐Ÿ“ Demonstrating instanceof validation, immutability, and zero-dependency events\n'); + + demonstrateBasicEvents(); + demonstrateMigrationEvents(); + demonstrateTestEvents(); + demonstrateTypeChecking(); + demonstrateAdvancedValidation(); + demonstrateEventSerialization(); + + console.log('\n๐ŸŽฏ === DEMONSTRATION COMPLETE ==='); + console.log('๐Ÿ’ช JavaScript events with runtime type safety - NO TYPESCRIPT REQUIRED!'); + console.log('๐Ÿš€ Zero build step, zero dependencies, 100% runtime validation'); + console.log('โšก This is the power of PHENOMENAL JavaScript!\n'); +} + +// Run demo if this file is executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + runDemonstration(); +} + +export { runDemonstration }; diff --git a/starfleet/data-cli/src/lib/events/index.js b/starfleet/data-cli/src/lib/events/index.js new file mode 100644 index 0000000..423bbbb --- /dev/null +++ b/starfleet/data-cli/src/lib/events/index.js @@ -0,0 +1,429 @@ +/** + * @fileoverview Comprehensive Event System Index - Runtime Type Safety for D.A.T.A. CLI + * + * Central export point for the complete event class hierarchy with instanceof validation, + * zero dependencies, and phenomenal JavaScript runtime type safety. + * + * This module provides: + * - All event classes with runtime validation + * - Type checking utilities + * - Event factory functions + * - Category-based imports + * - Complete TypeScript-like safety without TypeScript + * + * @module Events + * @since 2.0.0 + * @author JavaScript Pro (via Claude Code) + * @example + * // Import all events + * import { ProgressEvent, MigrationStartEvent, TestResultEvent } from './events/index.js'; + * + * // Import by category + * import { CommandEvents, MigrationEvents, TestEvents } from './events/index.js'; + * + * // Runtime validation + * import { validateEvent, isEventType } from './events/index.js'; + */ + +'use strict'; + +// ============================================================================= +// CORE EVENT SYSTEM IMPORTS +// ============================================================================= + +import CommandEvents from './CommandEvents.cjs'; +import MigrationEvents from './MigrationEvents.cjs'; +import TestEvents from './TestEvents.cjs'; + +// ============================================================================= +// INDIVIDUAL CLASS EXPORTS FOR CLEAN IMPORTS +// ============================================================================= + +// Base and core events +const { + CommandEvent, + ProgressEvent, + ErrorEvent, + SuccessEvent, + WarningEvent, + StartEvent, + CompleteEvent, + CancelledEvent, + validateCommandEvent +} = CommandEvents; + +// Migration events +const { + MigrationStartEvent, + MigrationStepEvent, + MigrationCompleteEvent, + MigrationFailedEvent, + MigrationRollbackEvent, + MigrationValidationEvent, + SchemaDiffEvent +} = MigrationEvents; + +// Test events +const { + TestRunEvent, + TestProgressEvent, + TestResultEvent, + TestFailedEvent, + CoverageEvent, + TestDiscoveryEvent, + TestValidationEvent +} = TestEvents; + +// ============================================================================= +// RUNTIME TYPE CHECKING UTILITIES +// ============================================================================= + +/** + * Enhanced event validation with comprehensive type checking. + * + * Provides more detailed validation than the basic validateCommandEvent, + * with support for multiple expected types and detailed error reporting. + * + * @param {Object} event - Event object to validate + * @param {Function|Array} [expectedTypes] - Expected event class(es) + * @param {Object} [options={}] - Validation options + * @param {boolean} [options.strict=true] - Strict validation mode + * @param {boolean} [options.throwOnError=true] - Throw error vs return result + * @returns {Object|boolean} Validation result or throws error + * @throws {TypeError} When validation fails and throwOnError is true + * @example + * // Single type validation + * validateEvent(event, ProgressEvent); + * + * // Multiple type validation + * validateEvent(event, [ProgressEvent, ErrorEvent]); + * + * // Non-throwing validation + * const result = validateEvent(event, ProgressEvent, { throwOnError: false }); + * if (!result.valid) console.error(result.errors); + */ +function validateEvent(event, expectedTypes = null, options = {}) { + const opts = { + strict: true, + throwOnError: true, + ...options + }; + + const errors = []; + + // Basic structure validation + try { + validateCommandEvent(event); + } catch (error) { + errors.push(`Basic validation failed: ${error.message}`); + } + + // Type-specific validation + if (expectedTypes) { + const types = Array.isArray(expectedTypes) ? expectedTypes : [expectedTypes]; + const matches = types.some((Type) => { + try { + validateCommandEvent(event, Type); + return true; + } catch (error) { + errors.push(`Type ${Type.name} validation failed: ${error.message}`); + return false; + } + }); + + if (!matches) { + const typeNames = types.map((T) => T.name).join(' or '); + errors.push(`Event does not match expected type(s): ${typeNames}`); + } + } + + // Strict mode additional checks + if (opts.strict) { + // Check for required properties based on event type + if (event instanceof ProgressEvent && event.percentage !== null) { + if (typeof event.percentage !== 'number' || event.percentage < 0 || event.percentage > 100) { + errors.push('ProgressEvent percentage must be null or number between 0-100'); + } + } + + if (event instanceof ErrorEvent) { + if (!event.message || event.message.trim().length === 0) { + errors.push('ErrorEvent must have non-empty message'); + } + } + + // Check immutability + if (!Object.isFrozen(event)) { + errors.push('Event object must be frozen (immutable)'); + } + } + + const result = { + valid: errors.length === 0, + errors, + event, + timestamp: new Date() + }; + + if (!result.valid && opts.throwOnError) { + throw new TypeError(`Event validation failed:\n${errors.join('\n')}`); + } + + return opts.throwOnError ? true : result; +} + +/** + * Checks if an event is of a specific type using instanceof. + * + * Provides a clean way to do runtime type checking with support + * for multiple types and null safety. + * + * @param {Object|null} event - Event to check + * @param {Function|Array} EventTypes - Class(es) to check against + * @returns {boolean} True if event matches any of the specified types + * @example + * if (isEventType(event, ProgressEvent)) { + * console.log(`Progress: ${event.percentage}%`); + * } + * + * if (isEventType(event, [ErrorEvent, WarningEvent])) { + * console.log('Issue detected:', event.message); + * } + */ +function isEventType(event, EventTypes) { + if (!event || typeof event !== 'object') return false; + + const types = Array.isArray(EventTypes) ? EventTypes : [EventTypes]; + return types.some((Type) => event instanceof Type); +} + +/** + * Creates a type guard function for a specific event type. + * + * Returns a function that can be used to check and narrow event types + * in a functional programming style. + * + * @param {Function} EventType - Event class to create guard for + * @returns {Function} Type guard function + * @example + * const isProgress = createTypeGuard(ProgressEvent); + * const progressEvents = events.filter(isProgress); + */ +function createTypeGuard(EventType) { + return function (event) { + return event instanceof EventType; + }; +} + +/** + * Gets the event type hierarchy for a given event. + * + * Returns an array of classes that the event inherits from, + * useful for debugging and type analysis. + * + * @param {Object} event - Event to analyze + * @returns {Array} Array of class names in inheritance chain + * @example + * const hierarchy = getEventHierarchy(migrationEvent); + * // ['MigrationStartEvent', 'CommandEvent', 'Object'] + */ +function getEventHierarchy(event) { + if (!event || typeof event !== 'object') return []; + + const hierarchy = []; + let current = event.constructor; + + while (current && current.name !== 'Object') { + hierarchy.push(current.name); + current = Object.getPrototypeOf(current); + } + + return hierarchy; +} + +// ============================================================================= +// EVENT FACTORY FUNCTIONS +// ============================================================================= + +/** + * Creates events with automatic validation and error handling. + * + * Factory functions that ensure events are created correctly with + * proper validation and consistent error handling. + */ +const EventFactory = { + /** + * Creates a progress event with validation. + * + * @param {string} message - Progress message + * @param {number|null} [percentage=null] - Progress percentage + * @param {Object} [details={}] - Additional details + * @returns {ProgressEvent} Validated progress event + */ + progress(message, percentage = null, details = {}) { + try { + return new ProgressEvent(message, percentage, details); + } catch (error) { + throw new TypeError(`Failed to create ProgressEvent: ${error.message}`); + } + }, + + /** + * Creates an error event with validation. + * + * @param {string} message - Error message + * @param {Error|null} [error=null] - Error object + * @param {string|null} [code=null] - Error code + * @param {Object} [details={}] - Additional details + * @returns {ErrorEvent} Validated error event + */ + error(message, error = null, code = null, details = {}) { + try { + return new ErrorEvent(message, error, code, details); + } catch (err) { + throw new TypeError(`Failed to create ErrorEvent: ${err.message}`); + } + }, + + /** + * Creates a migration start event with validation. + * + * @param {string} message - Migration message + * @param {Object} [details={}] - Migration details + * @returns {MigrationStartEvent} Validated migration event + */ + migrationStart(message, details = {}) { + try { + return new MigrationStartEvent(message, details); + } catch (error) { + throw new TypeError(`Failed to create MigrationStartEvent: ${error.message}`); + } + }, + + /** + * Creates a test result event with validation. + * + * @param {string} message - Test result message + * @param {Object} [details={}] - Test result details + * @returns {TestResultEvent} Validated test result event + */ + testResult(message, details = {}) { + try { + return new TestResultEvent(message, details); + } catch (error) { + throw new TypeError(`Failed to create TestResultEvent: ${error.message}`); + } + } +}; + +// ============================================================================= +// EVENT CATEGORY COLLECTIONS +// ============================================================================= + +/** + * All core command events for basic operations. + */ +const CoreEvents = { + CommandEvent, + ProgressEvent, + ErrorEvent, + SuccessEvent, + WarningEvent, + StartEvent, + CompleteEvent, + CancelledEvent +}; + +/** + * All migration-related events for database operations. + */ +const MigrationEventTypes = { + MigrationStartEvent, + MigrationStepEvent, + MigrationCompleteEvent, + MigrationFailedEvent, + MigrationRollbackEvent, + MigrationValidationEvent, + SchemaDiffEvent +}; + +/** + * All test-related events for pgTAP and coverage operations. + */ +const TestEventTypes = { + TestRunEvent, + TestProgressEvent, + TestResultEvent, + TestFailedEvent, + CoverageEvent, + TestDiscoveryEvent, + TestValidationEvent +}; + +/** + * All available event types in the system. + */ +const AllEvents = { + ...CoreEvents, + ...MigrationEventTypes, + ...TestEventTypes +}; + +// ============================================================================= +// EXPORTS +// ============================================================================= + +// Individual event classes for clean imports +export { + // Base and core events + CommandEvent, + ProgressEvent, + ErrorEvent, + SuccessEvent, + WarningEvent, + StartEvent, + CompleteEvent, + CancelledEvent, + + // Migration events + MigrationStartEvent, + MigrationStepEvent, + MigrationCompleteEvent, + MigrationFailedEvent, + MigrationRollbackEvent, + MigrationValidationEvent, + SchemaDiffEvent, + + // Test events + TestRunEvent, + TestProgressEvent, + TestResultEvent, + TestFailedEvent, + CoverageEvent, + TestDiscoveryEvent, + TestValidationEvent, + + // Validation utilities + validateCommandEvent, + validateEvent, + isEventType, + createTypeGuard, + getEventHierarchy, + + // Factory functions + EventFactory, + + // Category collections + CoreEvents, + MigrationEventTypes, + TestEventTypes, + AllEvents, + + // Module collections for namespace imports + CommandEvents, + MigrationEvents, + TestEvents +}; + +// Default export for convenience +export default AllEvents; diff --git a/src/reporters/CliReporter.js b/starfleet/data-cli/src/reporters/CliReporter.js similarity index 93% rename from src/reporters/CliReporter.js rename to starfleet/data-cli/src/reporters/CliReporter.js index f3aa8dd..ea2c768 100644 --- a/src/reporters/CliReporter.js +++ b/starfleet/data-cli/src/reporters/CliReporter.js @@ -2,12 +2,9 @@ * CLI Reporter for Command Events */ -const chalk = require('chalk'); -const inquirer = require('inquirer'); -const { - CommandEvent, - ErrorEvent -} = require('../lib/events/CommandEvents'); +import chalk from 'chalk'; +import inquirer from 'inquirer'; +import { CommandEvent, ErrorEvent } from '../lib/events/CommandEvents.cjs'; /** * Reporter that listens to command events and displays CLI output @@ -36,13 +33,13 @@ class CliReporter { if (!this.silent) { const message = this._extractMessage(eventData); const data = this._extractData(eventData); - + if (message) { console.log(chalk.yellow.bold(`\nโš ๏ธ WARNING: ${message}\n`)); - + if (data && data.actions) { console.log(chalk.yellow('This will:')); - data.actions.forEach(action => { + data.actions.forEach((action) => { console.log(chalk.yellow(` โ€ข ${action}`)); }); console.log(chalk.yellow('\nThis action cannot be undone!\n')); @@ -56,7 +53,7 @@ class CliReporter { if (!this.silent) { const message = this._extractMessage(eventData); const error = this._extractError(eventData); - + if (message) { console.error(chalk.red(`โœ— ${message}`)); } @@ -155,17 +152,17 @@ class CliReporter { if (eventData instanceof CommandEvent) { return eventData.message; } - + // Handle legacy event objects if (eventData && typeof eventData === 'object') { return eventData.message; } - + // Handle simple string messages if (typeof eventData === 'string') { return eventData; } - + return null; } @@ -177,15 +174,20 @@ class CliReporter { // Handle typed CommandEvent instances if (eventData instanceof CommandEvent) { // Return all properties except the standard ones - const { eventType: _eventType, timestamp: _timestamp, message: _message, ...data } = eventData; + const { + eventType: _eventType, + timestamp: _timestamp, + message: _message, + ...data + } = eventData; return Object.keys(data).length > 0 ? data : null; } - + // Handle legacy event objects if (eventData && typeof eventData === 'object') { return eventData.data || eventData; } - + return null; } @@ -198,12 +200,12 @@ class CliReporter { if (eventData instanceof ErrorEvent) { return eventData.error; } - + // Handle legacy event objects if (eventData && typeof eventData === 'object') { return eventData.error; } - + return null; } @@ -216,12 +218,12 @@ class CliReporter { if (eventData instanceof CommandEvent) { return eventData.isProd || false; } - + // Handle legacy event objects if (eventData && typeof eventData === 'object') { return eventData.isProd || false; } - + return false; } @@ -234,14 +236,15 @@ class CliReporter { if (eventData instanceof CommandEvent) { return eventData.stdout; } - + // Handle legacy event objects if (eventData && typeof eventData === 'object') { return eventData.stdout; } - + return null; } } -module.exports = CliReporter; \ No newline at end of file +export { CliReporter }; +export default CliReporter; diff --git a/starfleet/data-cli/src/reporters/attachCliReporter.js b/starfleet/data-cli/src/reporters/attachCliReporter.js new file mode 100644 index 0000000..3990c91 --- /dev/null +++ b/starfleet/data-cli/src/reporters/attachCliReporter.js @@ -0,0 +1,111 @@ +/** + * CLI Reporter - Attaches event listeners to format output for terminal + * Separated from container to keep composition root clean + */ + +import { Events } from '@starfleet/data-core/events/EventTypes.js'; + +/** + * Attach CLI reporter event handlers + * @param {Object} deps - Dependencies + * @param {import('@starfleet/data-core/ports/EventBusPort.js').EventBusPort} deps.bus - Event bus + * @param {import('@starfleet/data-core/ports/LoggerPort.js').LoggerPort} deps.logger - Logger + */ +export function attachCliReporter({ bus, logger }) { + // Migration plan events + bus.on(Events.MIGRATION_PLAN_STARTED, (payload) => { + logger.info(payload, '๐Ÿ” Analyzing SQL files...'); + }); + + bus.on(Events.MIGRATION_PLAN_STEP, (payload) => { + logger.debug(payload, ` Processing: ${payload.path}`); + }); + + bus.on(Events.MIGRATION_PLAN_READY, (payload) => { + logger.info(payload, `โœ… Migration plan ready (${payload.count} files)`); + }); + + // Migration apply events + bus.on(Events.MIGRATION_APPLY_STARTED, (payload) => { + const mode = payload.dryRun ? '๐Ÿงช Dry run' : '๐Ÿš€ Applying'; + logger.info(payload, `${mode} migration (${payload.steps} steps)`); + }); + + bus.on(Events.MIGRATION_APPLY_STEP, (payload) => { + logger.info(payload, ` [${payload.index}/${payload.total}] ${payload.path}`); + }); + + bus.on(Events.MIGRATION_APPLY_DONE, (payload) => { + if (payload.failed) { + logger.error(payload, 'โŒ Migration failed'); + } else { + logger.info(payload, `โœ… Migration complete (${payload.applied} applied)`); + } + }); + + // Safety gate events + bus.on(Events.SAFETY_CHECKS_STARTED, (payload) => { + logger.info(payload, '๐Ÿ”’ Verifying safety gates...'); + }); + + bus.on(Events.SAFETY_CHECK_ITEM, (payload) => { + const icon = payload.passed ? 'โœ…' : 'โŒ'; + logger.info(payload, ` ${icon} ${payload.check}`); + }); + + bus.on(Events.SAFETY_CHECKS_RESULT, (payload) => { + if (payload.passed) { + logger.info(payload, 'โœ… All safety checks passed'); + } else { + logger.warn(payload, `โš ๏ธ Safety checks failed: ${payload.failures.join(', ')}`); + } + }); + + // Compilation events + bus.on(Events.COMPILE_STARTED, (payload) => { + logger.info(payload, '๐Ÿ”จ Starting compilation...'); + }); + + bus.on(Events.COMPILE_FILE, (payload) => { + logger.debug(payload, ` Compiling: ${payload.file}`); + }); + + bus.on(Events.COMPILE_DONE, (payload) => { + logger.info(payload, 'โœ… Compilation complete'); + }); + + // Test events + bus.on(Events.TEST_RUN_STARTED, (payload) => { + logger.info(payload, '๐Ÿงช Running tests...'); + }); + + bus.on(Events.TEST_PASSED, (payload) => { + logger.debug(payload, ` โœ… ${payload.test}`); + }); + + bus.on(Events.TEST_FAILED, (payload) => { + logger.error(payload, ` โŒ ${payload.test}`); + }); + + bus.on(Events.TEST_RUN_DONE, (payload) => { + const icon = payload.failed === 0 ? 'โœ…' : 'โŒ'; + logger.info(payload, `${icon} Tests: ${payload.passed}/${payload.total} passed`); + }); + + // Generic command events + bus.on(Events.COMMAND_PROGRESS, (payload) => { + logger.info(payload, payload.message || 'Processing...'); + }); + + bus.on(Events.COMMAND_WARNING, (payload) => { + logger.warn(payload, `โš ๏ธ ${payload.message}`); + }); + + bus.on(Events.COMMAND_ERROR, (payload) => { + logger.error(payload, `โŒ ${payload.message}`); + }); + + bus.on(Events.COMMAND_SUCCESS, (payload) => { + logger.info(payload, `โœ… ${payload.message}`); + }); +} diff --git a/src/lib/test/formatters/JSONFormatter.js b/starfleet/data-cli/src/reporters/test-formatters/JSONFormatter.js similarity index 82% rename from src/lib/test/formatters/JSONFormatter.js rename to starfleet/data-cli/src/reporters/test-formatters/JSONFormatter.js index 6bf9fb3..6d391fd 100644 --- a/src/lib/test/formatters/JSONFormatter.js +++ b/starfleet/data-cli/src/reporters/test-formatters/JSONFormatter.js @@ -26,23 +26,23 @@ class JSONFormatter { format: 'json', version: '1.0', timestamp: new Date().toISOString(), - duration: duration + duration }, stats: { - total: total, - passed: passed, - failed: failed, - skipped: skipped, + total, + passed, + failed, + skipped, success: failed === 0 }, - testFunctions: testFunctions.map(func => ({ + testFunctions: testFunctions.map((func) => ({ name: func.name, total: func.total, passed: func.passed, failed: func.failed, skipped: func.skipped, success: func.success, - passRate: func.total > 0 ? (func.passed / func.total * 100).toFixed(1) : 0 + passRate: func.total > 0 ? ((func.passed / func.total) * 100).toFixed(1) : 0 })), tests: tests.map((test, index) => { const testResult = { @@ -66,9 +66,9 @@ class JSONFormatter { }), diagnostics: diagnostics || [], summary: { - passRate: total > 0 ? (passed / total * 100).toFixed(1) : 0, - failRate: total > 0 ? (failed / total * 100).toFixed(1) : 0, - skipRate: total > 0 ? (skipped / total * 100).toFixed(1) : 0, + passRate: total > 0 ? ((passed / total) * 100).toFixed(1) : 0, + failRate: total > 0 ? ((failed / total) * 100).toFixed(1) : 0, + skipRate: total > 0 ? ((skipped / total) * 100).toFixed(1) : 0, overallSuccess: failed === 0, executionTime: { total: duration, @@ -82,7 +82,7 @@ class JSONFormatter { if (testFunctions && testFunctions.length > 1) { jsonResult.functionBreakdown = testFunctions.reduce((breakdown, func) => { breakdown[func.name] = { - tests: tests.filter(test => test.function === func.name), + tests: tests.filter((test) => test.function === func.name), stats: { total: func.total, passed: func.passed, @@ -115,4 +115,4 @@ class JSONFormatter { } } -module.exports = JSONFormatter; \ No newline at end of file +export default JSONFormatter; diff --git a/src/lib/test/formatters/JUnitFormatter.js b/starfleet/data-cli/src/reporters/test-formatters/JUnitFormatter.js similarity index 89% rename from src/lib/test/formatters/JUnitFormatter.js rename to starfleet/data-cli/src/reporters/test-formatters/JUnitFormatter.js index 20ec788..168b6fc 100644 --- a/src/lib/test/formatters/JUnitFormatter.js +++ b/starfleet/data-cli/src/reporters/test-formatters/JUnitFormatter.js @@ -24,18 +24,20 @@ class JUnitFormatter { const xml = []; xml.push(''); xml.push(''); - + // Create one testsuite containing all tests - xml.push(` `); - + xml.push( + ` ` + ); + // Add individual test cases - tests.forEach(test => { + tests.forEach((test) => { const testName = this._escapeXml(test.description); const testTime = this._calculateTestTime(test, duration, total); - + if (test.status === 'fail') { xml.push(` `); - xml.push(` `); + xml.push(' '); xml.push(' '); } else if (test.status === 'skip') { xml.push(` `); @@ -46,21 +48,21 @@ class JUnitFormatter { xml.push(` `); } }); - + // Add system-out with function-level summary if (testFunctions && testFunctions.length > 0) { xml.push(' { + testFunctions.forEach((func) => { const status = func.success ? 'PASSED' : 'FAILED'; xml.push(`${func.name}: ${func.passed}/${func.total} passed (${status})`); }); xml.push(']]>'); } - + xml.push(' '); xml.push(''); - + return xml.join('\n'); } @@ -104,4 +106,4 @@ class JUnitFormatter { } } -module.exports = JUnitFormatter; \ No newline at end of file +export default JUnitFormatter; diff --git a/starfleet/data-cli/src/reporters/test-formatters/index.js b/starfleet/data-cli/src/reporters/test-formatters/index.js new file mode 100644 index 0000000..f28ff26 --- /dev/null +++ b/starfleet/data-cli/src/reporters/test-formatters/index.js @@ -0,0 +1,7 @@ +/** + * Test Result Formatters + * Export all available formatters for test output + */ + +export { default as JSONFormatter } from './JSONFormatter.js'; +export { default as JUnitFormatter } from './JUnitFormatter.js'; diff --git a/starfleet/data-cli/src/ui/logo.js b/starfleet/data-cli/src/ui/logo.js new file mode 100644 index 0000000..491116f --- /dev/null +++ b/starfleet/data-cli/src/ui/logo.js @@ -0,0 +1,79 @@ +/** + * data CLI Logo Display + */ + +// Import oh-my-logo through the CommonJS bridge +import ohMyLogoBridge from './oh-my-logo-bridge.cjs'; + +/** + * Display data logo with mountain theme + */ +async function displayLogo() { + try { + // Wait for the bridge to resolve the ES module + const { renderFilled } = await ohMyLogoBridge; + + // All available oh-my-logo palettes + const allPalettes = [ + 'grad-blue', + 'sunset', + 'dawn', + 'nebula', + 'mono', + 'ocean', + 'fire', + 'forest', + 'gold', + 'purple', + 'mint', + 'coral', + 'matrix' + ]; + + // All available block fonts for filled mode + const allFonts = [ + '3d', + 'block', + 'chrome', + 'grid', + 'huge', + 'pallet', + 'shade', + 'simple', + 'simple3d', + 'simpleBlock', + 'slick', + 'tiny' + ]; + + // Pick random palette AND random font - MAXIMUM CHAOS! ๐ŸŽฒ + const randomPalette = allPalettes[Math.floor(Math.random() * allPalettes.length)]; + const randomFont = allFonts[Math.floor(Math.random() * allFonts.length)]; + + await renderFilled('Supa', { + palette: randomPalette, + font: randomFont // RANDOM FONT EVERY TIME! WHEEEEE! ๐ŸŽ‰ + }); + await renderFilled('DATA', { + palette: randomPalette, + font: randomFont // RANDOM FONT EVERY TIME! WHEEEEE! ๐ŸŽ‰ + }); + } catch { + // Fallback: Simple console log if logo rendering fails + console.log('D โ€ข A โ€ข T โ€ข A'); + } + + console.log('๐Ÿ–– I am DATA:'); + console.log('Database Automation, Testing, and Alignment.'); + console.log('๐Ÿค– I am an Android. No, not the phone.'); + console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n'); + console.log(''); + console.log('Computer, display the help menu.'); + console.log(''); + console.log('Displaying help menu.'); + console.log(''); + console.log('โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•'); + console.log(''); +} + +export { displayLogo }; diff --git a/src/ui/oh-my-logo-bridge.cjs b/starfleet/data-cli/src/ui/oh-my-logo-bridge.cjs similarity index 100% rename from src/ui/oh-my-logo-bridge.cjs rename to starfleet/data-cli/src/ui/oh-my-logo-bridge.cjs diff --git a/starfleet/data-core/.eslintrc.js b/starfleet/data-core/.eslintrc.js new file mode 100644 index 0000000..2c1c5dc --- /dev/null +++ b/starfleet/data-core/.eslintrc.js @@ -0,0 +1,103 @@ +/** + * ESLint configuration for data-core + * Enforces architectural boundaries - NO Node.js built-ins allowed + */ + +module.exports = { + env: { + es2022: true, + node: false // Core should not use Node + }, + parserOptions: { + ecmaVersion: 2022, + sourceType: 'module' + }, + rules: { + // Forbid Node.js built-in modules + 'no-restricted-imports': [ + 'error', + { + paths: [ + { name: 'node:fs', message: 'Use FileSystemPort instead of node:fs' }, + { name: 'fs', message: 'Use FileSystemPort instead of fs' }, + { name: 'node:path', message: 'Use path utilities in core or PathPort' }, + { name: 'path', message: 'Use path utilities in core or PathPort' }, + { name: 'node:child_process', message: 'Use ProcessPort instead of node:child_process' }, + { name: 'child_process', message: 'Use ProcessPort instead of child_process' }, + { + name: 'node:process', + message: 'Use EnvironmentPort/ProcessPort instead of node:process' + }, + { name: 'process', message: 'Use EnvironmentPort/ProcessPort instead of process' }, + { name: 'node:events', message: 'Use EventBusPort instead of node:events' }, + { name: 'events', message: 'Use EventBusPort instead of events' }, + { name: 'node:crypto', message: 'Use CryptoPort instead of node:crypto' }, + { name: 'crypto', message: 'Use CryptoPort instead of crypto' }, + { name: 'node:http', message: 'Core should not make HTTP calls directly' }, + { name: 'http', message: 'Core should not make HTTP calls directly' }, + { name: 'node:https', message: 'Core should not make HTTPS calls directly' }, + { name: 'https', message: 'Core should not make HTTPS calls directly' }, + { name: 'node:net', message: 'Core should not use networking directly' }, + { name: 'net', message: 'Core should not use networking directly' }, + { name: 'node:os', message: 'Core should not access OS information directly' }, + { name: 'os', message: 'Core should not access OS information directly' }, + { name: 'node:util', message: 'Core should not use Node util directly' }, + { name: 'util', message: 'Core should not use Node util directly' } + ], + patterns: [ + 'node:*', // Block all node: prefixed modules + '@starfleet/data-host-node/*', // Core cannot import from host layer + '@starfleet/data-cli/*' // Core cannot import from CLI layer + ] + } + ], + + // Forbid console usage - use LoggerPort + 'no-console': [ + 'error', + { + allow: [] // No console methods allowed + } + ], + + // Forbid process global + 'no-restricted-globals': [ + 'error', + { + name: 'process', + message: 'Use EnvironmentPort or ProcessPort instead of global process' + }, + { + name: 'console', + message: 'Use LoggerPort instead of global console' + }, + { + name: '__dirname', + message: 'Core should not use __dirname' + }, + { + name: '__filename', + message: 'Core should not use __filename' + }, + { + name: 'Buffer', + message: 'Core should not use Buffer directly' + } + ], + + // Async/await best practices + 'require-await': 'error', + 'no-return-await': 'error', + + // General code quality + 'no-unused-vars': [ + 'error', + { + argsIgnorePattern: '^_', + varsIgnorePattern: '^_' + } + ], + 'prefer-const': 'error', + 'no-var': 'error' + } +}; diff --git a/starfleet/data-core/codemods/cjs-to-esm.js b/starfleet/data-core/codemods/cjs-to-esm.js new file mode 100644 index 0000000..4d8338f --- /dev/null +++ b/starfleet/data-core/codemods/cjs-to-esm.js @@ -0,0 +1,123 @@ +/** + * JSCodeshift transformer to convert CommonJS to ESM + * Handles module.exports, require(), and adds .js extensions + */ + +module.exports = function transformer(fileInfo, api) { + const j = api.jscodeshift; + const root = j(fileInfo.source); + let hasChanges = false; + + // 1. Convert require() to import + root + .find(j.VariableDeclarator, { + init: { + type: 'CallExpression', + callee: { name: 'require' } + } + }) + .forEach((path) => { + const requirePath = path.value.init.arguments[0].value; + const id = path.value.id; + + // Skip dynamic requires + if (typeof requirePath !== 'string') { + console.log(`FIXME: Dynamic require in ${fileInfo.path}`); + return; + } + + // Handle destructuring: const { a, b } = require('x') + if (id.type === 'ObjectPattern') { + const specifiers = id.properties.map((prop) => + j.importSpecifier(j.identifier(prop.key.name), j.identifier(prop.value.name)) + ); + + const importDecl = j.importDeclaration(specifiers, j.literal(addJsExtension(requirePath))); + + j(path.parent).replaceWith(importDecl); + hasChanges = true; + } + // Handle default: const x = require('y') + else { + const importDecl = j.importDeclaration( + [j.importDefaultSpecifier(id)], + j.literal(addJsExtension(requirePath)) + ); + + j(path.parent).replaceWith(importDecl); + hasChanges = true; + } + }); + + // 2. Convert module.exports = X to export default X + root + .find(j.AssignmentExpression, { + left: { + type: 'MemberExpression', + object: { name: 'module' }, + property: { name: 'exports' } + } + }) + .forEach((path) => { + const exportValue = path.value.right; + + // Handle module.exports = { a, b } + if (exportValue.type === 'ObjectExpression') { + const namedExports = exportValue.properties.map((prop) => { + // Handle shorthand: { TestRequirementAnalyzer } + if (prop.shorthand) { + return j.exportNamedDeclaration(null, [j.exportSpecifier(j.identifier(prop.key.name))]); + } + // Handle regular: { a: b } + return j.exportNamedDeclaration( + j.variableDeclaration('const', [ + j.variableDeclarator(j.identifier(prop.key.name), prop.value) + ]) + ); + }); + + // Replace with multiple export statements + const parent = path.parent; + if (parent.type === 'ExpressionStatement') { + j(parent).replaceWith(namedExports); + } + } else { + // Simple export default + j(path.parent).replaceWith(j.exportDefaultDeclaration(exportValue)); + } + hasChanges = true; + }); + + // 3. Convert exports.foo = bar to export const foo = bar + root + .find(j.AssignmentExpression, { + left: { + type: 'MemberExpression', + object: { name: 'exports' } + } + }) + .forEach((path) => { + const propName = path.value.left.property.name; + const exportValue = path.value.right; + + j(path.parent).replaceWith( + j.exportNamedDeclaration( + j.variableDeclaration('const', [ + j.variableDeclarator(j.identifier(propName), exportValue) + ]) + ) + ); + hasChanges = true; + }); + + // Helper to add .js extension to relative imports + function addJsExtension(importPath) { + // Skip node modules and already has extension + if (!importPath.startsWith('.') || importPath.endsWith('.js')) { + return importPath; + } + return importPath + '.js'; + } + + return hasChanges ? root.toSource() : null; +}; diff --git a/starfleet/data-core/example-di.js b/starfleet/data-core/example-di.js new file mode 100644 index 0000000..70b961a --- /dev/null +++ b/starfleet/data-core/example-di.js @@ -0,0 +1,169 @@ +#!/usr/bin/env node + +/** + * Example demonstrating the dependency injection system. + * Shows how to wire data-core with data-host-node adapters using DI. + * + * Run with: node packages/data-core/example-di.js + */ + +import { DIContainer } from './ports/DIContainer.js'; +import { PortFactory, wireDataCore } from './ports/PortFactory.js'; +import { DataCore } from './index.js'; + +// Import Node.js adapters +import { + FileSystemAdapter, + CryptoAdapter, + ProcessAdapter, + EnvironmentAdapter +} from '../data-host-node/index.js'; + +console.log('๐Ÿ”— Dependency Injection System Demo\n'); + +// === Method 1: Using DIContainer directly === +console.log('๐Ÿ“ฆ Method 1: Using DIContainer directly'); + +const container = new DIContainer(); + +// Register all adapters as singletons +container + .registerSingleton('fileSystem', FileSystemAdapter, { + config: { encoding: 'utf8' } + }) + .registerSingleton('crypto', CryptoAdapter, { + config: { defaultAlgorithm: 'sha256' } + }) + .registerSingleton('process', ProcessAdapter, { + config: { timeout: 30000, shell: '/bin/bash' } + }) + .registerSingleton('environment', EnvironmentAdapter, { + config: { prefix: 'DATA_' } + }); + +// Register DataCore with automatic dependency injection +container.register('dataCore', DataCore); + +// Resolve DataCore - all dependencies automatically injected +const dataCore1 = container.resolve('dataCore'); +console.log( + `โœ… DataCore resolved with ports: ${Object.keys(dataCore1) + .filter((k) => k.endsWith('Port')) + .join(', ')}` +); +console.log('๐Ÿ“Š Container stats:', container.getStats()); + +console.log('\n---\n'); + +// === Method 2: Using PortFactory === +console.log('๐Ÿญ Method 2: Using PortFactory'); + +const factory = new PortFactory(); + +// Register adapters with factory +factory + .registerPort('fileSystem', FileSystemAdapter, FileSystemAdapter, { encoding: 'utf8' }) + .registerPort('crypto', CryptoAdapter, CryptoAdapter, { defaultAlgorithm: 'sha256' }) + .registerPort('process', ProcessAdapter, ProcessAdapter, { timeout: 30000 }) + .registerPort('environment', EnvironmentAdapter, EnvironmentAdapter, { prefix: 'DATA_' }); + +// Create all data-core compatible ports +const ports = factory.createDataCorePorts({ + fileSystem: { encoding: 'utf8', mode: 0o644 }, + crypto: { defaultAlgorithm: 'sha256' }, + process: { timeout: 30000, shell: '/bin/bash' }, + environment: { prefix: 'DATA_', caseSensitive: true } +}); + +// Create DataCore with ports +const dataCore2 = new DataCore(ports.fileSystem, ports.crypto, ports.process, ports.environment); + +console.log('โœ… DataCore created with factory-generated ports'); +console.log('๐Ÿ“Š Factory info:', factory.getPortInfo()); + +console.log('\n---\n'); + +// === Method 3: Using convenience wireDataCore function === +console.log('โšก Method 3: Using wireDataCore convenience function'); + +const { + ports: wirePorts, + dataCore: dataCore3, + factory: wireFactory +} = wireDataCore( + DataCore, + { + fileSystem: FileSystemAdapter, + crypto: CryptoAdapter, + process: ProcessAdapter, + environment: EnvironmentAdapter + }, + { + fileSystem: { encoding: 'utf8' }, + crypto: { defaultAlgorithm: 'sha256' }, + process: { timeout: 30000 }, + environment: { prefix: 'DATA_' } + } +); + +console.log('โœ… DataCore wired using convenience function'); +console.log('๐Ÿ”Œ Wired ports:', Object.keys(wirePorts)); + +console.log('\n---\n'); + +// === Method 4: Factory + Container integration === +console.log('๐Ÿ”„ Method 4: Factory + Container integration'); + +const integratedContainer = new DIContainer(); +const integratedFactory = new PortFactory(); + +// Register adapters with factory +integratedFactory + .registerPort('fileSystem', FileSystemAdapter, FileSystemAdapter) + .registerPort('crypto', CryptoAdapter, CryptoAdapter) + .registerPort('process', ProcessAdapter, ProcessAdapter) + .registerPort('environment', EnvironmentAdapter, EnvironmentAdapter); + +// Register factory-created ports with container +integratedFactory.registerWithContainer(integratedContainer, { + fileSystem: { encoding: 'utf8' }, + crypto: { defaultAlgorithm: 'sha256' }, + process: { timeout: 30000 }, + environment: { prefix: 'DATA_' } +}); + +// Register DataCore +integratedContainer.registerSingleton('dataCore', DataCore); + +// Resolve everything +const integratedDataCore = integratedContainer.resolve('dataCore'); +console.log('โœ… DataCore resolved from integrated Factory + Container'); + +console.log('\n---\n'); + +// === Demonstrate DataCore functionality === +console.log('๐Ÿš€ Testing DataCore functionality'); + +try { + // Test package info + const packageInfo = dataCore1.getPackageInfo(); + console.log(`๐Ÿ“‹ Package: ${packageInfo.name} v${packageInfo.version}`); + console.log(`๐Ÿ”Œ Port interfaces: ${packageInfo.portInterfaces.join(', ')}`); + console.log(`โš™๏ธ Core engines: ${packageInfo.coreEngines.join(', ')}`); + + // Test sample schema creation + const sampleSchema = dataCore1.createSampleSchema('demo'); + console.log('๐Ÿ“Š Sample schema created with checksum capability'); + + console.log('\nโœ… All dependency injection methods working correctly!'); + console.log('\n๐ŸŽฏ Key Benefits:'); + console.log(' โ€ข Automatic dependency resolution'); + console.log(' โ€ข Circular dependency detection'); + console.log(' โ€ข Singleton lifecycle management'); + console.log(' โ€ข Configuration injection'); + console.log(' โ€ข Factory pattern for reusability'); + console.log(' โ€ข Multiple integration approaches'); +} catch (error) { + console.error('โŒ Error testing DataCore:', error.message); + process.exit(1); +} diff --git a/starfleet/data-core/example-full-di.js b/starfleet/data-core/example-full-di.js new file mode 100644 index 0000000..2968e02 --- /dev/null +++ b/starfleet/data-core/example-full-di.js @@ -0,0 +1,200 @@ +#!/usr/bin/env node + +/** + * Complete example showing dependency injection system integration. + * Demonstrates wiring data-core with data-host-node adapters. + */ + +import { DIContainer, PortFactory, wireDataCore, DataCore } from './index.js'; + +// Import Node.js adapters +import { FileSystemAdapter } from '../data-host-node/adapters/FileSystemAdapter.js'; +import { CryptoAdapter } from '../data-host-node/adapters/CryptoAdapter.js'; +import { ProcessAdapter } from '../data-host-node/adapters/ProcessAdapter.js'; +import { EnvironmentAdapter } from '../data-host-node/adapters/EnvironmentAdapter.js'; + +console.log('๐Ÿš€ Complete Dependency Injection Integration Demo\n'); + +// === Method 1: Manual DI Container Setup === +console.log('๐Ÿ“ฆ Method 1: Manual DIContainer Setup'); + +const container = new DIContainer(); + +// Register all Node.js adapters as singletons with no dependencies (they only take config objects) +container + .registerSingleton('fileSystem', FileSystemAdapter, { + dependencies: [], // No DI dependencies, just config + config: { encoding: 'utf8', mode: 0o644 } + }) + .registerSingleton('crypto', CryptoAdapter, { + dependencies: [], + config: { defaultAlgorithm: 'sha256', encoding: 'hex' } + }) + .registerSingleton('process', ProcessAdapter, { + dependencies: [], + config: { timeout: 30000, shell: '/bin/bash' } + }) + .registerSingleton('environment', EnvironmentAdapter, { + dependencies: [], + config: { prefix: 'DATA_' } + }); + +// Register DataCore with automatic dependency injection +container.register('dataCore', DataCore, { + dependencies: ['fileSystem', 'crypto', 'process', 'environment'] +}); + +// Resolve DataCore with all dependencies wired +const dataCore1 = container.resolve('dataCore'); +console.log('โœ… DataCore resolved from DIContainer'); +console.log(' Ports injected: fileSystem, crypto, process, environment'); + +// Test functionality +const packageInfo1 = dataCore1.getPackageInfo(); +console.log(` Package: ${packageInfo1.name} v${packageInfo1.version}`); +console.log(` Capabilities: ${Object.keys(packageInfo1.capabilities).length} features`); + +console.log('\n---\n'); + +// === Method 2: PortFactory Approach === +console.log('๐Ÿญ Method 2: PortFactory Approach'); + +const factory = new PortFactory(); + +// Register adapters with factory (note: using the base classes for validation) +factory + .registerPort('fileSystem', FileSystemAdapter, FileSystemAdapter) + .registerPort('crypto', CryptoAdapter, CryptoAdapter) + .registerPort('process', ProcessAdapter, ProcessAdapter) + .registerPort('environment', EnvironmentAdapter, EnvironmentAdapter); + +// Create configured ports +const ports = factory.createDataCorePorts({ + fileSystem: { encoding: 'utf8', mode: 0o644 }, + crypto: { defaultAlgorithm: 'sha256' }, + process: { timeout: 30000, shell: '/bin/bash' }, + environment: { prefix: 'DATA_' } +}); + +// Wire DataCore manually +const dataCore2 = new DataCore(ports.fileSystem, ports.crypto, ports.process, ports.environment); + +console.log('โœ… DataCore created with PortFactory'); +console.log(` Generated ports: ${Object.keys(ports).join(', ')}`); + +// Test functionality +const sampleSchema = dataCore2.createSampleSchema('factory-test'); +console.log(' Sample schema created successfully'); + +console.log('\n---\n'); + +// === Method 3: wireDataCore Convenience Function === +console.log('โšก Method 3: wireDataCore Convenience Function'); + +const { + ports: wireports, + dataCore: dataCore3, + factory: wirefactory +} = wireDataCore( + DataCore, + { + fileSystem: FileSystemAdapter, + crypto: CryptoAdapter, + process: ProcessAdapter, + environment: EnvironmentAdapter + }, + { + fileSystem: { encoding: 'utf8' }, + crypto: { defaultAlgorithm: 'sha256' }, + process: { timeout: 30000 }, + environment: { prefix: 'DATA_' } + } +); + +console.log('โœ… DataCore wired with convenience function'); +console.log(` Auto-wired ports: ${Object.keys(wireports).join(', ')}`); + +console.log('\n---\n'); + +// === Method 4: Factory + Container Integration === +console.log('๐Ÿ”„ Method 4: Factory + Container Integration'); + +const integrationContainer = new DIContainer(); +const integrationFactory = new PortFactory(); + +// Register adapters with factory +integrationFactory + .registerPort('fileSystem', FileSystemAdapter, FileSystemAdapter) + .registerPort('crypto', CryptoAdapter, CryptoAdapter) + .registerPort('process', ProcessAdapter, ProcessAdapter) + .registerPort('environment', EnvironmentAdapter, EnvironmentAdapter); + +// Register factory ports with container as singletons +integrationFactory.registerWithContainer(integrationContainer, { + fileSystem: { encoding: 'utf8' }, + crypto: { defaultAlgorithm: 'sha256' }, + process: { timeout: 30000 }, + environment: { prefix: 'DATA_' } +}); + +// Register DataCore for automatic resolution +integrationContainer.register('dataCore', DataCore, { + dependencies: ['fileSystem', 'crypto', 'process', 'environment'] +}); + +// Resolve everything +const dataCore4 = integrationContainer.resolve('dataCore'); +console.log('โœ… DataCore resolved from integrated Factory + Container'); + +// Show container statistics +const stats = integrationContainer.getStats(); +console.log( + ` Container: ${stats.totalServices} services, ${stats.singletonInstances} singletons` +); + +console.log('\n---\n'); + +// === Demonstrate DataCore Functionality === +console.log('๐ŸŽฏ Testing DataCore Functionality'); + +try { + // Test with one of our DataCore instances + const testDataCore = dataCore1; + + // Get package information + const info = testDataCore.getPackageInfo(); + console.log(`๐Ÿ“‹ Package: ${info.name} v${info.version}`); + console.log(`๐Ÿ”Œ Port interfaces: ${info.portInterfaces.join(', ')}`); + console.log(`โš™๏ธ Core engines: ${info.coreEngines.join(', ')}`); + + // Create sample schema + const schema = testDataCore.createSampleSchema('integration-test'); + console.log('๐Ÿ“Š Sample schema created'); + + // Show capabilities + console.log('๐ŸŽช Capabilities:'); + for (const [capability, enabled] of Object.entries(info.capabilities)) { + console.log(` โ€ข ${capability}: ${enabled ? 'โœ…' : 'โŒ'}`); + } + + console.log('\n๐ŸŽ‰ All integration methods working successfully!'); + + console.log('\n๐Ÿ“‹ Summary:'); + console.log(' 1. DIContainer: Manual registration with full control'); + console.log(' 2. PortFactory: Type-safe port creation with validation'); + console.log(' 3. wireDataCore: One-liner convenience for simple cases'); + console.log(' 4. Factory+Container: Best of both worlds for complex apps'); + + console.log('\n๐Ÿ”‘ Key Benefits:'); + console.log(' โ€ข Constructor injection with automatic dependency resolution'); + console.log(' โ€ข Singleton lifecycle management for shared resources'); + console.log(' โ€ข Configuration injection for customizable behavior'); + console.log(' โ€ข Circular dependency detection prevents infinite loops'); + console.log(' โ€ข Port interface validation ensures contract compliance'); + console.log(' โ€ข Factory pattern enables reusable, configured instances'); + console.log(' โ€ข Multiple integration approaches for different use cases'); +} catch (error) { + console.error('โŒ Error testing DataCore functionality:', error.message); + console.error(error.stack); + process.exit(1); +} diff --git a/starfleet/data-core/example.js b/starfleet/data-core/example.js new file mode 100644 index 0000000..327c6a9 --- /dev/null +++ b/starfleet/data-core/example.js @@ -0,0 +1,168 @@ +/** + * Example usage demonstrating dependency injection with data-core package + * This file shows how to implement port adapters and use the core logic + */ + +import { + DataCore, + FileSystemPort, + CryptoPort, + ProcessPort, + EnvironmentPort, + SchemaState +} from './index.js'; + +// Example adapter implementations for Node.js environment +// These would typically be in separate adapter packages + +class NodeFileSystemAdapter extends FileSystemPort { + async readFile(path) { + const fs = await import('fs/promises'); + return fs.readFile(path, 'utf8'); + } + + async glob(patterns, cwd = process.cwd()) { + const glob = await import('glob'); + const results = []; + for (const pattern of patterns) { + const matches = await glob.glob(pattern, { cwd }); + results.push(...matches); + } + return results; + } +} + +class NodeCryptoAdapter extends CryptoPort { + hash(data, algorithm = 'sha256') { + const crypto = await import('crypto'); + return crypto.createHash(algorithm).update(data).digest('hex'); + } +} + +class NodeProcessAdapter extends ProcessPort { + async spawn(command, args = [], options = {}) { + const { spawn } = await import('child_process'); + const { promisify } = await import('util'); + + return new Promise((resolve, _reject) => { + const child = spawn(command, args, options); + let stdout = ''; + let stderr = ''; + + child.stdout?.on('data', (data) => stdout += data.toString()); + child.stderr?.on('data', (data) => stderr += data.toString()); + + child.on('close', (exitCode) => { + resolve({ stdout, stderr, exitCode }); + }); + + child.on('error', _reject); + }); + } +} + +class NodeEnvironmentAdapter extends EnvironmentPort { + get(key, defaultValue) { + return process.env[key] ?? defaultValue; + } + + has(key) { + return key in process.env; + } +} + +// Example usage function +export async function demonstrateCoreUsage() { + console.log('๐Ÿš€ D.A.T.A. Core Package Demonstration'); + console.log('=====================================\n'); + + // 1. Create adapter instances (dependency injection) + const fileSystemPort = new NodeFileSystemAdapter(); + const cryptoPort = new NodeCryptoAdapter(); + const processPort = new NodeProcessAdapter(); + const environmentPort = new NodeEnvironmentAdapter(); + + // 2. Initialize DataCore with injected dependencies + const dataCore = new DataCore( + fileSystemPort, + cryptoPort, + processPort, + environmentPort + ); + + console.log('โœ… DataCore initialized with injected adapters\n'); + + // 3. Display package information + const packageInfo = dataCore.getPackageInfo(); + console.log('๐Ÿ“ฆ Package Information:'); + console.log(` Name: ${packageInfo.name}`); + console.log(` Version: ${packageInfo.version}`); + console.log(` Type: ${packageInfo.type}`); + console.log(` I/O Dependencies: ${packageInfo.ioDepencencies}`); + console.log(` Port Interfaces: ${packageInfo.portInterfaces.join(', ')}`); + console.log(` Core Engines: ${packageInfo.coreEngines.join(', ')}\n`); + + // 4. Demonstrate schema state creation + console.log('๐Ÿ—๏ธ Creating sample schema states...'); + const currentSchema = dataCore.createSampleSchema('current'); + const targetSchema = dataCore.createSampleSchema('target'); + + // Modify target schema to demonstrate diff calculation + targetSchema.addObject('tables', 'comments', { + columns: ['id', 'post_id', 'content', 'created_at'], + sql: 'CREATE TABLE comments (id SERIAL PRIMARY KEY, post_id INTEGER REFERENCES posts(id), content TEXT, created_at TIMESTAMP)' + }); + + targetSchema.addObject('indexes', 'idx_comments_post_id', { + table: 'comments', + columns: ['post_id'], + sql: 'CREATE INDEX idx_comments_post_id ON comments(post_id)' + }); + + console.log(` Current schema checksum: ${currentSchema.checksum}`); + console.log(` Target schema checksum: ${targetSchema.checksum}\n`); + + // 5. Generate migration plan + console.log('๐Ÿ”„ Generating migration plan...'); + const migrationResult = dataCore.generateMigrationPlan(currentSchema, targetSchema, { + enableRollback: true, + parallelExecution: false + }); + + console.log(` Operations generated: ${migrationResult.operations.length}`); + console.log(` Execution steps: ${migrationResult.executionPlan.stepCount}`); + console.log(` Estimated time: ${Math.round(migrationResult.executionPlan.estimatedTime / 1000)}s`); + console.log(` Plan valid: ${migrationResult.validation.valid}`); + + if (migrationResult.validation.warnings.length > 0) { + console.log(` Warnings: ${migrationResult.validation.warnings.length}`); + } + + if (migrationResult.rollbackPlan) { + console.log(` Rollback steps: ${migrationResult.rollbackPlan.stepCount}`); + } + + console.log('\n๐Ÿ“‹ Migration Operations:'); + migrationResult.operations.forEach((op, index) => { + const destructiveFlag = op.isDestructive ? 'โš ๏ธ ' : 'โœ… '; + console.log(` ${index + 1}. ${destructiveFlag}${op.objectName}: ${op.sql.substring(0, 60)}...`); + }); + + console.log('\n๐ŸŽฏ Example demonstrates:'); + console.log(' โœ“ Pure JavaScript implementation (zero I/O dependencies)'); + console.log(' โœ“ Dependency injection via port/adapter pattern'); + console.log(' โœ“ Runtime validation using instanceof checks'); + console.log(' โœ“ Comprehensive JSDoc annotations'); + console.log(' โœ“ ESM exports with clean API surface'); + console.log(' โœ“ Business logic separation from I/O concerns\n'); + + return migrationResult; +} + +// Export individual adapters for reuse +export { + NodeFileSystemAdapter, + NodeCryptoAdapter, + NodeProcessAdapter, + NodeEnvironmentAdapter +}; \ No newline at end of file diff --git a/starfleet/data-core/index.js b/starfleet/data-core/index.js new file mode 100644 index 0000000..9abc29e --- /dev/null +++ b/starfleet/data-core/index.js @@ -0,0 +1,264 @@ +/** + * @fileoverview Main entry point for data-core package + * + * Pure JavaScript logic core for D.A.T.A. with zero I/O dependencies. + * This package contains only business logic that accepts injected ports + * for all external operations following the ports/adapters pattern. + * + * Key Features: + * - SQL dependency graph analysis + * - Migration diff calculation + * - Execution plan compilation + * - Comprehensive runtime validation + * - ESM module exports + */ + +// Export all port interfaces and dependency injection system +export { + FileSystemPort, + CryptoPort, + ProcessPort, + EnvironmentPort, + validatePort, + DIContainer, + PortFactory, + wireDataCore, + createPortFactory +} from './ports/index.js'; + +// Export SQL dependency graph functionality +export { SqlNode, SqlGraph } from './src/migration/SqlGraph.js'; + +// Export migration diff engine +export { + OperationType, + MigrationOperation, + SchemaState, + DiffEngine +} from './src/migration/DiffEngine.js'; + +// Export execution plan compiler +export { + ExecutionPhase, + ExecutionStep, + ExecutionPlan, + PlanCompiler +} from './src/migration/PlanCompiler.js'; + +// Export migration compiler +export { MigrationCompiler } from './src/migration/MigrationCompiler.js'; + +// Export migration metadata +export { MigrationMetadata } from './src/domain/MigrationMetadata.js'; + +// Export output configuration +export { default as OutputConfig } from './src/config/OutputConfig.js'; + +// Export testing domain types +export { TEST_TYPES, TEST_PRIORITIES } from './src/domain/testingTypes.js'; + +// Export test pattern library +export { PATTERNS, getPatternsByCategory, getPatternById } from './src/testing/patterns/index.js'; + +// Export pattern rendering +export { + renderPattern, + getRecommendedPatterns, + generateEnhancedTemplate +} from './src/testing/render/renderPattern.js'; + +// Export test requirement analyzer +export { + makeAnalyzeTestRequirements, + AnalysisEvents +} from './src/application/makeAnalyzeTestRequirements.js'; + +/** + * Package version information + */ +export const VERSION = '0.1.0'; + +// Import validatePort and port classes for use in DataCore +import { + validatePort as validate, + FileSystemPort, + CryptoPort, + ProcessPort, + EnvironmentPort +} from './ports/index.js'; + +// Import core classes for DataCore +import { SqlGraph } from './src/migration/SqlGraph.js'; +import { DiffEngine, SchemaState } from './src/migration/DiffEngine.js'; +import { PlanCompiler } from './src/migration/PlanCompiler.js'; + +/** + * Core migration workflow orchestrator + * Demonstrates the complete migration pipeline using dependency injection + */ +export class DataCore { + /** + * @param {FileSystemPort} fileSystemPort - File system operations + * @param {CryptoPort} cryptoPort - Cryptographic operations + * @param {ProcessPort} processPort - Process execution + * @param {EnvironmentPort} environmentPort - Environment access + */ + constructor(fileSystemPort, cryptoPort, processPort, environmentPort) { + validate(fileSystemPort, FileSystemPort); + validate(cryptoPort, CryptoPort); + validate(processPort, ProcessPort); + validate(environmentPort, EnvironmentPort); + + this.fileSystemPort = fileSystemPort; + this.cryptoPort = cryptoPort; + this.processPort = processPort; + this.environmentPort = environmentPort; + + // Initialize core engines with injected dependencies + this.sqlGraph = new SqlGraph(fileSystemPort); + this.diffEngine = new DiffEngine(cryptoPort); + this.planCompiler = new PlanCompiler(processPort, environmentPort); + } + + /** + * Analyze SQL dependencies in a directory + * @param {string} sqlDirectory - Directory containing SQL files + * @returns {Promise} Dependency analysis results + */ + async analyzeDependencies(sqlDirectory) { + // Find all SQL files + const sqlFiles = await this.fileSystemPort.glob(['**/*.sql'], sqlDirectory); + + // Build dependency graph + await this.sqlGraph.buildGraph(sqlFiles); + + // Analyze the graph + const executionOrder = this.sqlGraph.getExecutionOrder(); + const independentNodes = this.sqlGraph.getIndependentNodes(); + const terminalNodes = this.sqlGraph.getTerminalNodes(); + const hasCircularDeps = this.sqlGraph.hasCircularDependencies(); + + return { + totalFiles: sqlFiles.length, + executionOrder: executionOrder.map((node) => ({ + name: node.name, + type: node.type, + filePath: node.filePath, + dependencies: Array.from(node.dependencies).map((dep) => dep.name) + })), + independentNodes: independentNodes.map((node) => node.name), + terminalNodes: terminalNodes.map((node) => node.name), + hasCircularDependencies: hasCircularDeps + }; + } + + /** + * Generate migration plan from schema differences + * @param {SchemaState} currentState - Current database schema + * @param {SchemaState} targetState - Target database schema + * @param {Object} [options={}] - Migration options + * @returns {Object} Migration plan and analysis + */ + generateMigrationPlan(currentState, targetState, options = {}) { + // Calculate schema differences + const operations = this.diffEngine.calculateDiff(currentState, targetState); + + // Optimize operations + const optimizedOperations = this.diffEngine.optimizeOperations(operations); + + // Compile execution plan + const executionPlan = this.planCompiler.compilePlan(optimizedOperations, { + planId: `migration_${Date.now()}`, + planName: 'Schema Migration', + enableRollback: options.enableRollback ?? true, + parallelExecution: options.parallelExecution ?? false + }); + + // Validate the plan + const validation = this.planCompiler.validatePlan(executionPlan); + + return { + operations: optimizedOperations.map((op) => ({ + type: op.type, + objectName: op.objectName, + sql: op.sql, + isDestructive: op.isDestructive(), + hash: op.hash + })), + executionPlan: { + id: executionPlan.id, + name: executionPlan.name, + stepCount: executionPlan.steps.length, + estimatedTime: executionPlan.getTotalEstimatedTime(), + phases: Array.from(executionPlan.phases.keys()).sort() + }, + validation, + rollbackPlan: validation.valid + ? { + id: `${executionPlan.id}_rollback`, + stepCount: executionPlan.generateRollbackPlan().steps.length + } + : null + }; + } + + /** + * Create sample schema state for testing + * @param {string} [name='sample'] - Schema name + * @returns {SchemaState} Sample schema state + */ + createSampleSchema(name = 'sample') { + const schema = new SchemaState(); + + // Add sample tables + schema.addObject('tables', 'users', { + columns: ['id', 'email', 'created_at'], + sql: 'CREATE TABLE users (id SERIAL PRIMARY KEY, email VARCHAR(255), created_at TIMESTAMP)' + }); + + schema.addObject('tables', 'posts', { + columns: ['id', 'user_id', 'title', 'content'], + sql: 'CREATE TABLE posts (id SERIAL PRIMARY KEY, user_id INTEGER REFERENCES users(id), title VARCHAR(255), content TEXT)' + }); + + // Add sample views + schema.addObject('views', 'user_posts', { + sql: 'CREATE VIEW user_posts AS SELECT u.email, p.title FROM users u JOIN posts p ON u.id = p.user_id' + }); + + // Add sample indexes + schema.addObject('indexes', 'idx_posts_user_id', { + table: 'posts', + columns: ['user_id'], + sql: 'CREATE INDEX idx_posts_user_id ON posts(user_id)' + }); + + // Generate checksum + schema.generateChecksum(this.cryptoPort); + + return schema; + } + + /** + * Get package information and capabilities + * @returns {Object} Package metadata and capabilities + */ + getPackageInfo() { + return { + name: '@data/core', + version: VERSION, + type: 'pure-javascript', + ioDepencencies: 'none', + capabilities: { + sqlDependencyAnalysis: true, + migrationDiffCalculation: true, + executionPlanCompilation: true, + rollbackPlanGeneration: true, + circularDependencyDetection: true, + operationOptimization: true + }, + portInterfaces: ['FileSystemPort', 'CryptoPort', 'ProcessPort', 'EnvironmentPort'], + coreEngines: ['SqlGraph', 'DiffEngine', 'PlanCompiler'] + }; + } +} diff --git a/starfleet/data-core/package.json b/starfleet/data-core/package.json new file mode 100644 index 0000000..655fffd --- /dev/null +++ b/starfleet/data-core/package.json @@ -0,0 +1,42 @@ +{ + "name": "@starfleet/data-core", + "version": "1.0.0", + "description": "Pure JavaScript logic core for D.A.T.A. with zero I/O dependencies", + "type": "module", + "main": "./src/index.js", + "exports": { + ".": "./src/index.js", + "./migration/*": "./src/migration/*", + "./domain/*": "./src/domain/*", + "./config/*": "./src/config/*", + "./testing/*": "./src/testing/*", + "./application/*": "./src/application/*", + "./events/*": "./src/events/*", + "./ports/*": "./src/ports/*" + }, + "scripts": { + "lint": "eslint \"src/**/*.{js,mjs,cjs,ts,tsx}\"", + "test": "vitest --run --passWithNoTests", + "build": "echo \"No build needed for pure JS\"" + }, + "keywords": [ + "data", + "database", + "migration", + "sql", + "dependency-injection", + "ports-adapters" + ], + "author": "Flyingrobots Development Team", + "license": "MIT", + "engines": { + "node": ">=18.0.0" + }, + "files": [ + "src" + ], + "sideEffects": false, + "publishConfig": { + "access": "public" + } +} \ No newline at end of file diff --git a/starfleet/data-core/ports/DIContainer.js b/starfleet/data-core/ports/DIContainer.js new file mode 100644 index 0000000..1f5cc3d --- /dev/null +++ b/starfleet/data-core/ports/DIContainer.js @@ -0,0 +1,353 @@ +/** + * Dependency Injection Container for data-core package. + * Manages service registration, resolution, and lifecycle. + * Supports constructor injection with automatic wiring. + * + * @fileoverview Lightweight DI container with circular dependency detection + */ + +/** + * Service registration configuration + * @typedef {Object} ServiceConfig + * @property {boolean} singleton - Whether to create single instance (default: false) + * @property {Array} dependencies - Manual dependency specification + * @property {Function} factory - Custom factory function + * @property {Object} config - Configuration to pass to constructor + */ + +/** + * Dependency injection container with automatic wiring capabilities. + * Manages service lifecycles and resolves constructor dependencies. + */ +export class DIContainer { + constructor() { + /** @type {Map} */ + this._services = new Map(); + + /** @type {Set} Currently resolving services for circular dependency detection */ + this._resolving = new Set(); + + /** @type {Map} Singleton instances cache */ + this._singletons = new Map(); + } + + /** + * Register a service with the container. + * + * @param {string} name - Service name/key + * @param {Function} constructor - Service constructor function + * @param {ServiceConfig} [config={}] - Registration configuration + * @returns {DIContainer} This container for chaining + * + * @example + * ```javascript + * container + * .register('fileSystem', FileSystemAdapter, { singleton: true }) + * .register('dataCore', DataCore, { + * dependencies: ['fileSystem', 'crypto', 'process', 'environment'] + * }); + * ``` + */ + register(name, constructor, config = {}) { + if (typeof name !== 'string' || !name.trim()) { + throw new Error('Service name must be a non-empty string'); + } + + // Allow null constructor if factory is provided + if (!config.factory && typeof constructor !== 'function') { + throw new Error('Service constructor must be a function'); + } + + this._services.set(name, { + constructor, + singleton: config.singleton || false, + dependencies: config.dependencies || null, + factory: config.factory || null, + config: config.config || {} + }); + + return this; + } + + /** + * Register a singleton service (convenience method). + * + * @param {string} name - Service name + * @param {Function} constructor - Service constructor + * @param {Object} [config={}] - Additional configuration + * @returns {DIContainer} This container for chaining + */ + registerSingleton(name, constructor, config = {}) { + return this.register(name, constructor, { ...config, singleton: true }); + } + + /** + * Register a factory function for creating services. + * + * @param {string} name - Service name + * @param {Function} factory - Factory function that returns service instance + * @param {Object} [config={}] - Additional configuration + * @returns {DIContainer} This container for chaining + * + * @example + * ```javascript + * container.registerFactory('database', (container) => { + * const config = container.resolve('config'); + * return new DatabaseConnection(config.connectionString); + * }); + * ``` + */ + registerFactory(name, factory, config = {}) { + if (typeof factory !== 'function') { + throw new Error('Factory must be a function'); + } + + return this.register(name, null, { ...config, factory }); + } + + /** + * Register an existing instance as a singleton. + * + * @param {string} name - Service name + * @param {any} instance - Service instance + * @returns {DIContainer} This container for chaining + */ + registerInstance(name, instance) { + this._singletons.set(name, instance); + return this; + } + + /** + * Resolve a service by name with automatic dependency injection. + * + * @param {string} name - Service name to resolve + * @returns {any} Service instance + * @throws {Error} If service not found or circular dependency detected + * + * @example + * ```javascript + * const dataCore = container.resolve('dataCore'); + * // All dependencies automatically injected + * ``` + */ + resolve(name) { + if (typeof name !== 'string') { + throw new Error('Service name must be a string'); + } + + // Check for existing singleton instance + if (this._singletons.has(name)) { + return this._singletons.get(name); + } + + // Check for circular dependency + if (this._resolving.has(name)) { + const resolvingArray = Array.from(this._resolving); + throw new Error(`Circular dependency detected: ${resolvingArray.join(' -> ')} -> ${name}`); + } + + // Get service configuration + const service = this._services.get(name); + if (!service) { + throw new Error(`Service '${name}' not registered`); + } + + // Track this service as currently resolving + this._resolving.add(name); + + try { + let instance; + + if (service.factory) { + // Use custom factory + instance = service.factory(this); + } else { + // Resolve constructor dependencies + const dependencies = this._resolveDependencies(service); + + // Add config to dependencies if it exists and no explicit dependencies were specified + if (service.config && Object.keys(service.config).length > 0 && dependencies.length === 0) { + dependencies.push(service.config); + } + + // Create instance with dependencies + instance = new service.constructor(...dependencies); + } + + // Cache singleton instances + if (service.singleton) { + this._singletons.set(name, instance); + } + + return instance; + } finally { + // Remove from resolving set + this._resolving.delete(name); + } + } + + /** + * Resolve multiple services at once. + * + * @param {string[]} names - Service names to resolve + * @returns {Object} Object with resolved services keyed by name + * + * @example + * ```javascript + * const { fileSystem, process, environment } = container.resolveMultiple([ + * 'fileSystem', 'process', 'environment' + * ]); + * ``` + */ + resolveMultiple(names) { + if (!Array.isArray(names)) { + throw new Error('Names must be an array'); + } + + const resolved = {}; + for (const name of names) { + resolved[name] = this.resolve(name); + } + return resolved; + } + + /** + * Check if a service is registered. + * + * @param {string} name - Service name + * @returns {boolean} True if service is registered + */ + has(name) { + return this._services.has(name) || this._singletons.has(name); + } + + /** + * Create a child container that inherits from this container. + * Useful for scoping services or creating test containers. + * + * @returns {DIContainer} Child container + */ + createChildContainer() { + const child = new DIContainer(); + + // Copy parent services (not instances) + for (const [name, service] of this._services) { + child._services.set(name, { ...service }); + } + + // Reference to parent for fallback resolution + child._parent = this; + + return child; + } + + /** + * Auto-wire a constructor by analyzing its parameter names. + * This is a convenience method for simple dependency injection scenarios. + * + * @param {Function} constructor - Constructor to analyze and wire + * @param {Object} [overrides={}] - Manual dependency overrides + * @returns {any} New instance with dependencies injected + * + * @example + * ```javascript + * class MyService { + * constructor(fileSystem, process) { ... } + * } + * + * const instance = container.autoWire(MyService); + * // fileSystem and process automatically resolved and injected + * ``` + */ + autoWire(constructor, overrides = {}) { + if (typeof constructor !== 'function') { + throw new Error('Constructor must be a function'); + } + + const dependencies = this._extractParameterNames(constructor); + const resolvedDependencies = dependencies.map((name) => { + if (overrides.hasOwnProperty(name)) { + return overrides[name]; + } + return this.resolve(name); + }); + + return new constructor(...resolvedDependencies); + } + + /** + * Clear all services and singletons. + * Useful for testing or container cleanup. + */ + clear() { + this._services.clear(); + this._singletons.clear(); + this._resolving.clear(); + } + + /** + * Get container statistics for debugging. + * + * @returns {Object} Container statistics + */ + getStats() { + return { + totalServices: this._services.size, + singletonInstances: this._singletons.size, + currentlyResolving: this._resolving.size, + services: Array.from(this._services.keys()).sort(), + singletons: Array.from(this._singletons.keys()).sort() + }; + } + + /** + * Resolve dependencies for a service based on its configuration. + * + * @private + * @param {Object} service - Service configuration + * @returns {Array} Resolved dependency instances + */ + _resolveDependencies(service) { + if (service.dependencies) { + // Use explicitly specified dependencies + return service.dependencies.map((dep) => this.resolve(dep)); + } else { + // Try to auto-wire constructor parameters + const paramNames = this._extractParameterNames(service.constructor); + return paramNames.map((name) => { + try { + return this.resolve(name); + } catch (error) { + throw new Error(`Failed to resolve dependency '${name}' for service: ${error.message}`); + } + }); + } + } + + /** + * Extract parameter names from a function for auto-wiring. + * Uses function.toString() to parse parameter names. + * + * @private + * @param {Function} func - Function to analyze + * @returns {string[]} Parameter names + */ + _extractParameterNames(func) { + const funcStr = func.toString(); + + // Match constructor parameters + const match = funcStr.match(/constructor\s*\(([^)]*)\)/); + if (!match || !match[1].trim()) { + return []; + } + + return match[1] + .split(',') + .map((param) => { + // Handle default parameters: name = 'default' -> name + const cleaned = param.trim().split('=')[0].trim(); + return cleaned.split(/\s+/)[0]; // Remove type annotations + }) + .filter((param) => param && param !== '...' && !param.startsWith('{')); // Filter out rest params and destructuring + } +} diff --git a/starfleet/data-core/ports/PortFactory.js b/starfleet/data-core/ports/PortFactory.js new file mode 100644 index 0000000..f3fce63 --- /dev/null +++ b/starfleet/data-core/ports/PortFactory.js @@ -0,0 +1,368 @@ +/** + * Factory for creating and configuring port instances. + * Provides standardized ways to create data-core ports with proper validation. + * Integrates with DIContainer for automatic dependency resolution. + * + * @fileoverview Port factory with configuration support and validation + */ + +import { FileSystemPort, CryptoPort, ProcessPort, EnvironmentPort, validatePort } from './index.js'; + +/** + * Port configuration options + * @typedef {Object} PortConfig + * @property {string} [type] - Port type identifier + * @property {Object} [config] - Port-specific configuration + * @property {boolean} [validate=true] - Whether to validate port implementation + * @property {string[]} [requiredMethods] - Custom method validation list + */ + +/** + * Factory for creating and managing port instances. + * Handles port creation, configuration, and validation in a standardized way. + */ +export class PortFactory { + constructor() { + /** @type {Map} Registered port constructors */ + this._portConstructors = new Map(); + + /** @type {Map} Registered port classes for validation */ + this._portClasses = new Map(); + + /** @type {Map} Default configurations by port type */ + this._defaultConfigs = new Map(); + + // Register built-in port types + this._registerBuiltinPorts(); + } + + /** + * Register a port constructor with the factory. + * + * @param {string} type - Port type identifier + * @param {Function} constructor - Port constructor function + * @param {Function} portClass - Port interface class for validation + * @param {Object} [defaultConfig={}] - Default configuration + * @returns {PortFactory} This factory for chaining + * + * @example + * ```javascript + * factory.registerPort('fileSystem', FileSystemAdapter, FileSystemPort, { + * encoding: 'utf8', + * mode: 0o644 + * }); + * ``` + */ + registerPort(type, constructor, portClass, defaultConfig = {}) { + if (typeof type !== 'string' || !type.trim()) { + throw new Error('Port type must be a non-empty string'); + } + + if (typeof constructor !== 'function') { + throw new Error('Port constructor must be a function'); + } + + if (typeof portClass !== 'function') { + throw new Error('Port class must be a function'); + } + + this._portConstructors.set(type, constructor); + this._portClasses.set(type, portClass); + this._defaultConfigs.set(type, defaultConfig); + + return this; + } + + /** + * Create a port instance of the specified type. + * + * @param {string} type - Port type to create + * @param {Object} [config={}] - Port configuration + * @param {PortConfig} [options={}] - Creation options + * @returns {Object} Created port instance + * @throws {Error} If port type not registered or validation fails + * + * @example + * ```javascript + * const fileSystem = factory.createPort('fileSystem', { + * encoding: 'utf8', + * baseDir: '/app/data' + * }); + * ``` + */ + createPort(type, config = {}, options = {}) { + const constructor = this._portConstructors.get(type); + if (!constructor) { + throw new Error(`Port type '${type}' not registered`); + } + + // Merge with default configuration + const defaultConfig = this._defaultConfigs.get(type) || {}; + const finalConfig = { ...defaultConfig, ...config }; + + // Create port instance + const port = new constructor(finalConfig); + + // Validate port implementation if requested + if (options.validate !== false) { + this._validatePort(port, type, options); + } + + return port; + } + + /** + * Create multiple ports at once. + * + * @param {Object} portConfigs - Map of port type to config + * @param {PortConfig} [options={}] - Global creation options + * @returns {Object} Map of port type to instance + * + * @example + * ```javascript + * const ports = factory.createPorts({ + * fileSystem: { encoding: 'utf8' }, + * process: { timeout: 30000 }, + * environment: { prefix: 'DATA_' } + * }); + * ``` + */ + createPorts(portConfigs, options = {}) { + if (typeof portConfigs !== 'object' || portConfigs === null) { + throw new Error('Port configs must be an object'); + } + + const ports = {}; + for (const [type, config] of Object.entries(portConfigs)) { + ports[type] = this.createPort(type, config, options); + } + return ports; + } + + /** + * Create a complete set of data-core compatible ports. + * Creates all required ports for DataCore with sensible defaults. + * + * @param {Object} [configs={}] - Port-specific configurations + * @param {Object} [configs.fileSystem] - FileSystem port config + * @param {Object} [configs.crypto] - Crypto port config + * @param {Object} [configs.process] - Process port config + * @param {Object} [configs.environment] - Environment port config + * @param {PortConfig} [options={}] - Creation options + * @returns {Object} Complete set of data-core ports + * + * @example + * ```javascript + * const ports = factory.createDataCorePorts({ + * fileSystem: { encoding: 'utf8' }, + * process: { timeout: 30000 } + * }); + * + * const dataCore = new DataCore( + * ports.fileSystem, + * ports.crypto, + * ports.process, + * ports.environment + * ); + * ``` + */ + createDataCorePorts(configs = {}, options = {}) { + const requiredPorts = ['fileSystem', 'crypto', 'process', 'environment']; + + // Ensure all required ports are registered + for (const portType of requiredPorts) { + if (!this._portConstructors.has(portType)) { + throw new Error(`Required port type '${portType}' not registered`); + } + } + + return this.createPorts( + { + fileSystem: configs.fileSystem || {}, + crypto: configs.crypto || {}, + process: configs.process || {}, + environment: configs.environment || {} + }, + options + ); + } + + /** + * Register ports with a DI container. + * Convenience method for integrating with dependency injection. + * + * @param {DIContainer} container - DI container to register with + * @param {Object} [portConfigs={}] - Port configurations + * @param {Object} [registrationOptions={}] - DI registration options + * @param {boolean} [registrationOptions.singleton=true] - Register as singletons + * @returns {PortFactory} This factory for chaining + * + * @example + * ```javascript + * const container = new DIContainer(); + * factory.registerWithContainer(container, { + * fileSystem: { encoding: 'utf8' }, + * process: { timeout: 30000 } + * }); + * + * // Now can resolve ports from container + * const fileSystem = container.resolve('fileSystem'); + * ``` + */ + registerWithContainer(container, portConfigs = {}, registrationOptions = {}) { + const singleton = registrationOptions.singleton !== false; + + for (const [type, constructor] of this._portConstructors) { + const config = portConfigs[type] || {}; + + container.registerFactory( + type, + () => { + return this.createPort(type, config); + }, + { singleton } + ); + } + + return this; + } + + /** + * Get information about registered port types. + * + * @returns {Object} Port factory information + */ + getPortInfo() { + const portInfo = {}; + + for (const type of this._portConstructors.keys()) { + const constructor = this._portConstructors.get(type); + const portClass = this._portClasses.get(type); + const defaultConfig = this._defaultConfigs.get(type); + + portInfo[type] = { + constructorName: constructor.name, + interfaceClass: portClass.name, + defaultConfig: { ...defaultConfig }, + requiredMethods: this._getRequiredMethods(portClass) + }; + } + + return { + registeredPorts: Object.keys(portInfo).sort(), + portDetails: portInfo + }; + } + + /** + * Validate that a port implements the required interface. + * + * @private + * @param {Object} port - Port instance to validate + * @param {string} type - Port type + * @param {PortConfig} options - Validation options + * @throws {Error} If validation fails + */ + _validatePort(port, type, options) { + const portClass = this._portClasses.get(type); + if (!portClass) { + return; // No validation class registered + } + + // Use built-in validation + validatePort(port, portClass); + + // Additional method validation if specified + if (options.requiredMethods) { + for (const method of options.requiredMethods) { + if (typeof port[method] !== 'function') { + throw new Error(`Port '${type}' missing required method: ${method}`); + } + } + } + } + + /** + * Get required method names from a port class. + * + * @private + * @param {Function} portClass - Port class to analyze + * @returns {string[]} Required method names + */ + _getRequiredMethods(portClass) { + const methods = []; + const proto = portClass.prototype; + + for (const name of Object.getOwnPropertyNames(proto)) { + if (name !== 'constructor' && typeof proto[name] === 'function') { + methods.push(name); + } + } + + return methods.sort(); + } + + /** + * Register built-in port types that come with data-core. + * + * @private + */ + _registerBuiltinPorts() { + // These are just the interface classes - actual implementations + // will be registered by the host packages (like data-host-node) + this._portClasses.set('fileSystem', FileSystemPort); + this._portClasses.set('crypto', CryptoPort); + this._portClasses.set('process', ProcessPort); + this._portClasses.set('environment', EnvironmentPort); + } +} + +/** + * Create a pre-configured port factory instance. + * + * @param {Object} [options={}] - Factory configuration options + * @returns {PortFactory} Configured port factory + */ +export function createPortFactory(options = {}) { + return new PortFactory(); +} + +/** + * Convenience function to create ports and wire them with a DataCore instance. + * + * @param {Function} DataCore - DataCore constructor + * @param {Object} adapters - Map of adapter constructors by type + * @param {Object} [configs={}] - Port configurations + * @returns {Object} Object with both ports and wired DataCore instance + * + * @example + * ```javascript + * import { DataCore } from 'data-core'; + * import { FileSystemAdapter, ProcessAdapter } from 'data-host-node'; + * + * const { ports, dataCore } = wireDataCore(DataCore, { + * fileSystem: FileSystemAdapter, + * process: ProcessAdapter, + * // ... other adapters + * }); + * ``` + */ +export function wireDataCore(DataCore, adapters, configs = {}) { + const factory = createPortFactory(); + + // Register adapters with factory + for (const [type, adapter] of Object.entries(adapters)) { + const portClass = factory._portClasses.get(type); + if (portClass) { + factory.registerPort(type, adapter, portClass, configs[type] || {}); + } + } + + // Create all required ports + const ports = factory.createDataCorePorts(configs); + + // Create DataCore instance with wired ports + const dataCore = new DataCore(ports.fileSystem, ports.crypto, ports.process, ports.environment); + + return { ports, dataCore, factory }; +} diff --git a/starfleet/data-core/ports/index.js b/starfleet/data-core/ports/index.js new file mode 100644 index 0000000..38a4b1c --- /dev/null +++ b/starfleet/data-core/ports/index.js @@ -0,0 +1,109 @@ +/** + * Port interfaces for dependency injection in data-core package. + * These define the contracts that external adapters must implement. + * All ports are validated at runtime using instanceof checks. + * + * @fileoverview Core port definitions for I/O abstraction + */ + +/** + * File system port for reading files and globbing patterns. + * Provides abstraction over file system operations. + */ +export class FileSystemPort { + /** + * Read file contents as string + * @param {string} path - Absolute file path + * @returns {Promise} File contents + * @throws {Error} If file cannot be read + */ + async readFile(path) { + throw new Error('FileSystemPort.readFile must be implemented'); + } + + /** + * Find files matching glob patterns + * @param {string[]} patterns - Glob patterns to match + * @param {string} [cwd] - Working directory for glob search + * @returns {Promise} Array of matching file paths + */ + async glob(patterns, cwd = process.cwd()) { + throw new Error('FileSystemPort.glob must be implemented'); + } +} + +/** + * Cryptographic port for hashing operations. + * Provides abstraction over crypto operations. + */ +export class CryptoPort { + /** + * Generate hash of byte data + * @param {Buffer|Uint8Array|string} data - Data to hash + * @param {string} [algorithm='sha256'] - Hash algorithm + * @returns {string} Hex-encoded hash + */ + hash(data, algorithm = 'sha256') { + throw new Error('CryptoPort.hash must be implemented'); + } +} + +/** + * Process port for spawning child processes. + * Provides abstraction over process execution. + */ +export class ProcessPort { + /** + * Spawn child process with command and arguments + * @param {string} command - Command to execute + * @param {string[]} args - Command arguments + * @param {Object} [options] - Spawn options + * @param {string} [options.cwd] - Working directory + * @param {Object} [options.env] - Environment variables + * @returns {Promise<{stdout: string, stderr: string, exitCode: number}>} + */ + async spawn(command, args = [], options = {}) { + throw new Error('ProcessPort.spawn must be implemented'); + } +} + +/** + * Environment port for accessing environment variables. + * Provides abstraction over environment access. + */ +export class EnvironmentPort { + /** + * Get environment variable value + * @param {string} key - Environment variable name + * @param {string} [defaultValue] - Default value if not found + * @returns {string|undefined} Environment variable value + */ + get(key, defaultValue) { + throw new Error('EnvironmentPort.get must be implemented'); + } + + /** + * Check if environment variable exists + * @param {string} key - Environment variable name + * @returns {boolean} True if variable exists + */ + has(key) { + throw new Error('EnvironmentPort.has must be implemented'); + } +} + +/** + * Validate that an object implements the required port interface + * @param {Object} port - Port implementation to validate + * @param {Function} PortClass - Port class to validate against + * @throws {Error} If port doesn't implement required interface + */ +export function validatePort(port, PortClass) { + if (!(port instanceof PortClass)) { + throw new Error(`Port must be instance of ${PortClass.name}`); + } +} + +// Export dependency injection components +export { DIContainer } from './DIContainer.js'; +export { PortFactory, wireDataCore, createPortFactory } from './PortFactory.js'; diff --git a/starfleet/data-core/src/ArchyErrorBase.js b/starfleet/data-core/src/ArchyErrorBase.js new file mode 100644 index 0000000..dc6cea5 --- /dev/null +++ b/starfleet/data-core/src/ArchyErrorBase.js @@ -0,0 +1,69 @@ +/** + * Custom error class for data-related errors. + * Includes error code and context for better debugging. + * @class dataErrorBase + * @extends Error + */ +export class dataErrorBase extends Error { + /** + * Constructor for dataError + * @param {string} message Error message + * @param {number} code Error code + * @param {object} context Contextual information about the error + * @constructor + */ + constructor(message, code, context = {}) { + if (new.target === dataErrorBase) { + throw new TypeError('Cannot construct dataErrorBase instances directly'); + } + + if (typeof code !== 'number') { + throw new TypeError('Error code must be a number'); + } + + if (typeof message !== 'string' || message.trim() === '') { + throw new TypeError('Error message must be a non-empty string'); + } + + super(message); + + this.name = this.constructor.name; + this.timestamp = new Date().toISOString(); + this.code = code; + this.context = context; + } + + /** + * Error code associated with the error + * @returns {number} Error code + */ + getCode() { + return this.code; + } + + /** + * Contextual information about the error + * @returns {object} Context + */ + getContext() { + return this.context; + } + + /** + * Timestamp when the error was created + * @returns {string} ISO timestamp + */ + getTimestamp() { + return this.timestamp; + } + + /** + * Error message + * @returns {string} Error message + */ + getMessage() { + return this.message; + } +} + +export default dataErrorBase; diff --git a/starfleet/data-core/src/CommandEvent.cjs b/starfleet/data-core/src/CommandEvent.cjs new file mode 100644 index 0000000..ad80c3a --- /dev/null +++ b/starfleet/data-core/src/CommandEvent.cjs @@ -0,0 +1,107 @@ +/** + * Base Command Event Class for D.A.T.A. CLI + * + * This module provides the foundational CommandEvent class for the event-driven + * architecture used throughout the D.A.T.A. (Database Automation, Testing, and + * Alignment) CLI tool. All events support instanceof checks for runtime type safety. + * + * @fileoverview Base event class for robust event-driven command architecture + * @author Supa Base 12 Engineering Team + * @version 1.0.0 + */ + +/** + * @typedef {Object} EventDetails + * @property {string} [directoryName] - Name of directory being processed + * @property {number} [filesProcessed] - Count of files processed + * @property {number} [totalFiles] - Total number of files to process + * @property {string} [filePath] - Path to file being processed + * @property {string} [operation] - Type of operation being performed + * @property {string} [stage] - Current stage of operation + * @property {Error} [error] - Error object if applicable + * @property {string} [code] - Error code for categorization + * @property {boolean} [isProd] - Whether operation is in production mode + * @property {Object} [metadata] - Additional metadata for the event + */ + +/** + * Base class for all command events in the D.A.T.A. system + * + * Provides the foundational structure for all events emitted by commands. + * All events include a timestamp and support structured data through the + * details property. + * + * @class + */ +class CommandEvent { + /** + * Create a new command event + * + * @param {string} type - Event type identifier (e.g., 'progress', 'error') + * @param {string} message - Human-readable message describing the event + * @param {EventDetails} [details={}] - Additional structured data + */ + constructor(type, message, details = {}) { + /** + * @type {string} Event type identifier + */ + this.type = type; + + /** + * @type {string} Human-readable message + */ + this.message = message; + + /** + * @type {EventDetails} Additional structured event data + */ + this.details = details; + + /** + * @type {Date} Timestamp when event was created + */ + this.timestamp = new Date(); + } + + /** + * Convert event to JSON-serializable object + * + * @returns {Object} JSON representation of the event + */ + toJSON() { + return { + type: this.type, + message: this.message, + details: this.details, + timestamp: this.timestamp.toISOString() + }; + } + + /** + * Get a string representation of the event + * + * @returns {string} String representation + */ + toString() { + return `[${this.type.toUpperCase()}] ${this.message}`; + } + + /** + * Convert to event data format expected by emit() + * + * This method provides backward compatibility with the existing event system + * by converting event instances to the object format expected by listeners. + * + * @returns {Object} Event data in the format expected by emit() + */ + toEventData() { + return { + message: this.message, + data: this.details, + timestamp: this.timestamp, + type: this.type + }; + } +} + +module.exports = CommandEvent; \ No newline at end of file diff --git a/starfleet/data-core/src/ConfigSchema.js b/starfleet/data-core/src/ConfigSchema.js new file mode 100644 index 0000000..b340cf4 --- /dev/null +++ b/starfleet/data-core/src/ConfigSchema.js @@ -0,0 +1,251 @@ +/** + * Configuration schema definitions and validation logic + * Pure configuration structure definitions without environment variable reads + */ + +import { safeParsedataConfig, mergeConfigs } from './schemas/DataConfigSchema.js'; + +/** + * Configuration schema and validation utilities + * Does not read environment variables - that's handled by the host layer + */ +export class ConfigSchema { + constructor() { + // Default configuration structure (no env vars) + this.defaultStructure = { + environments: { + local: { + db: 'postgresql://postgres:postgres@127.0.0.1:54332/postgres', + supabase_url: null, + supabase_anon_key: null, + supabase_service_role_key: null + } + }, + paths: { + sql_dir: './sql', + tests_dir: './tests', + migrations_dir: './migrations', + functions_dir: './functions', + schemas_dir: './schemas' + }, + test: { + minimum_coverage: 80, + test_timeout: 300, + output_formats: ['console', 'json'] + }, + safety: { + require_prod_flag: true, + require_confirmation: true + } + }; + } + + /** + * Get default configuration structure + * @param {Object} overrides - Configuration overrides + * @returns {Object} Default configuration with overrides applied + */ + getDefaultConfig(overrides = {}) { + return this.merge(this.defaultStructure, overrides); + } + + /** + * Validate configuration object + * @param {Object} config - Configuration to validate + * @returns {Object} Validation result + */ + validate(config) { + const result = safeParsedataConfig(config); + if (!result.success) { + return { + valid: false, + errors: result.error.errors.map((err) => ({ + path: err.path.join('.'), + message: err.message + })) + }; + } + return { valid: true, data: result.data }; + } + + /** + * Deep merge configuration objects + * @param {Object} base - Base configuration + * @param {Object} overrides - Configuration overrides + * @returns {Object} Merged configuration + */ + merge(base, overrides) { + if (!overrides || typeof overrides !== 'object') { + return { ...base }; + } + + const result = { ...base }; + + for (const key in overrides) { + if ( + typeof overrides[key] === 'object' && + !Array.isArray(overrides[key]) && + overrides[key] !== null + ) { + result[key] = this.merge(base[key] || {}, overrides[key]); + } else { + result[key] = overrides[key]; + } + } + + return result; + } + + /** + * Extract configuration value by path + * @param {Object} config - Configuration object + * @param {string} path - Dot-separated path (e.g., 'test.minimum_coverage') + * @returns {*} Configuration value or undefined + */ + getValue(config, path) { + if (!config || !path) return undefined; + + const keys = path.split('.'); + let value = config; + + for (const key of keys) { + if (value && typeof value === 'object') { + value = value[key]; + } else { + return undefined; + } + } + + return value; + } + + /** + * Set configuration value by path + * @param {Object} config - Configuration object to modify + * @param {string} path - Dot-separated path + * @param {*} value - Value to set + * @returns {Object} Modified configuration object + */ + setValue(config, path, value) { + if (!config || !path) return config; + + const keys = path.split('.'); + const lastKey = keys.pop(); + let target = config; + + // Navigate to the parent object + for (const key of keys) { + if (!target[key] || typeof target[key] !== 'object') { + target[key] = {}; + } + target = target[key]; + } + + target[lastKey] = value; + return config; + } + + /** + * Get test configuration from full config + * @param {Object} config - Full configuration object + * @returns {Object} Test configuration section + */ + getTestConfig(config) { + return this.getValue(config, 'test') || this.defaultStructure.test; + } + + /** + * Get environment configuration + * @param {Object} config - Full configuration object + * @param {string} environmentName - Environment name (e.g., 'local', 'prod') + * @returns {Object} Environment configuration + */ + getEnvironmentConfig(config, environmentName = 'local') { + const envs = this.getValue(config, 'environments') || {}; + return envs[environmentName] || this.defaultStructure.environments.local; + } + + /** + * Get paths configuration + * @param {Object} config - Full configuration object + * @returns {Object} Paths configuration + */ + getPathsConfig(config) { + return this.getValue(config, 'paths') || this.defaultStructure.paths; + } + + /** + * Get safety configuration + * @param {Object} config - Full configuration object + * @returns {Object} Safety configuration + */ + getSafetyConfig(config) { + return this.getValue(config, 'safety') || this.defaultStructure.safety; + } + + /** + * Validate and merge configurations using schema + * @param {Object} baseConfig - Base configuration + * @param {Object} overrideConfig - Override configuration + * @returns {Object} Merged and validated configuration + */ + mergeAndValidate(baseConfig, overrideConfig) { + try { + return mergeConfigs(baseConfig, overrideConfig); + } catch (error) { + throw new Error(`Configuration merge failed: ${error.message}`); + } + } + + /** + * Create configuration template + * @param {Object} customValues - Custom values to include + * @returns {Object} Configuration template + */ + createTemplate(customValues = {}) { + const template = { + $schema: './datarc.schema.json', + ...this.getDefaultConfig(customValues) + }; + + // Add helpful comments structure + template._comments = { + environments: 'Database connection settings for different environments', + paths: 'File system paths for SQL, tests, migrations, etc.', + test: 'Test execution and coverage settings', + safety: 'Production safety gate configurations' + }; + + return template; + } + + /** + * Check if configuration has required fields + * @param {Object} config - Configuration to check + * @returns {Object} Check result with missing fields + */ + checkRequiredFields(config) { + const required = ['environments', 'paths']; + + const missing = []; + + for (const field of required) { + if (!this.getValue(config, field)) { + missing.push(field); + } + } + + // Check for at least one environment + const envs = this.getValue(config, 'environments'); + if (envs && Object.keys(envs).length === 0) { + missing.push('environments (at least one environment required)'); + } + + return { + valid: missing.length === 0, + missing + }; + } +} + +export default ConfigSchema; diff --git a/src/lib/DataInputPaths.js b/starfleet/data-core/src/DataInputPaths.js similarity index 95% rename from src/lib/DataInputPaths.js rename to starfleet/data-core/src/DataInputPaths.js index dd3fbc7..c1cbb72 100644 --- a/src/lib/DataInputPaths.js +++ b/starfleet/data-core/src/DataInputPaths.js @@ -1,9 +1,9 @@ -const PathResolver = require('./PathResolver'); -const path = require('path'); +import PathResolver from './PathResolver.js'; +import path from 'path'; /** * dataInputPaths - Manages all input/read sources for data - * + * * This class handles all directories where data reads files from. * It uses PathResolver to ensure directories exist and are readable. * All paths are resolved to absolute paths and cached. @@ -27,7 +27,7 @@ class DataInputPaths { pathResolver = null ) { this.pathResolver = pathResolver || new PathResolver(); - + // Store configuration with defaults this._config = { sqlDir: sqlDir || process.env.data_SQL_DIR || './sql', @@ -36,11 +36,11 @@ class DataInputPaths { schemasDir: schemasDir || process.env.data_SCHEMAS_DIR || './schemas', configDir: configDir || process.env.data_CONFIG_DIR || '.' }; - + // Cache for resolved paths this._resolvedPaths = {}; this._resolving = {}; // Prevent duplicate resolution attempts - + // Cache for file listings this._fileCache = {}; } @@ -143,7 +143,7 @@ class DataInputPaths { if (!Object.prototype.hasOwnProperty.call(this._config, key)) { throw new Error(`Unknown path configuration: ${key}`); } - + try { await this.pathResolver.resolveDirectoryForRead(this._config[key]); return true; @@ -159,12 +159,12 @@ class DataInputPaths { * @returns {Promise} First existing path or null */ async findDirectory(key, candidates) { - const checkPromises = candidates.map(async candidate => { + const checkPromises = candidates.map(async (candidate) => { this._config[key] = candidate; const exists = await this.hasDirectory(key); return exists ? { candidate, exists } : null; }); - + const results = await Promise.allSettled(checkPromises); for (const result of results) { if (result.status === 'fulfilled' && result.value) { @@ -224,13 +224,14 @@ class DataInputPaths { } // Start resolution - this._resolving[key] = this.pathResolver.resolveDirectoryForRead(this._config[key]) - .then(resolved => { + this._resolving[key] = this.pathResolver + .resolveDirectoryForRead(this._config[key]) + .then((resolved) => { this._resolvedPaths[key] = resolved; delete this._resolving[key]; return resolved; }) - .catch(error => { + .catch((_error) => { delete this._resolving[key]; throw new Error(`Failed to resolve input path ${key}: ${error.message}`); }); @@ -239,4 +240,4 @@ class DataInputPaths { } } -module.exports = DataInputPaths; \ No newline at end of file +export default DataInputPaths; diff --git a/src/lib/DataOutputPaths.js b/starfleet/data-core/src/DataOutputPaths.js similarity index 94% rename from src/lib/DataOutputPaths.js rename to starfleet/data-core/src/DataOutputPaths.js index 1e01caa..8f11d43 100644 --- a/src/lib/DataOutputPaths.js +++ b/starfleet/data-core/src/DataOutputPaths.js @@ -1,9 +1,9 @@ -const PathResolver = require('./PathResolver'); -const path = require('path'); +import PathResolver from './PathResolver.js'; +import path from 'path'; /** * dataOutputPaths - Manages all output/write destinations for data - * + * * This class handles all directories where data writes files. * It uses PathResolver to ensure directories exist and are writable. * All paths are resolved to absolute paths and cached. @@ -25,7 +25,7 @@ class DataOutputPaths { pathResolver = null ) { this.pathResolver = pathResolver || new PathResolver(); - + // Store configuration this._config = { migrationsDir: migrationsDir || process.env.data_MIGRATIONS_DIR || './migrations', @@ -33,7 +33,7 @@ class DataOutputPaths { reportsDir: reportsDir || process.env.data_REPORTS_DIR || './reports', tempDir: tempDir || process.env.data_TEMP_DIR || './tmp' }; - + // Cache for resolved paths this._resolvedPaths = {}; this._resolving = {}; // Prevent duplicate resolution attempts @@ -158,13 +158,14 @@ class DataOutputPaths { } // Start resolution - this._resolving[key] = this.pathResolver.resolveDirectoryForWrite(this._config[key]) - .then(resolved => { + this._resolving[key] = this.pathResolver + .resolveDirectoryForWrite(this._config[key]) + .then((resolved) => { this._resolvedPaths[key] = resolved; delete this._resolving[key]; return resolved; }) - .catch(error => { + .catch((_error) => { delete this._resolving[key]; throw new Error(`Failed to resolve output path ${key}: ${error.message}`); }); @@ -173,4 +174,4 @@ class DataOutputPaths { } } -module.exports = DataOutputPaths; \ No newline at end of file +export default DataOutputPaths; diff --git a/src/lib/DiffEngine.js b/starfleet/data-core/src/DiffEngine.js similarity index 96% rename from src/lib/DiffEngine.js rename to starfleet/data-core/src/DiffEngine.js index b3820ae..1d536f1 100644 --- a/src/lib/DiffEngine.js +++ b/starfleet/data-core/src/DiffEngine.js @@ -1,9 +1,9 @@ -const EventEmitter = require('events'); -const DatabaseUtils = require('./db-utils'); +import EventEmitter from 'events'; +import DatabaseUtils from './db-utils.js'; /** * DiffEngine - Event-driven database schema difference generator - * + * * Emits events: * - 'start': When diff generation begins * - 'progress': During processing with step information @@ -13,7 +13,7 @@ const DatabaseUtils = require('./db-utils'); class DiffEngine extends EventEmitter { constructor(config = {}) { super(); - + // Configuration with defaults this.config = { // Diff generation options @@ -37,7 +37,7 @@ class DiffEngine extends EventEmitter { /** * Generate schema differences between current and desired database states - * + * * @param {Object} currentDb - Current database connection/state * @param {Object} desiredDb - Desired database connection/state * @param {Object} options - Override options for this diff operation @@ -82,7 +82,7 @@ class DiffEngine extends EventEmitter { // TODO: Actual diff logic will be implemented in P1.T005 // For now, return a placeholder result - + this.emit('progress', { step: 'analysis_complete', message: 'Schema analysis completed', @@ -114,10 +114,9 @@ class DiffEngine extends EventEmitter { }); return diffResult; - } catch (error) { this.endTime = new Date(); - + // Emit error event this.emit('error', { error, @@ -158,7 +157,7 @@ class DiffEngine extends EventEmitter { try { // Generate unique database name const dbName = this.dbUtils.generateTempDatabaseName(suffix); - + this.emit('progress', { step: 'temp_db_creating', message: `Creating temporary database: ${dbName}`, @@ -173,18 +172,18 @@ class DiffEngine extends EventEmitter { // Create the database const adminClient = this.dbUtils.createAdminClient(); - + try { await adminClient.connect(); - + // Use identifier to prevent SQL injection await adminClient.query(`CREATE DATABASE "${dbName}"`); - + // Track the temp database for cleanup this.tempDatabases.add(dbName); - + const connectionString = this.dbUtils.getConnectionString(dbName); - + this.emit('progress', { step: 'temp_db_created', message: `Temporary database created: ${dbName}`, @@ -194,11 +193,9 @@ class DiffEngine extends EventEmitter { }); return connectionString; - } finally { await adminClient.end(); } - } catch (error) { this.emit('error', { error, @@ -206,7 +203,7 @@ class DiffEngine extends EventEmitter { operation: 'createTempDatabase', timestamp: new Date() }); - + throw error; } } @@ -234,30 +231,33 @@ class DiffEngine extends EventEmitter { database: dbName, timestamp: new Date() }); - + // Remove from tracking set regardless this.tempDatabases.delete(dbName); return true; } const adminClient = this.dbUtils.createAdminClient(); - + try { await adminClient.connect(); - + // Terminate all connections to the database first - await adminClient.query(` + await adminClient.query( + ` SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid <> pg_backend_pid() - `, [dbName]); + `, + [dbName] + ); // Drop the database await adminClient.query(`DROP DATABASE IF EXISTS "${dbName}"`); - + // Remove from tracking set this.tempDatabases.delete(dbName); - + this.emit('progress', { step: 'temp_db_cleaned', message: `Temporary database cleaned up: ${dbName}`, @@ -266,11 +266,9 @@ class DiffEngine extends EventEmitter { }); return true; - } finally { await adminClient.end(); } - } catch (error) { this.emit('error', { error, @@ -279,7 +277,7 @@ class DiffEngine extends EventEmitter { database: dbName, timestamp: new Date() }); - + // Don't throw - cleanup should be non-fatal return false; } @@ -312,13 +310,13 @@ class DiffEngine extends EventEmitter { // Parse database URL to get connection parameters const url = new globalThis.URL(dbUrl); const client = this.dbUtils.createDatabaseClient(url.pathname.slice(1)); - + try { await client.connect(); - + // Apply the SQL schema using our utility method const result = await this.dbUtils.executeSql(client, sqlContent); - + this.emit('progress', { step: 'schema_applied', message: `Schema applied successfully to: ${dbName}`, @@ -333,11 +331,9 @@ class DiffEngine extends EventEmitter { statementsExecuted: result.statementCount, results: result.results }; - } finally { await client.end(); } - } catch (error) { this.emit('error', { error, @@ -346,7 +342,7 @@ class DiffEngine extends EventEmitter { database: dbName, timestamp: new Date() }); - + throw error; } } @@ -372,12 +368,12 @@ class DiffEngine extends EventEmitter { // Convert to array to avoid mutation during iteration const databasesToCleanup = Array.from(this.tempDatabases); - + // Process all cleanup operations in parallel const cleanupPromises = databasesToCleanup.map(async (dbName) => { summary.attempted++; summary.databases.push(dbName); - + try { const success = await this.cleanupTempDatabase(dbName); if (success) { @@ -389,7 +385,7 @@ class DiffEngine extends EventEmitter { summary.failed++; } }); - + await Promise.all(cleanupPromises); this.emit('progress', { @@ -418,7 +414,7 @@ class DiffEngine extends EventEmitter { if (!currentDb || typeof currentDb !== 'object') { throw new Error('currentDb parameter must be a valid database connection object'); } - + if (!desiredDb || typeof desiredDb !== 'object') { throw new Error('desiredDb parameter must be a valid database connection object'); } @@ -430,14 +426,14 @@ class DiffEngine extends EventEmitter { */ _sanitizeDbInfo(dbInfo) { if (!dbInfo) return null; - + return { host: dbInfo.host || 'unknown', port: dbInfo.port || 'unknown', - database: dbInfo.database || 'unknown', + database: dbInfo.database || 'unknown' // Never include passwords or sensitive connection info }; } } -module.exports = DiffEngine; \ No newline at end of file +export default DiffEngine; diff --git a/starfleet/data-core/src/GitDeploymentTracker.js b/starfleet/data-core/src/GitDeploymentTracker.js new file mode 100644 index 0000000..2198e91 --- /dev/null +++ b/starfleet/data-core/src/GitDeploymentTracker.js @@ -0,0 +1,319 @@ +/** + * Git Deployment Tracker Interfaces and Business Logic + * + * Pure interfaces and business logic for git-based deployment tracking. + * No process, filesystem, or I/O dependencies - only data structures and validation. + */ + +/** + * Git deployment tag prefix for D.A.T.A. deployments + */ +export const DEPLOYMENT_TAG_PREFIX = 'data-deploy-'; + +/** + * Deployment metadata structure + * @typedef {Object} DeploymentMetadata + * @property {string} migrationId - Unique migration identifier + * @property {number} operations - Number of operations executed + * @property {string} timestamp - ISO timestamp of deployment + * @property {string} environment - Environment (production/development) + * @property {string} [rollbackFrom] - Previous deployment tag if this is a rollback + */ + +/** + * Git working tree status structure + * @typedef {Object} WorkingTreeStatus + * @property {string[]} modified - Modified files + * @property {string[]} untracked - Untracked files + * @property {string[]} staged - Staged files + * @property {string[]} deleted - Deleted files + */ + +/** + * Git deployment business logic and validation + */ +export class GitDeploymentLogic { + /** + * Validate deployment metadata + * @param {DeploymentMetadata} metadata - Metadata to validate + * @returns {Object} Validation result + */ + validateDeploymentMetadata(metadata) { + const errors = []; + + if (!metadata || typeof metadata !== 'object') { + return { + valid: false, + errors: ['Deployment metadata must be an object'] + }; + } + + // Required fields + if (!metadata.migrationId || typeof metadata.migrationId !== 'string') { + errors.push('migrationId is required and must be a string'); + } + + if (typeof metadata.operations !== 'number' || metadata.operations < 0) { + errors.push('operations must be a non-negative number'); + } + + if (!metadata.timestamp || typeof metadata.timestamp !== 'string') { + errors.push('timestamp is required and must be a string'); + } else if (!this._isValidISO8601(metadata.timestamp)) { + errors.push('timestamp must be a valid ISO 8601 date string'); + } + + if (!metadata.environment || typeof metadata.environment !== 'string') { + errors.push('environment is required and must be a string'); + } + + // Optional rollbackFrom validation + if ( + metadata.rollbackFrom !== undefined && + (typeof metadata.rollbackFrom !== 'string' || metadata.rollbackFrom.trim() === '') + ) { + errors.push('rollbackFrom must be a non-empty string if provided'); + } + + return { + valid: errors.length === 0, + errors + }; + } + + /** + * Generate deployment tag name + * @param {string} environment - Environment name + * @param {string} migrationId - Migration identifier + * @param {string} timestamp - Optional timestamp (defaults to now) + * @returns {string} Generated tag name + */ + generateDeploymentTag(environment, migrationId, timestamp = null) { + if (!environment || typeof environment !== 'string') { + throw new Error('Environment is required and must be a string'); + } + + if (!migrationId || typeof migrationId !== 'string') { + throw new Error('Migration ID is required and must be a string'); + } + + const tagTimestamp = timestamp || new Date().toISOString().replace(/[:.]/g, '-'); + + return `${DEPLOYMENT_TAG_PREFIX}${environment}-${migrationId}-${tagTimestamp}`; + } + + /** + * Parse deployment tag to extract metadata + * @param {string} tagName - Tag name to parse + * @returns {Object} Parsed tag information + */ + parseDeploymentTag(tagName) { + if (!tagName || typeof tagName !== 'string') { + return { + valid: false, + error: 'Tag name is required and must be a string' + }; + } + + if (!tagName.startsWith(DEPLOYMENT_TAG_PREFIX)) { + return { + valid: false, + error: `Tag does not start with expected prefix: ${DEPLOYMENT_TAG_PREFIX}` + }; + } + + const tagContent = tagName.substring(DEPLOYMENT_TAG_PREFIX.length); + const parts = tagContent.split('-'); + + if (parts.length < 3) { + return { + valid: false, + error: + 'Tag format is invalid - expected format: data-deploy-{environment}-{migrationId}-{timestamp}' + }; + } + + const environment = parts[0]; + const migrationId = parts[1]; + const timestampParts = parts.slice(2); + const timestamp = timestampParts.join('-'); + + return { + valid: true, + environment, + migrationId, + timestamp, + fullTag: tagName + }; + } + + /** + * Validate working tree status for deployment readiness + * @param {WorkingTreeStatus} status - Working tree status + * @returns {Object} Validation result + */ + validateWorkingTreeStatus(status) { + if (!status || typeof status !== 'object') { + return { + ready: false, + issues: ['Working tree status is required'] + }; + } + + const issues = []; + + // Check for uncommitted changes + const modifiedCount = (status.modified || []).length; + const untracked = (status.untracked || []).length; + const staged = (status.staged || []).length; + const deleted = (status.deleted || []).length; + + if (modifiedCount > 0) { + issues.push(`${modifiedCount} modified files need to be committed`); + } + + if (untracked > 0) { + issues.push(`${untracked} untracked files should be committed or ignored`); + } + + if (staged > 0) { + issues.push(`${staged} staged files need to be committed`); + } + + if (deleted > 0) { + issues.push(`${deleted} deleted files need to be committed`); + } + + return { + ready: issues.length === 0, + issues, + summary: { + totalChanges: modifiedCount + untracked + staged + deleted, + modified: modifiedCount, + untracked, + staged, + deleted + } + }; + } + + /** + * Create deployment metadata object + * @param {string} migrationId - Migration identifier + * @param {string} environment - Environment name + * @param {number} operations - Number of operations + * @param {string} rollbackFrom - Previous deployment tag (optional) + * @returns {DeploymentMetadata} Deployment metadata + */ + createDeploymentMetadata(migrationId, environment, operations = 0, rollbackFrom = null) { + const metadata = { + migrationId, + operations, + timestamp: new Date().toISOString(), + environment + }; + + if (rollbackFrom) { + metadata.rollbackFrom = rollbackFrom; + } + + const validation = this.validateDeploymentMetadata(metadata); + if (!validation.valid) { + throw new Error(`Invalid deployment metadata: ${validation.errors.join(', ')}`); + } + + return metadata; + } + + /** + * Compare two deployment tags chronologically + * @param {string} tagA - First tag + * @param {string} tagB - Second tag + * @returns {number} -1 if tagA is older, 1 if newer, 0 if equal + */ + compareDeploymentTags(tagA, tagB) { + const parsedA = this.parseDeploymentTag(tagA); + const parsedB = this.parseDeploymentTag(tagB); + + if (!parsedA.valid || !parsedB.valid) { + throw new Error('Cannot compare invalid deployment tags'); + } + + // Convert timestamp back to Date for comparison + const dateA = new Date(parsedA.timestamp.replace(/-/g, ':')); + const dateB = new Date(parsedB.timestamp.replace(/-/g, ':')); + + if (dateA < dateB) return -1; + if (dateA > dateB) return 1; + return 0; + } + + /** + * Filter deployment tags by environment + * @param {string[]} tags - Array of tag names + * @param {string} environment - Environment to filter by + * @returns {Object[]} Filtered and parsed tags for the environment + */ + filterTagsByEnvironment(tags, environment) { + if (!Array.isArray(tags)) { + throw new Error('Tags must be an array'); + } + + return tags + .map((tag) => this.parseDeploymentTag(tag)) + .filter((parsed) => parsed.valid && parsed.environment === environment) + .sort((a, b) => this.compareDeploymentTags(a.fullTag, b.fullTag)); + } + + /** + * Get rollback information for a deployment + * @param {DeploymentMetadata} metadata - Current deployment metadata + * @param {string[]} availableTags - Available deployment tags + * @returns {Object} Rollback information + */ + getRollbackInfo(metadata, availableTags) { + if (metadata.rollbackFrom) { + return { + isRollback: true, + rollbackFrom: metadata.rollbackFrom, + reason: 'Explicit rollback deployment' + }; + } + + // Check if this looks like a rollback based on available tags + const environmentTags = this.filterTagsByEnvironment(availableTags, metadata.environment); + + if (environmentTags.length <= 1) { + return { + isRollback: false, + reason: 'First deployment or insufficient history' + }; + } + + // Find if there's a newer tag with the same migration ID + const thisTagData = environmentTags.find((tag) => tag.migrationId === metadata.migrationId); + const newerTags = environmentTags.filter( + (tag) => this.compareDeploymentTags(tag.fullTag, thisTagData?.fullTag || '') > 0 + ); + + return { + isRollback: newerTags.length > 0, + possibleRollbackFrom: newerTags.length > 0 ? newerTags[newerTags.length - 1].fullTag : null, + reason: + newerTags.length > 0 ? 'Deploying older migration after newer ones' : 'Standard deployment' + }; + } + + /** + * Validate ISO 8601 date string + * @param {string} dateString - Date string to validate + * @returns {boolean} True if valid ISO 8601 + * @private + */ + _isValidISO8601(dateString) { + const date = new Date(dateString); + return date instanceof Date && !isNaN(date.getTime()) && dateString === date.toISOString(); + } +} + +export default GitDeploymentLogic; diff --git a/src/lib/PathResolver.js b/starfleet/data-core/src/PathResolver.js similarity index 94% rename from src/lib/PathResolver.js rename to starfleet/data-core/src/PathResolver.js index 90d886b..db3e0d4 100644 --- a/src/lib/PathResolver.js +++ b/starfleet/data-core/src/PathResolver.js @@ -1,6 +1,6 @@ -const path = require('path'); -const fs = require('fs'); -const { promisify } = require('util'); +import path from 'path'; +import fs from 'fs'; +import { promisify } from 'util'; /** * A utility class for resolving and ensuring the existence of file and directory paths. @@ -27,7 +27,7 @@ class PathResolver { */ async resolveDirectoryForRead(dirPath) { const absolutePath = path.resolve(dirPath); - + try { await this.fsAccess(absolutePath, this.fs.constants.R_OK); const stats = await this.fsStat(absolutePath); @@ -54,11 +54,11 @@ class PathResolver { */ async resolveDirectoryForWrite(dirPath) { const absolutePath = path.resolve(dirPath); - + try { // Try to create the directory (will succeed if it already exists) await this.fsMkdir(absolutePath, { recursive: true }); - + // Verify write access await this.fsAccess(absolutePath, this.fs.constants.W_OK); return absolutePath; @@ -66,7 +66,9 @@ class PathResolver { if (error.code === 'EACCES') { throw new Error(`Directory is not writable: ${absolutePath}`); } - throw new Error(`Failed to create/access directory for writing: ${absolutePath} - ${error.message}`); + throw new Error( + `Failed to create/access directory for writing: ${absolutePath} - ${error.message}` + ); } } @@ -78,7 +80,7 @@ class PathResolver { */ async resolveFileForRead(filePath) { const absolutePath = path.resolve(filePath); - + try { await this.fsAccess(absolutePath, this.fs.constants.R_OK); const stats = await this.fsStat(absolutePath); @@ -106,10 +108,10 @@ class PathResolver { async resolveFileForWrite(filePath) { const absolutePath = path.resolve(filePath); const parentDir = path.dirname(absolutePath); - + // Ensure parent directory exists and is writable await this.resolveDirectoryForWrite(parentDir); - + // Check if file exists and is writable, or if parent dir is writable for new file try { await this.fsAccess(absolutePath, this.fs.constants.W_OK); @@ -123,7 +125,7 @@ class PathResolver { throw error; } } - + return absolutePath; } @@ -158,4 +160,4 @@ class PathResolver { } } -module.exports = PathResolver; +export default PathResolver; diff --git a/starfleet/data-core/src/SafetyGates.js b/starfleet/data-core/src/SafetyGates.js new file mode 100644 index 0000000..c3765dd --- /dev/null +++ b/starfleet/data-core/src/SafetyGates.js @@ -0,0 +1,357 @@ +/** + * SafetyGates.js - Production Safety Gate Business Rules + * + * Pure business logic for safety gate validation rules and policies. + * No process, filesystem, or I/O dependencies - only validation rules. + */ + +/** + * Business rules and validation logic for production safety gates + */ +export class SafetyGateRules { + constructor(options = {}) { + this.options = { + gitEnabled: true, + branchValidation: true, + testValidation: true, + confirmationRequired: true, + coverageThreshold: 80, + ...options + }; + } + + /** + * Validate safety gate configuration + * @param {Object} config - Gate configuration + * @returns {Object} Validation result + */ + validateGateConfig(config = {}) { + const errors = []; + const warnings = []; + + // Required fields validation + if (!config.operation || typeof config.operation !== 'string') { + errors.push('Operation name is required'); + } + + // Coverage threshold validation + if (config.coverageThreshold !== undefined) { + if ( + typeof config.coverageThreshold !== 'number' || + config.coverageThreshold < 0 || + config.coverageThreshold > 100 + ) { + errors.push('Coverage threshold must be a number between 0 and 100'); + } + } + + // Branch name validation + if (config.expectedBranch && typeof config.expectedBranch !== 'string') { + errors.push('Expected branch must be a string'); + } + + // Confirmation message validation + if (config.confirmationMessage && typeof config.confirmationMessage !== 'string') { + errors.push('Confirmation message must be a string'); + } + + return { + valid: errors.length === 0, + errors, + warnings + }; + } + + /** + * Determine which gates should be enabled based on configuration + * @param {Object} config - Gate configuration + * @param {boolean} force - Force bypass flag + * @returns {Object} Gate execution plan + */ + createGateExecutionPlan(config = {}, force = false) { + if (force) { + return { + skipAll: true, + reason: 'Force flag enabled - all gates bypassed', + requiredGates: [], + optionalGates: [], + requiresForceConfirmation: true + }; + } + + const requiredGates = []; + const optionalGates = []; + + if (this.options.gitEnabled) { + requiredGates.push({ + name: 'git-clean-check', + description: 'Validate git repository state', + critical: true + }); + } + + if (this.options.branchValidation && config.expectedBranch) { + requiredGates.push({ + name: 'branch-validation', + description: `Validate current branch is ${config.expectedBranch}`, + critical: true + }); + } + + if (this.options.testValidation) { + requiredGates.push({ + name: 'test-validation', + description: `Validate tests pass with ${config.coverageThreshold || this.options.coverageThreshold}% coverage`, + critical: true + }); + } + + if (this.options.confirmationRequired) { + requiredGates.push({ + name: 'production-confirmation', + description: 'Require typed confirmation for production operation', + critical: true + }); + } + + return { + skipAll: false, + requiredGates, + optionalGates, + requiresForceConfirmation: false + }; + } + + /** + * Validate git status data + * @param {Object} gitStatus - Git status information + * @returns {Object} Validation result + */ + validateGitStatus(gitStatus) { + const issues = []; + + if (!gitStatus) { + return { + valid: false, + issues: ['Git status data is required'] + }; + } + + // Check for uncommitted changes + if (gitStatus.modified && gitStatus.modified.length > 0) { + issues.push(`${gitStatus.modified.length} modified files need to be committed`); + } + + if (gitStatus.untracked && gitStatus.untracked.length > 0) { + issues.push(`${gitStatus.untracked.length} untracked files should be committed or ignored`); + } + + if (gitStatus.staged && gitStatus.staged.length > 0) { + issues.push(`${gitStatus.staged.length} staged files need to be committed`); + } + + return { + valid: issues.length === 0, + issues, + hasUncommittedChanges: issues.length > 0 + }; + } + + /** + * Validate branch information + * @param {string} currentBranch - Current branch name + * @param {string} expectedBranch - Expected branch name + * @returns {Object} Validation result + */ + validateBranch(currentBranch, expectedBranch) { + if (!currentBranch || typeof currentBranch !== 'string') { + return { + valid: false, + issue: 'Current branch information is required' + }; + } + + if (!expectedBranch || typeof expectedBranch !== 'string') { + return { + valid: false, + issue: 'Expected branch information is required' + }; + } + + const isCorrectBranch = currentBranch.trim() === expectedBranch.trim(); + + return { + valid: isCorrectBranch, + currentBranch: currentBranch.trim(), + expectedBranch: expectedBranch.trim(), + issue: isCorrectBranch + ? null + : `Current branch "${currentBranch}" does not match expected "${expectedBranch}"` + }; + } + + /** + * Validate test results + * @param {Object} testResults - Test execution results + * @param {number} coverageThreshold - Minimum coverage threshold + * @returns {Object} Validation result + */ + validateTestResults(testResults, coverageThreshold = this.options.coverageThreshold) { + const issues = []; + + if (!testResults || typeof testResults !== 'object') { + return { + valid: false, + issues: ['Test results data is required'] + }; + } + + // Check for test failures + if (testResults.failed && testResults.failed > 0) { + issues.push(`${testResults.failed} tests failed - all tests must pass`); + } + + // Check coverage if available + if (testResults.coverage && testResults.coverage.total !== undefined) { + if (testResults.coverage.total < coverageThreshold) { + issues.push( + `Coverage ${testResults.coverage.total}% is below required ${coverageThreshold}%` + ); + } + } + + // Validate test counts make sense + const totalTests = + (testResults.passed || 0) + (testResults.failed || 0) + (testResults.skipped || 0); + if (totalTests === 0) { + issues.push('No tests found - at least some tests should exist'); + } + + return { + valid: issues.length === 0, + issues, + summary: { + total: totalTests, + passed: testResults.passed || 0, + failed: testResults.failed || 0, + skipped: testResults.skipped || 0, + coverage: testResults.coverage?.total + } + }; + } + + /** + * Validate confirmation input + * @param {string} providedInput - User's confirmation input + * @param {string} expectedInput - Expected confirmation text + * @returns {Object} Validation result + */ + validateConfirmation(providedInput, expectedInput) { + if (typeof providedInput !== 'string' || typeof expectedInput !== 'string') { + return { + valid: false, + issue: 'Both provided and expected confirmation inputs must be strings' + }; + } + + const matches = providedInput.trim() === expectedInput.trim(); + + return { + valid: matches, + providedLength: providedInput.trim().length, + expectedLength: expectedInput.trim().length, + issue: matches ? null : 'Confirmation text does not match expected input' + }; + } + + /** + * Generate safety gate audit entry + * @param {string} gateName - Name of the gate + * @param {Object} result - Gate execution result + * @returns {Object} Audit entry + */ + createAuditEntry(gateName, result) { + return { + gate: gateName, + timestamp: new Date().toISOString(), + status: result.valid ? 'PASSED' : 'FAILED', + issues: result.issues || (result.issue ? [result.issue] : []), + metadata: { + ...result, + duration: result.duration || null + } + }; + } + + /** + * Calculate overall safety score + * @param {Array} auditEntries - Array of gate audit entries + * @returns {Object} Safety score summary + */ + calculateSafetyScore(auditEntries) { + if (!auditEntries || auditEntries.length === 0) { + return { + score: 0, + total: 0, + passed: 0, + failed: 0, + percentage: 0 + }; + } + + const passed = auditEntries.filter((entry) => entry.status === 'PASSED').length; + const failed = auditEntries.filter((entry) => entry.status === 'FAILED').length; + const total = auditEntries.length; + const percentage = total > 0 ? Math.round((passed / total) * 100) : 0; + + return { + score: percentage, + total, + passed, + failed, + percentage, + allPassed: failed === 0, + criticalFailures: auditEntries + .filter((entry) => entry.status === 'FAILED') + .map((entry) => entry.gate) + }; + } + + /** + * Get recommended actions based on gate failures + * @param {Array} auditEntries - Array of gate audit entries + * @returns {Array} Array of recommended actions + */ + getRecommendedActions(auditEntries) { + const actions = []; + const failedEntries = auditEntries.filter((entry) => entry.status === 'FAILED'); + + for (const entry of failedEntries) { + switch (entry.gate) { + case 'git-clean-check': + actions.push('Commit or stash uncommitted changes in git working tree'); + break; + case 'branch-validation': + actions.push(`Switch to the correct branch: ${entry.metadata.expectedBranch}`); + break; + case 'test-validation': + if (entry.issues.some((issue) => issue.includes('failed'))) { + actions.push('Fix failing tests before proceeding'); + } + if (entry.issues.some((issue) => issue.includes('coverage'))) { + actions.push('Increase test coverage to meet minimum threshold'); + } + break; + case 'production-confirmation': + actions.push('Type the exact confirmation text as requested'); + break; + default: + actions.push(`Review and fix issues in ${entry.gate}`); + } + } + + return actions; + } +} + +export default SafetyGateRules; diff --git a/starfleet/data-core/src/application/ApplyMigrationPlan.js b/starfleet/data-core/src/application/ApplyMigrationPlan.js new file mode 100644 index 0000000..c11c93e --- /dev/null +++ b/starfleet/data-core/src/application/ApplyMigrationPlan.js @@ -0,0 +1,104 @@ +/** + * ApplyMigrationPlan - Pure use-case for applying migration plans + * No I/O, no Node dependencies - only uses injected ports + */ +import { Events } from '../events/index.js'; + +/** + * Factory for ApplyMigrationPlan use-case + * @param {Object} deps - Dependencies + * @param {import('../ports/DbPort.js').DbPort} deps.db + * @param {import('../ports/LoggerPort.js').LoggerPort} deps.logger + * @param {import('../ports/ClockPort.js').ClockPort} deps.clock + * @param {import('../ports/EventBusPort.js').EventBusPort} deps.bus + */ +export function makeApplyMigrationPlan({ db, logger, clock, bus }) { + return { + /** + * Execute migration plan application + * @param {Object} input + * @param {Object} input.plan - Migration plan to apply + * @param {Array} input.plan.steps - Migration steps + * @param {boolean} [input.dryRun] - Whether to do a dry run + * @returns {Promise<{applied: number, dryRun: boolean, duration: number}>} + */ + async execute({ plan, dryRun = false }) { + const startTime = clock.nowMs(); + + bus.emit(Events.MIGRATION_APPLY_STARTED, { + at: clock.now(), + dryRun, + steps: plan.steps.length, + name: plan.name + }); + + if (dryRun) { + logger.info({ steps: plan.steps.length }, 'Dry run - no changes will be applied'); + return { + applied: 0, + dryRun: true, + duration: clock.nowMs() - startTime + }; + } + + let applied = 0; + const errors = []; + + try { + // Run all migrations in a transaction + await db.withTransaction(async (tx) => { + for (const step of plan.steps) { + bus.emit(Events.MIGRATION_APPLY_STEP, { + id: step.id, + path: step.path, + index: applied + 1, + total: plan.steps.length + }); + + try { + await tx.apply(step.sql); + applied++; + logger.debug({ path: step.path, id: step.id }, 'Applied migration step'); + } catch (error) { + logger.error( + { path: step.path, error: error.message }, + 'Failed to apply migration step' + ); + errors.push({ step: step.path, error: error.message }); + throw error; // This will rollback the transaction + } + } + }); + + bus.emit(Events.MIGRATION_APPLY_DONE, { + at: clock.now(), + applied, + duration: clock.nowMs() - startTime + }); + + return { + applied, + dryRun: false, + duration: clock.nowMs() - startTime, + success: true + }; + } catch (error) { + bus.emit(Events.MIGRATION_APPLY_DONE, { + at: clock.now(), + applied, + failed: true, + error: error.message, + duration: clock.nowMs() - startTime + }); + + return { + applied, + dryRun: false, + duration: clock.nowMs() - startTime, + success: false, + errors + }; + } + } + }; +} diff --git a/starfleet/data-core/src/application/GenerateMigrationPlan.js b/starfleet/data-core/src/application/GenerateMigrationPlan.js new file mode 100644 index 0000000..78258b8 --- /dev/null +++ b/starfleet/data-core/src/application/GenerateMigrationPlan.js @@ -0,0 +1,80 @@ +/** + * GenerateMigrationPlan - Pure use-case for generating migration plans + * No I/O, no Node dependencies - only uses injected ports + */ +import { Events } from '../events/index.js'; + +/** + * Factory for GenerateMigrationPlan use-case + * @param {Object} deps - Dependencies + * @param {import('../ports/FileSystemPort.js').FileSystemPort} deps.fs + * @param {import('../ports/GlobPort.js').GlobPort} deps.glob + * @param {import('../ports/CryptoPort.js').CryptoPort} deps.crypto + * @param {import('../ports/LoggerPort.js').LoggerPort} deps.logger + * @param {import('../ports/ClockPort.js').ClockPort} deps.clock + * @param {import('../ports/EventBusPort.js').EventBusPort} deps.bus + */ +export function makeGenerateMigrationPlan(deps) { + const { fs, glob, crypto, logger, clock, bus } = deps; + + return { + /** + * Execute migration plan generation + * @param {Object} input + * @param {string} input.sqlRoot - Root directory for SQL files + * @param {string} [input.migrationName] - Optional migration name + * @returns {Promise<{steps: Array, preview: string, checksum: string}>} + */ + async execute({ sqlRoot, migrationName }) { + bus.emit(Events.MIGRATION_PLAN_STARTED, { + at: clock.now(), + root: sqlRoot, + name: migrationName + }); + + // Find all SQL files + const paths = await glob.find([`${sqlRoot}/**/*.sql`], { dot: false }); + logger.debug({ count: paths.length }, 'Found SQL files'); + + const steps = []; + const contents = []; + + // Process each SQL file + for (const path of paths) { + bus.emit(Events.MIGRATION_PLAN_STEP, { path }); + + const sql = await fs.readFile(path); + const id = crypto.hash(sql); // Stable content hash + + steps.push({ + id, + path, + sql, + checksum: id + }); + + contents.push(`-- Source: ${path}\n-- Checksum: ${id}\n${sql}`); + } + + // Generate deterministic preview + const preview = contents.join('\n\n-- ===== Next File =====\n\n'); + const planChecksum = crypto.hash(preview); + + const plan = { + steps, + preview, + checksum: planChecksum, + timestamp: clock.nowMs(), + name: migrationName || `migration_${clock.nowMs()}` + }; + + bus.emit(Events.MIGRATION_PLAN_READY, { + at: clock.now(), + count: steps.length, + checksum: planChecksum + }); + + return plan; + } + }; +} diff --git a/starfleet/data-core/src/application/VerifySafetyGates.js b/starfleet/data-core/src/application/VerifySafetyGates.js new file mode 100644 index 0000000..df772d7 --- /dev/null +++ b/starfleet/data-core/src/application/VerifySafetyGates.js @@ -0,0 +1,126 @@ +/** + * VerifySafetyGates - Pure use-case for verifying safety gates + * No I/O, no Node dependencies - only uses injected ports + */ +import { Events } from '../events/index.js'; + +/** + * Factory for VerifySafetyGates use-case + * @param {Object} deps - Dependencies + * @param {import('../ports/GitPort.js').GitPort} deps.git + * @param {import('../ports/DbPort.js').DbPort} deps.db + * @param {import('../ports/LoggerPort.js').LoggerPort} deps.logger + * @param {import('../ports/EventBusPort.js').EventBusPort} deps.bus + */ +export function makeVerifySafetyGates({ git, db, logger, bus }) { + return { + /** + * Execute safety gate verification + * @param {Object} policy - Safety gate policy + * @param {boolean} [policy.requireClean] - Require clean working tree + * @param {string[]} [policy.allowedBranches] - List of allowed branches + * @param {boolean} [policy.requireTests] - Require tests to pass + * @param {string[]} [policy.testGlobs] - Test file patterns + * @param {boolean} [policy.requireUpToDate] - Require branch up to date with remote + * @returns {Promise<{passed: boolean, failures: string[], details: Object}>} + */ + async execute(policy) { + bus.emit(Events.SAFETY_CHECKS_STARTED, { policy }); + + const failures = []; + const details = {}; + + // Check working tree cleanliness + if (policy.requireClean) { + const { clean, modified, untracked } = await git.status(); + details.workingTree = { clean, modified, untracked }; + + if (!clean) { + failures.push('working_tree_dirty'); + logger.warn({ modified, untracked }, 'Working tree is not clean'); + } + + bus.emit(Events.SAFETY_CHECK_ITEM, { + check: 'working_tree', + passed: clean + }); + } + + // Check branch restrictions + if (policy.allowedBranches?.length > 0) { + const { branch } = await git.status(); + details.branch = { current: branch, allowed: policy.allowedBranches }; + + const branchAllowed = policy.allowedBranches.includes(branch); + if (!branchAllowed) { + failures.push('branch_not_allowed'); + logger.warn({ branch, allowed: policy.allowedBranches }, 'Branch not in allowed list'); + } + + bus.emit(Events.SAFETY_CHECK_ITEM, { + check: 'branch_policy', + passed: branchAllowed + }); + } + + // Check if branch is up to date with remote + if (policy.requireUpToDate) { + const { behind, ahead } = await git.status(); + details.remote = { behind, ahead }; + + const upToDate = behind === 0; + if (!upToDate) { + failures.push('branch_behind_remote'); + logger.warn({ behind, ahead }, 'Branch is behind remote'); + } + + bus.emit(Events.SAFETY_CHECK_ITEM, { + check: 'up_to_date', + passed: upToDate + }); + } + + // Run tests if required + if (policy.requireTests) { + const testGlobs = policy.testGlobs || ['test/pgtap/**/*.sql']; + logger.info({ patterns: testGlobs }, 'Running tests'); + + const testResult = await db.runPgTap(testGlobs); + details.tests = testResult; + + const testsPass = testResult.failed === 0; + if (!testsPass) { + failures.push('tests_failed'); + logger.error( + { + failed: testResult.failed, + total: testResult.total, + failures: testResult.failures + }, + 'Tests failed' + ); + } + + bus.emit(Events.SAFETY_CHECK_ITEM, { + check: 'tests', + passed: testsPass, + details: testResult + }); + } + + const passed = failures.length === 0; + + bus.emit(Events.SAFETY_CHECKS_RESULT, { + passed, + failures, + details + }); + + return { + passed, + failures, + details + }; + } + }; +} diff --git a/starfleet/data-core/src/application/index.js b/starfleet/data-core/src/application/index.js new file mode 100644 index 0000000..3ca65ef --- /dev/null +++ b/starfleet/data-core/src/application/index.js @@ -0,0 +1,8 @@ +/** + * Application use-cases index + * Export all pure business logic use-cases + */ + +export { makeGenerateMigrationPlan } from './GenerateMigrationPlan.js'; +export { makeApplyMigrationPlan } from './ApplyMigrationPlan.js'; +export { makeVerifySafetyGates } from './VerifySafetyGates.js'; diff --git a/starfleet/data-core/src/application/makeAnalyzeTestRequirements.js b/starfleet/data-core/src/application/makeAnalyzeTestRequirements.js new file mode 100644 index 0000000..e48dea4 --- /dev/null +++ b/starfleet/data-core/src/application/makeAnalyzeTestRequirements.js @@ -0,0 +1,586 @@ +/** + * @fileoverview Test requirement analysis use-case + * Pure function factory - no I/O, optional event bus + */ + +import { TEST_TYPES, TEST_PRIORITIES } from '../domain/testingTypes.js'; +import { getRecommendedPatterns } from '../testing/render/renderPattern.js'; + +/** + * Events that can be emitted during analysis + */ +export const AnalysisEvents = { + STARTED: 'TEST_ANALYSIS_STARTED', + PROGRESS: 'TEST_ANALYSIS_PROGRESS', + COMPLETE: 'TEST_ANALYSIS_COMPLETE', + WARNING: 'TEST_ANALYSIS_WARNING' +}; + +/** + * Create test requirement analyzer function + * @param {Object} deps - Dependencies + * @param {Object} [deps.bus] - Optional event bus for progress + * @param {Function} [deps.clock] - Optional clock for timestamps + * @returns {Function} Analyzer function + */ +export function makeAnalyzeTestRequirements({ bus, clock = Date } = {}) { + /** + * Analyze operations for test requirements + * @param {Array} operations - Migration operations to analyze + * @param {Object} [context] - Analysis context + * @returns {Object} Analysis results + */ + return async function analyzeTestRequirements(operations, context = {}) { + const startTime = clock.now(); + + bus?.emit?.(AnalysisEvents.STARTED, { + operationCount: operations.length, + timestamp: startTime + }); + + const requirements = []; + const summary = { + totalRequirements: 0, + byType: {}, + byPriority: {}, + operationsAnalyzed: operations.length + }; + const suggestions = []; + const riskAreas = []; + let estimatedEffort = 0; + + // Analyze each operation + for (let i = 0; i < operations.length; i++) { + const operation = operations[i]; + + bus?.emit?.(AnalysisEvents.PROGRESS, { + current: i + 1, + total: operations.length, + operation: operation.description || operation.sql?.substring(0, 50) + }); + + try { + const opRequirements = analyzeOperation(operation, context); + + for (const req of opRequirements) { + requirements.push(req); + + // Update statistics + summary.byType[req.type] = (summary.byType[req.type] || 0) + 1; + summary.byPriority[req.priority] = (summary.byPriority[req.priority] || 0) + 1; + estimatedEffort += estimateTestEffort(req); + + // Check for risks + if (isHighRisk(operation)) { + riskAreas.push(operation.description || extractOperationDescription(operation)); + } + } + } catch (error) { + bus?.emit?.(AnalysisEvents.WARNING, { + message: `Failed to analyze operation: ${error.message}`, + operation, + error + }); + } + } + + // Generate suggestions based on analysis + suggestions.push(...generateSuggestions(requirements, summary, riskAreas)); + + // Sort requirements by priority + requirements.sort((a, b) => comparePriority(a.priority, b.priority)); + + summary.totalRequirements = requirements.length; + + const result = { + requirements, + summary, + suggestions, + estimatedEffort: Math.round(estimatedEffort * 10) / 10, + riskAreas + }; + + bus?.emit?.(AnalysisEvents.COMPLETE, { + totalRequirements: summary.totalRequirements, + estimatedEffort: result.estimatedEffort, + riskAreas: riskAreas.length, + duration: clock.now() - startTime + }); + + return result; + }; +} + +/** + * Analyze a single operation for test requirements + * @param {Object} operation - Operation to analyze + * @param {Object} context - Analysis context + * @returns {Array} Test requirements + */ +function analyzeOperation(operation, context) { + const requirements = []; + const operationType = categorizeOperation(operation); + const target = extractTargetObject(operation); + const basePriority = getBasePriority(operation); + + // Generate requirements based on operation type + switch (operationType) { + case 'CREATE_TABLE': + requirements.push(...generateTableCreationRequirements(operation, target, basePriority)); + break; + + case 'DROP_TABLE': + requirements.push(...generateTableDropRequirements(operation, target, basePriority)); + break; + + case 'ALTER_TABLE': + requirements.push(...generateTableAlterRequirements(operation, target, basePriority)); + break; + + case 'CREATE_INDEX': + requirements.push(...generateIndexRequirements(operation, target, basePriority)); + break; + + case 'CREATE_FUNCTION': + requirements.push(...generateFunctionRequirements(operation, target, basePriority)); + break; + + case 'CREATE_POLICY': + case 'ALTER_POLICY': + case 'DROP_POLICY': + requirements.push( + ...generatePolicyRequirements(operation, target, basePriority, operationType) + ); + break; + + case 'ENABLE_RLS': + case 'DISABLE_RLS': + requirements.push(...generateRLSRequirements(operation, target, basePriority, operationType)); + break; + + default: + requirements.push(...generateGenericRequirements(operation, target, basePriority)); + } + + // Add security tests if needed + if (requiresSecurityTests(operation)) { + requirements.push(...generateSecurityRequirements(operation, target, TEST_PRIORITIES.CRITICAL)); + } + + // Enhance requirements with metadata + for (const req of requirements) { + req.reason = req.reason || generateTestReason(req, operation); + req.metadata = { ...req.metadata, operation: operationType }; + } + + return requirements; +} + +/** + * Categorize operation type from SQL + */ +function categorizeOperation(operation) { + const sql = (operation.sql || '').toUpperCase(); + + if (sql.includes('CREATE TABLE')) return 'CREATE_TABLE'; + if (sql.includes('DROP TABLE')) return 'DROP_TABLE'; + if (sql.includes('ALTER TABLE')) return 'ALTER_TABLE'; + if (sql.includes('CREATE INDEX')) return 'CREATE_INDEX'; + if (sql.includes('CREATE FUNCTION')) return 'CREATE_FUNCTION'; + if (sql.includes('CREATE POLICY')) return 'CREATE_POLICY'; + if (sql.includes('ALTER POLICY')) return 'ALTER_POLICY'; + if (sql.includes('DROP POLICY')) return 'DROP_POLICY'; + if (sql.includes('ENABLE ROW LEVEL SECURITY')) return 'ENABLE_RLS'; + if (sql.includes('DISABLE ROW LEVEL SECURITY')) return 'DISABLE_RLS'; + + return 'UNKNOWN'; +} + +/** + * Extract target object name from SQL + */ +function extractTargetObject(operation) { + const sql = operation.sql || ''; + + // Try various patterns + const patterns = [ + /(?:TABLE|INDEX|FUNCTION|POLICY|VIEW)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?([^\s(]+)/i, + /ON\s+([^\s(]+)/i, + /FROM\s+([^\s(]+)/i + ]; + + for (const pattern of patterns) { + const match = sql.match(pattern); + if (match) { + return match[1].replace(/["`]/g, ''); + } + } + + return 'unknown'; +} + +/** + * Get base priority for operation + */ +function getBasePriority(operation) { + if (operation.type === 'DESTRUCTIVE') return TEST_PRIORITIES.CRITICAL; + if (operation.type === 'WARNING') return TEST_PRIORITIES.HIGH; + return TEST_PRIORITIES.MEDIUM; +} + +/** + * Generate requirements for table creation + */ +function generateTableCreationRequirements(operation, target, priority) { + const [schema, table] = target.includes('.') ? target.split('.') : ['public', target]; + + return [ + { + type: TEST_TYPES.SCHEMA, + priority, + description: `Verify table ${target} exists with correct structure`, + target, + testCases: [ + 'has_table() - table exists', + 'columns_are() - correct columns', + 'col_type_is() - correct types' + ], + vars: { schema, table }, + recommendedPatterns: ['table_exists', 'column_type_check'] + } + ]; +} + +/** + * Generate requirements for table drops + */ +function generateTableDropRequirements(operation, target, priority) { + const [schema, table] = target.includes('.') ? target.split('.') : ['public', target]; + + return [ + { + type: TEST_TYPES.SCHEMA, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify table ${target} is properly dropped`, + target, + testCases: [ + 'hasnt_table() - table no longer exists', + 'Verify cascade behavior if applicable' + ], + vars: { schema, table }, + reason: 'Destructive operations require critical testing' + } + ]; +} + +/** + * Generate requirements for table alterations + */ +function generateTableAlterRequirements(operation, target, priority) { + const [schema, table] = target.includes('.') ? target.split('.') : ['public', target]; + const sql = operation.sql || ''; + const requirements = []; + + if (sql.includes('ADD COLUMN')) { + requirements.push({ + type: TEST_TYPES.SCHEMA, + priority, + description: `Verify new column added to ${target}`, + target, + testCases: ['has_column() - column exists'], + vars: { schema, table }, + recommendedPatterns: ['column_exists', 'column_type_check'] + }); + } + + if (sql.includes('DROP COLUMN')) { + requirements.push({ + type: TEST_TYPES.SCHEMA, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify column dropped from ${target}`, + target, + testCases: ['hasnt_column() - column removed'], + vars: { schema, table } + }); + } + + if (sql.includes('ALTER COLUMN') && sql.includes('TYPE')) { + requirements.push({ + type: TEST_TYPES.DATA, + priority: TEST_PRIORITIES.HIGH, + description: `Verify data integrity after type change in ${target}`, + target, + testCases: ['Data conversion successful', 'No data loss'], + vars: { schema, table }, + recommendedPatterns: ['data_type_conversion_test'] + }); + } + + return requirements; +} + +/** + * Generate requirements for indexes + */ +function generateIndexRequirements(operation, target, priority) { + const sql = operation.sql || ''; + const tableMatch = sql.match(/ON\s+([^\s(]+)/i); + const tableName = tableMatch ? tableMatch[1] : 'unknown'; + const [schema, table] = tableName.includes('.') ? tableName.split('.') : ['public', tableName]; + + return [ + { + type: TEST_TYPES.INDEX, + priority, + description: `Verify index ${target} exists and functions correctly`, + target, + testCases: [ + 'has_index() - index exists', + 'Verify index type if specified', + 'Test query performance improvement' + ], + vars: { schema, table, index_name: target }, + recommendedPatterns: ['index_exists', 'index_type_check'] + } + ]; +} + +/** + * Generate requirements for functions + */ +function generateFunctionRequirements(operation, target, priority) { + const [schema, functionName] = target.includes('.') ? target.split('.') : ['public', target]; + + return [ + { + type: TEST_TYPES.FUNCTION, + priority, + description: `Verify function ${target} exists and behaves correctly`, + target, + testCases: [ + 'has_function() - function exists', + 'Test with valid inputs', + 'Test error handling' + ], + vars: { schema, function_name: functionName } + } + ]; +} + +/** + * Generate requirements for policy operations + */ +function generatePolicyRequirements(operation, target, priority, operationType) { + const sql = operation.sql || ''; + const tableMatch = sql.match(/ON\s+([^\s(]+)/i); + const tableName = tableMatch ? tableMatch[1] : 'unknown'; + const [schema, table] = tableName.includes('.') ? tableName.split('.') : ['public', tableName]; + + const requirements = [ + { + type: TEST_TYPES.RLS, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify RLS policy ${target} on ${tableName}`, + target, + testCases: [ + 'is_rls_enabled() - RLS is active', + 'policy_exists() - policy created/modified', + 'Test with different roles' + ], + vars: { schema, table, policy_name: target }, + recommendedPatterns: ['rls_enablement_check', 'policy_exists', 'role_based_access'] + } + ]; + + // Add permission tests for each role + const roles = ['anon', 'authenticated']; + for (const role of roles) { + requirements.push({ + type: TEST_TYPES.PERMISSION, + priority: TEST_PRIORITIES.CRITICAL, + description: `Test ${target} enforcement for role ${role}`, + target: `${target}_${role}`, + testCases: [ + `Test data visibility as ${role}`, + 'Verify authorized operations allowed', + 'Verify unauthorized operations blocked' + ], + vars: { schema, table, policy_name: target, role }, + recommendedPatterns: ['role_based_access', 'privilege_escalation_test'] + }); + } + + return requirements; +} + +/** + * Generate requirements for RLS enable/disable + */ +function generateRLSRequirements(operation, target, priority, operationType) { + const [schema, table] = target.includes('.') ? target.split('.') : ['public', target]; + const isEnabling = operationType === 'ENABLE_RLS'; + + return [ + { + type: TEST_TYPES.RLS, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify RLS ${isEnabling ? 'enabled' : 'disabled'} on ${target}`, + target, + testCases: [ + `is_rls_enabled() - RLS is ${isEnabling ? 'active' : 'inactive'}`, + 'Test access patterns after change' + ], + vars: { schema, table }, + recommendedPatterns: ['rls_enablement_check', 'service_role_bypass'] + } + ]; +} + +/** + * Generate generic requirements + */ +function generateGenericRequirements(operation, target, priority) { + return [ + { + type: TEST_TYPES.SCHEMA, + priority: TEST_PRIORITIES.LOW, + description: `Verify operation on ${target}`, + target, + testCases: ['Verify operation completed successfully'], + vars: {}, + reason: 'Generic operation requires basic validation' + } + ]; +} + +/** + * Generate security-specific requirements + */ +function generateSecurityRequirements(operation, target, priority) { + return [ + { + type: TEST_TYPES.PERMISSION, + priority, + description: `Security validation for ${target}`, + target, + testCases: [ + 'Test with different user roles', + 'Verify no privilege escalation', + 'Test SQL injection protection' + ], + vars: {}, + recommendedPatterns: ['privilege_escalation_test', 'multi_role_data_isolation'] + } + ]; +} + +/** + * Check if operation requires security tests + */ +function requiresSecurityTests(operation) { + const sql = (operation.sql || '').toUpperCase(); + return ( + sql.includes('POLICY') || + sql.includes('GRANT') || + sql.includes('REVOKE') || + sql.includes('SECURITY DEFINER') + ); +} + +/** + * Check if operation is high risk + */ +function isHighRisk(operation) { + const sql = (operation.sql || '').toUpperCase(); + return ( + sql.includes('DROP') || + sql.includes('TRUNCATE') || + sql.includes('DELETE FROM') || + operation.type === 'DESTRUCTIVE' + ); +} + +/** + * Extract operation description + */ +function extractOperationDescription(operation) { + if (operation.description) return operation.description; + const sql = (operation.sql || '').substring(0, 50); + return sql.length === 50 ? sql + '...' : sql; +} + +/** + * Estimate test effort in hours + */ +function estimateTestEffort(requirement) { + const effortMap = { + [TEST_PRIORITIES.CRITICAL]: 1.0, + [TEST_PRIORITIES.HIGH]: 0.75, + [TEST_PRIORITIES.MEDIUM]: 0.5, + [TEST_PRIORITIES.LOW]: 0.25 + }; + return effortMap[requirement.priority] || 0.5; +} + +/** + * Generate test reason + */ +function generateTestReason(requirement, operation) { + if (requirement.reason) return requirement.reason; + + if (operation.type === 'DESTRUCTIVE') { + return 'Destructive operations require comprehensive testing'; + } + + if (requirement.type === TEST_TYPES.RLS || requirement.type === TEST_TYPES.PERMISSION) { + return 'Security-critical functionality requires thorough validation'; + } + + return `Verify ${requirement.type.toLowerCase()} changes are correctly applied`; +} + +/** + * Generate suggestions based on analysis + */ +function generateSuggestions(requirements, summary, riskAreas) { + const suggestions = []; + + if (riskAreas.length > 0) { + suggestions.push( + `โš ๏ธ High-risk operations detected: ${riskAreas.length} destructive changes require careful testing` + ); + } + + if (summary.byType[TEST_TYPES.RLS] > 0 || summary.byType[TEST_TYPES.PERMISSION] > 0) { + suggestions.push( + '๐Ÿ”’ Security tests required: Test with multiple user roles and verify access controls' + ); + } + + if (summary.byPriority[TEST_PRIORITIES.CRITICAL] > 5) { + suggestions.push( + `๐Ÿšจ ${summary.byPriority[TEST_PRIORITIES.CRITICAL]} critical tests required - allocate sufficient testing time` + ); + } + + if (summary.totalRequirements === 0) { + suggestions.push( + 'โ„น๏ธ No specific test requirements identified - consider adding basic validation tests' + ); + } + + return suggestions; +} + +/** + * Compare priorities for sorting + */ +function comparePriority(a, b) { + const order = { + [TEST_PRIORITIES.CRITICAL]: 0, + [TEST_PRIORITIES.HIGH]: 1, + [TEST_PRIORITIES.MEDIUM]: 2, + [TEST_PRIORITIES.LOW]: 3 + }; + return order[a] - order[b]; +} diff --git a/starfleet/data-core/src/config/OutputConfig.js b/starfleet/data-core/src/config/OutputConfig.js new file mode 100644 index 0000000..26cf36c --- /dev/null +++ b/starfleet/data-core/src/config/OutputConfig.js @@ -0,0 +1,265 @@ +/** + * OutputConfig - Centralized path configuration for data + * + * A proper class with typed properties for all paths. + * Uses dependency injection - no singletons! + */ + +import path from 'path'; +import fs from 'fs'; + +/** + * OutputConfig class + * @class + */ +class OutputConfig { + constructor( + configPath = null, + cliSupabaseDir = null, + cliMigrationsDir = null, + cliTestsDir = null, + cliSqlDir = null, + cliFunctionsDir = null, + cliOutputDir = null, + cliProjectRoot = null + ) { + // Initialize all path properties as direct class properties + this.projectRoot = null; + this.supabaseDir = null; + this.migrationsDir = null; + this.testsDir = null; + this.sqlDir = null; + this.functionsDir = null; + this.seedDir = null; + this.supabaseConfig = null; + this.dataConfig = null; + this.buildDir = null; + this.cacheDir = null; + this.tempDir = null; + this.logFile = null; + this.errorLogFile = null; + + // Build configuration from various sources + this._setDefaults(); + this._applyAutoDetection(); + this._applyEnvironmentVariables(); + if (configPath) { + this._loadConfigFile(configPath); + } + // Apply CLI overrides with explicit parameters + this._applyCliOptions( + cliProjectRoot, + cliSupabaseDir, + cliMigrationsDir, + cliTestsDir, + cliSqlDir, + cliFunctionsDir, + cliOutputDir + ); + this._resolveAllPaths(); + this._validatePaths(); + } + + _setDefaults() { + const cwd = process.cwd(); + + this.projectRoot = cwd; + this.supabaseDir = path.join(cwd, 'supabase'); + this.migrationsDir = path.join(cwd, 'supabase', 'migrations'); + this.testsDir = path.join(cwd, 'supabase', 'tests'); + this.sqlDir = path.join(cwd, 'supabase', 'sql'); + this.functionsDir = path.join(cwd, 'supabase', 'functions'); + this.seedDir = path.join(cwd, 'supabase', 'seed'); + this.supabaseConfig = path.join(cwd, 'supabase', 'config.toml'); + this.dataConfig = path.join(cwd, '.datarc.json'); + this.buildDir = path.join(cwd, '.data', 'build'); + this.cacheDir = path.join(cwd, '.data', 'cache'); + this.tempDir = path.join(cwd, '.data', 'temp'); + this.logFile = path.join(cwd, '.data', 'data.log'); + this.errorLogFile = path.join(cwd, '.data', 'error.log'); + } + + _applyAutoDetection() { + const cwd = process.cwd(); + + // Check if we're inside a supabase directory + if (fs.existsSync(path.join(cwd, 'config.toml'))) { + this.supabaseDir = cwd; + this.projectRoot = path.dirname(cwd); + this._updateRelativePaths(); + return; + } + + // Check if we have a supabase subdirectory + if (fs.existsSync(path.join(cwd, 'supabase', 'config.toml'))) { + this.projectRoot = cwd; + this.supabaseDir = path.join(cwd, 'supabase'); + this._updateRelativePaths(); + return; + } + + // Search up the tree for a project root + let searchDir = cwd; + let depth = 0; + const maxDepth = 5; + + while (depth < maxDepth) { + const parentDir = path.dirname(searchDir); + if (parentDir === searchDir) break; + + if (fs.existsSync(path.join(parentDir, 'supabase', 'config.toml'))) { + this.projectRoot = parentDir; + this.supabaseDir = path.join(parentDir, 'supabase'); + this._updateRelativePaths(); + return; + } + + searchDir = parentDir; + depth++; + } + } + + _updateRelativePaths() { + this.migrationsDir = path.join(this.supabaseDir, 'migrations'); + this.testsDir = path.join(this.supabaseDir, 'tests'); + this.sqlDir = path.join(this.supabaseDir, 'sql'); + this.functionsDir = path.join(this.supabaseDir, 'functions'); + this.seedDir = path.join(this.supabaseDir, 'seed'); + this.supabaseConfig = path.join(this.supabaseDir, 'config.toml'); + this.dataConfig = path.join(this.projectRoot, '.datarc.json'); + this.buildDir = path.join(this.projectRoot, '.data', 'build'); + this.cacheDir = path.join(this.projectRoot, '.data', 'cache'); + this.tempDir = path.join(this.projectRoot, '.data', 'temp'); + this.logFile = path.join(this.projectRoot, '.data', 'data.log'); + this.errorLogFile = path.join(this.projectRoot, '.data', 'error.log'); + } + + _applyEnvironmentVariables() { + if (process.env.data_PROJECT_ROOT) this.projectRoot = process.env.data_PROJECT_ROOT; + if (process.env.data_SUPABASE_DIR) this.supabaseDir = process.env.data_SUPABASE_DIR; + if (process.env.data_MIGRATIONS_DIR) this.migrationsDir = process.env.data_MIGRATIONS_DIR; + if (process.env.data_TESTS_DIR) this.testsDir = process.env.data_TESTS_DIR; + if (process.env.data_SQL_DIR) this.sqlDir = process.env.data_SQL_DIR; + if (process.env.data_FUNCTIONS_DIR) this.functionsDir = process.env.data_FUNCTIONS_DIR; + if (process.env.data_BUILD_DIR) this.buildDir = process.env.data_BUILD_DIR; + if (process.env.data_CACHE_DIR) this.cacheDir = process.env.data_CACHE_DIR; + if (process.env.data_LOG_FILE) this.logFile = process.env.data_LOG_FILE; + } + + _loadConfigFile(configPath) { + const configFile = configPath || this.dataConfig; + + if (!fs.existsSync(configFile)) { + return; + } + + try { + const config = JSON.parse(fs.readFileSync(configFile, 'utf8')); + + if (config.paths) { + Object.assign(this, config.paths); + } + + if (config.directories) { + Object.assign(this, config.directories); + } + } catch (error) { + console.warn(`Warning: Could not parse config file ${configFile}:`, error.message); + } + } + + _applyCliOptions( + projectRoot, + supabaseDir, + migrationsDir, + testsDir, + sqlDir, + functionsDir, + outputDir + ) { + if (projectRoot) this.projectRoot = projectRoot; + if (supabaseDir) this.supabaseDir = supabaseDir; + if (migrationsDir) this.migrationsDir = migrationsDir; + if (testsDir) this.testsDir = testsDir; + if (sqlDir) this.sqlDir = sqlDir; + if (functionsDir) this.functionsDir = functionsDir; + if (outputDir) this.buildDir = outputDir; + } + + _resolveAllPaths() { + const pathProps = [ + 'projectRoot', + 'supabaseDir', + 'migrationsDir', + 'testsDir', + 'sqlDir', + 'functionsDir', + 'seedDir', + 'supabaseConfig', + 'dataConfig', + 'buildDir', + 'cacheDir', + 'tempDir', + 'logFile', + 'errorLogFile' + ]; + + for (const prop of pathProps) { + if (this[prop] && typeof this[prop] === 'string' && !path.isAbsolute(this[prop])) { + this[prop] = path.resolve(this[prop]); + } + } + } + + _validatePaths() { + const createIfMissing = [this.buildDir, this.cacheDir, this.tempDir, this.migrationsDir]; + + for (const dir of createIfMissing) { + if (dir && !fs.existsSync(dir)) { + try { + fs.mkdirSync(dir, { recursive: true }); + } catch { + // Silent - directories will be created when needed + } + } + } + } + + exists(pathProperty) { + const value = this[pathProperty]; + return value && fs.existsSync(value); + } + + getRelative(pathProperty) { + const value = this[pathProperty]; + return value ? path.relative(process.cwd(), value) : null; + } + + debug() { + console.log('\nOutputConfig Paths:'); + console.log('โ•'.repeat(60)); + + const categories = { + Core: ['projectRoot', 'supabaseDir'], + Supabase: ['migrationsDir', 'testsDir', 'sqlDir', 'functionsDir', 'seedDir'], + Config: ['supabaseConfig', 'dataConfig'], + Output: ['buildDir', 'cacheDir', 'tempDir'], + Logs: ['logFile', 'errorLogFile'] + }; + + for (const [category, props] of Object.entries(categories)) { + console.log(`\n${category}:`); + for (const prop of props) { + const value = this[prop]; + const exists = value && fs.existsSync(value); + const mark = exists ? 'โœ“' : 'โœ—'; + const display = this.getRelative(prop) || value || '(not set)'; + console.log(` ${mark} ${prop}: ${display}`); + } + } + + console.log('\n' + 'โ•'.repeat(60) + '\n'); + } +} + +export default OutputConfig; diff --git a/starfleet/data-core/src/domain/MigrationMetadata.js b/starfleet/data-core/src/domain/MigrationMetadata.js new file mode 100644 index 0000000..bcd47c2 --- /dev/null +++ b/starfleet/data-core/src/domain/MigrationMetadata.js @@ -0,0 +1,347 @@ +/** + * Migration metadata validation and processing (pure logic) + * Handles validation, creation, and manipulation of migration metadata + * No filesystem dependencies - data is passed in/out + */ + +/** + * Migration metadata management class (pure logic version) + * Handles parsing, validation, and manipulation of migration metadata + */ +export class MigrationMetadata { + constructor() { + this.schema = this._getSchema(); + } + + /** + * Validate metadata against schema + * @param {Object} metadata - Metadata object to validate + * @returns {Object} Validation result + */ + validate(metadata) { + if (!metadata || typeof metadata !== 'object') { + return { + valid: false, + errors: ['Metadata must be an object'] + }; + } + + const errors = []; + + // Required fields + if (!metadata.id || typeof metadata.id !== 'string') { + errors.push('id is required and must be a string'); + } + + if (!metadata.name || typeof metadata.name !== 'string') { + errors.push('name is required and must be a string'); + } + + if (!metadata.generated || typeof metadata.generated !== 'string') { + errors.push('generated is required and must be a string'); + } else if (!this._isValidISO8601(metadata.generated)) { + errors.push('generated must be a valid ISO 8601 date string'); + } + + // Status validation + const validStatuses = ['pending', 'tested', 'promoted']; + if (!metadata.status || !validStatuses.includes(metadata.status)) { + errors.push(`status must be one of: ${validStatuses.join(', ')}`); + } + + // Testing object validation + if (metadata.testing) { + if (typeof metadata.testing !== 'object') { + errors.push('testing must be an object'); + } else { + if ( + metadata.testing.tested_at !== null && + (!metadata.testing.tested_at || !this._isValidISO8601(metadata.testing.tested_at)) + ) { + errors.push('testing.tested_at must be null or valid ISO 8601 date string'); + } + + if ( + metadata.testing.tests_passed !== undefined && + (!Number.isInteger(metadata.testing.tests_passed) || metadata.testing.tests_passed < 0) + ) { + errors.push('testing.tests_passed must be a non-negative integer'); + } + + if ( + metadata.testing.tests_failed !== undefined && + (!Number.isInteger(metadata.testing.tests_failed) || metadata.testing.tests_failed < 0) + ) { + errors.push('testing.tests_failed must be a non-negative integer'); + } + } + } + + // Promotion object validation + if (metadata.promotion) { + if (typeof metadata.promotion !== 'object') { + errors.push('promotion must be an object'); + } else { + if ( + metadata.promotion.promoted_at !== null && + (!metadata.promotion.promoted_at || !this._isValidISO8601(metadata.promotion.promoted_at)) + ) { + errors.push('promotion.promoted_at must be null or valid ISO 8601 date string'); + } + + if ( + metadata.promotion.promoted_by !== null && + (!metadata.promotion.promoted_by || typeof metadata.promotion.promoted_by !== 'string') + ) { + errors.push('promotion.promoted_by must be null or a non-empty string'); + } + } + } + + return { + valid: errors.length === 0, + errors + }; + } + + /** + * Partially update metadata with new values + * @param {Object} existing - Existing metadata + * @param {Object} updates - Object containing fields to update + * @returns {Object} Updated metadata object + */ + update(existing, updates) { + if (!updates || typeof updates !== 'object') { + throw new Error('Updates must be an object'); + } + + if (!existing || typeof existing !== 'object') { + throw new Error('Existing metadata must be an object'); + } + + // Deep merge updates + const updated = this._deepMerge(existing, updates); + + // Validate updated metadata + const validation = this.validate(updated); + if (!validation.valid) { + throw new Error(`Metadata validation failed:\n${validation.errors.join('\n')}`); + } + + return updated; + } + + /** + * Create a new metadata object with default values + * @param {string} id - Migration ID + * @param {string} name - Migration name + * @returns {Object} New metadata object + */ + static createDefault(id, name) { + if (!id || typeof id !== 'string') { + throw new Error('id is required and must be a string'); + } + + if (!name || typeof name !== 'string') { + throw new Error('name is required and must be a string'); + } + + return { + id, + name, + generated: new Date().toISOString(), + status: 'pending', + testing: { + tested_at: null, + tests_passed: 0, + tests_failed: 0 + }, + promotion: { + promoted_at: null, + promoted_by: null + } + }; + } + + /** + * Update test results in metadata + * @param {Object} metadata - Existing metadata + * @param {Object} testResults - Test results to update + * @returns {Object} Updated metadata + */ + updateTestResults(metadata, testResults) { + const updates = { + status: testResults.failed === 0 ? 'tested' : 'pending', + testing: { + tested_at: new Date().toISOString(), + tests_passed: testResults.passed || 0, + tests_failed: testResults.failed || 0 + } + }; + + return this.update(metadata, updates); + } + + /** + * Update promotion information in metadata + * @param {Object} metadata - Existing metadata + * @param {string} promotedBy - Who promoted the migration + * @returns {Object} Updated metadata + */ + updatePromotion(metadata, promotedBy) { + const updates = { + status: 'promoted', + promotion: { + promoted_at: new Date().toISOString(), + promoted_by: promotedBy + } + }; + + return this.update(metadata, updates); + } + + /** + * Check if metadata indicates migration is ready for promotion + * @param {Object} metadata - Metadata to check + * @returns {Object} Readiness check result + */ + checkPromotionReadiness(metadata) { + const validation = this.validate(metadata); + if (!validation.valid) { + return { + ready: false, + reason: 'Metadata is invalid', + errors: validation.errors + }; + } + + if (metadata.status !== 'tested') { + return { + ready: false, + reason: `Migration status is '${metadata.status}', must be 'tested'` + }; + } + + if (!metadata.testing?.tested_at) { + return { + ready: false, + reason: 'Migration has not been tested' + }; + } + + if (metadata.testing.tests_failed > 0) { + return { + ready: false, + reason: `Migration has ${metadata.testing.tests_failed} failing tests` + }; + } + + return { + ready: true, + reason: 'Migration is ready for promotion' + }; + } + + /** + * Generate summary information from metadata + * @param {Object} metadata - Metadata to summarize + * @returns {Object} Summary information + */ + generateSummary(metadata) { + const validation = this.validate(metadata); + + return { + id: metadata.id, + name: metadata.name, + status: metadata.status, + generated: metadata.generated, + valid: validation.valid, + errors: validation.errors || [], + testingSummary: metadata.testing + ? { + tested: metadata.testing.tested_at !== null, + testedAt: metadata.testing.tested_at, + passed: metadata.testing.tests_passed || 0, + failed: metadata.testing.tests_failed || 0, + total: (metadata.testing.tests_passed || 0) + (metadata.testing.tests_failed || 0) + } + : null, + promotionSummary: metadata.promotion + ? { + promoted: metadata.promotion.promoted_at !== null, + promotedAt: metadata.promotion.promoted_at, + promotedBy: metadata.promotion.promoted_by + } + : null + }; + } + + /** + * Get the metadata schema definition + * @returns {Object} Schema object + * @private + */ + _getSchema() { + return { + type: 'object', + required: ['id', 'name', 'generated', 'status'], + properties: { + id: { type: 'string' }, + name: { type: 'string' }, + generated: { type: 'string', format: 'date-time' }, + status: { enum: ['pending', 'tested', 'promoted'] }, + testing: { + type: 'object', + properties: { + tested_at: { type: ['string', 'null'], format: 'date-time' }, + tests_passed: { type: 'integer', minimum: 0 }, + tests_failed: { type: 'integer', minimum: 0 } + } + }, + promotion: { + type: 'object', + properties: { + promoted_at: { type: ['string', 'null'], format: 'date-time' }, + promoted_by: { type: ['string', 'null'] } + } + } + } + }; + } + + /** + * Validate ISO 8601 date string + * @param {string} dateString - Date string to validate + * @returns {boolean} True if valid ISO 8601 + * @private + */ + _isValidISO8601(dateString) { + const date = new Date(dateString); + return date instanceof Date && !isNaN(date.getTime()) && dateString === date.toISOString(); + } + + /** + * Deep merge two objects + * @param {Object} target - Target object + * @param {Object} source - Source object + * @returns {Object} Merged object + * @private + */ + _deepMerge(target, source) { + const result = { ...target }; + + for (const key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) { + result[key] = this._deepMerge(result[key] || {}, source[key]); + } else { + result[key] = source[key]; + } + } + } + + return result; + } +} + +export default MigrationMetadata; diff --git a/starfleet/data-core/src/domain/testingTypes.js b/starfleet/data-core/src/domain/testingTypes.js new file mode 100644 index 0000000..e8fd18b --- /dev/null +++ b/starfleet/data-core/src/domain/testingTypes.js @@ -0,0 +1,58 @@ +/** + * @fileoverview Domain types for testing requirements + * Pure data structures with no dependencies + */ + +/** + * Test requirement types + * @readonly + * @enum {string} + */ +export const TEST_TYPES = { + SCHEMA: 'SCHEMA', // Table structure tests + DATA: 'DATA', // Data integrity tests + CONSTRAINT: 'CONSTRAINT', // Constraint validation tests + INDEX: 'INDEX', // Index existence and performance tests + FUNCTION: 'FUNCTION', // Function behavior tests + TRIGGER: 'TRIGGER', // Trigger functionality tests + RLS: 'RLS', // Row Level Security tests + VIEW: 'VIEW', // View definition tests + ENUM: 'ENUM', // Enum type tests + PERMISSION: 'PERMISSION' // Permission and security tests +}; + +/** + * Test priority levels + * @readonly + * @enum {string} + */ +export const TEST_PRIORITIES = { + CRITICAL: 'CRITICAL', // Must have - blocks deployment + HIGH: 'HIGH', // Should have - important coverage + MEDIUM: 'MEDIUM', // Nice to have - good practice + LOW: 'LOW' // Optional - comprehensive coverage +}; + +/** + * Test requirement object + * @typedef {Object} TestRequirement + * @property {string} type - Test type from TEST_TYPES + * @property {string} priority - Test priority from TEST_PRIORITIES + * @property {string} description - Human-readable description + * @property {string} target - Target object (table, column, function, etc.) + * @property {Array} testCases - Suggested test cases to implement + * @property {Object} metadata - Additional context for test generation + * @property {Object} vars - Variables for pattern rendering + * @property {string} [reason] - Why this test is required + * @property {Array} [dependencies] - Other tests this depends on + */ + +/** + * Test analysis result + * @typedef {Object} TestAnalysis + * @property {Array} requirements - All test requirements + * @property {Object} summary - Summary statistics + * @property {Array} suggestions - High-level testing suggestions + * @property {number} estimatedEffort - Estimated effort in hours + * @property {Array} riskAreas - Areas requiring extra attention + */ diff --git a/starfleet/data-core/src/domain/types.js b/starfleet/data-core/src/domain/types.js new file mode 100644 index 0000000..7c2478b --- /dev/null +++ b/starfleet/data-core/src/domain/types.js @@ -0,0 +1,111 @@ +/** + * Domain Types - Core business types with JSDoc + * Pure type definitions - no implementation + */ + +/** + * @typedef {Object} MigrationStep + * @property {string} id - Unique identifier (hash of SQL content) + * @property {string} path - Source file path + * @property {string} sql - SQL content + * @property {string} checksum - Content checksum + */ + +/** + * @typedef {Object} MigrationPlan + * @property {MigrationStep[]} steps - Ordered migration steps + * @property {string} preview - Human-readable preview + * @property {string} checksum - Plan checksum + * @property {number} timestamp - Creation timestamp (ms) + * @property {string} name - Migration name + */ + +/** + * @typedef {Object} MigrationResult + * @property {number} applied - Number of steps applied + * @property {boolean} dryRun - Whether this was a dry run + * @property {number} duration - Execution time in ms + * @property {boolean} success - Whether migration succeeded + * @property {Array<{step: string, error: string}>} [errors] - Any errors encountered + */ + +/** + * @typedef {Object} SafetyGatePolicy + * @property {boolean} [requireClean] - Require clean working tree + * @property {string[]} [allowedBranches] - List of allowed branch names + * @property {boolean} [requireTests] - Require tests to pass + * @property {string[]} [testGlobs] - Test file patterns + * @property {boolean} [requireUpToDate] - Require branch up to date with remote + */ + +/** + * @typedef {Object} SafetyGateResult + * @property {boolean} passed - Whether all checks passed + * @property {string[]} failures - List of failed check names + * @property {Object} details - Detailed check results + */ + +/** + * @typedef {Object} CompilationOptions + * @property {string} sqlRoot - Root directory for SQL files + * @property {string} outputDir - Output directory for compiled files + * @property {boolean} [minify] - Whether to minify output + * @property {boolean} [sourceMaps] - Whether to generate source maps + */ + +/** + * @typedef {Object} TestRunOptions + * @property {string[]} patterns - Test file patterns + * @property {number} [timeout] - Test timeout in ms + * @property {boolean} [coverage] - Whether to collect coverage + * @property {string} [reporter] - Output format (tap, json, junit) + */ + +/** + * @typedef {Object} TestResult + * @property {number} passed - Number of passed tests + * @property {number} failed - Number of failed tests + * @property {number} total - Total number of tests + * @property {number} duration - Test run duration in ms + * @property {string[]} failures - Failed test descriptions + * @property {Object} [coverage] - Coverage data if collected + */ + +/** + * @typedef {Object} DeploymentOptions + * @property {string} environment - Target environment (dev, staging, prod) + * @property {boolean} [dryRun] - Whether to do a dry run + * @property {string[]} [functions] - Specific functions to deploy + * @property {boolean} [skipValidation] - Skip validation checks + */ + +/** + * @typedef {Object} DeploymentResult + * @property {boolean} success - Whether deployment succeeded + * @property {string[]} deployed - List of deployed resources + * @property {string[]} skipped - List of skipped resources + * @property {Object} [errors] - Any errors encountered + */ + +// Export as frozen enums for safety +export const MigrationStatus = Object.freeze({ + PENDING: 'pending', + IN_PROGRESS: 'in_progress', + APPLIED: 'applied', + FAILED: 'failed', + ROLLED_BACK: 'rolled_back' +}); + +export const Environment = Object.freeze({ + LOCAL: 'local', + DEV: 'dev', + STAGING: 'staging', + PROD: 'prod' +}); + +export const TestReporter = Object.freeze({ + TAP: 'tap', + JSON: 'json', + JUNIT: 'junit', + CONSOLE: 'console' +}); diff --git a/starfleet/data-core/src/events/EventTypes.js b/starfleet/data-core/src/events/EventTypes.js new file mode 100644 index 0000000..66baee5 --- /dev/null +++ b/starfleet/data-core/src/events/EventTypes.js @@ -0,0 +1,51 @@ +/** + * EventTypes - Core event type definitions + * No Node EventEmitter dependency - pure constants + */ + +export const Events = { + // Migration events + MIGRATION_PLAN_STARTED: 'migration.plan.started', + MIGRATION_PLAN_STEP: 'migration.plan.step', + MIGRATION_PLAN_READY: 'migration.plan.ready', + MIGRATION_APPLY_STARTED: 'migration.apply.started', + MIGRATION_APPLY_STEP: 'migration.apply.step', + MIGRATION_APPLY_DONE: 'migration.apply.done', + MIGRATION_ROLLBACK_STARTED: 'migration.rollback.started', + MIGRATION_ROLLBACK_DONE: 'migration.rollback.done', + + // Safety gate events + SAFETY_CHECKS_STARTED: 'safety.checks.started', + SAFETY_CHECK_ITEM: 'safety.check.item', + SAFETY_CHECKS_RESULT: 'safety.checks.result', + + // Compilation events + COMPILE_STARTED: 'compile.started', + COMPILE_FILE: 'compile.file', + COMPILE_DONE: 'compile.done', + + // Test events + TEST_RUN_STARTED: 'test.run.started', + TEST_FILE: 'test.file', + TEST_PASSED: 'test.passed', + TEST_FAILED: 'test.failed', + TEST_RUN_DONE: 'test.run.done', + + // Coverage events + COVERAGE_STARTED: 'coverage.started', + COVERAGE_COMPUTED: 'coverage.computed', + COVERAGE_DONE: 'coverage.done', + + // Function deployment events + FUNCTION_DEPLOY_STARTED: 'function.deploy.started', + FUNCTION_VALIDATE: 'function.validate', + FUNCTION_DEPLOY_DONE: 'function.deploy.done', + + // Generic command events + COMMAND_STARTED: 'command.started', + COMMAND_PROGRESS: 'command.progress', + COMMAND_WARNING: 'command.warning', + COMMAND_ERROR: 'command.error', + COMMAND_SUCCESS: 'command.success', + COMMAND_DONE: 'command.done' +}; diff --git a/starfleet/data-core/src/events/MigrationEvent.js b/starfleet/data-core/src/events/MigrationEvent.js new file mode 100644 index 0000000..ada2a0b --- /dev/null +++ b/starfleet/data-core/src/events/MigrationEvent.js @@ -0,0 +1,21 @@ +/** + * MigrationEvent - Migration event data structure + * Pure data class - no dependencies + */ +export class MigrationEvent { + /** + * @param {string} type - Event type from EventTypes + * @param {Object} data - Event data + * @param {string} [data.migrationName] - Migration name + * @param {number} [data.step] - Current step number + * @param {number} [data.totalSteps] - Total steps + * @param {string} [data.sqlFile] - SQL file being processed + * @param {string} [data.preview] - Migration preview + * @param {Date} [data.timestamp] - Event timestamp + */ + constructor(type, data = {}) { + this.type = type; + this.data = data; + this.timestamp = data.timestamp || new Date(); + } +} diff --git a/starfleet/data-core/src/events/index.js b/starfleet/data-core/src/events/index.js new file mode 100644 index 0000000..5bf1e8e --- /dev/null +++ b/starfleet/data-core/src/events/index.js @@ -0,0 +1,5 @@ +/** + * Events index - Export all event types + */ + +export { Events } from './EventTypes.js'; diff --git a/starfleet/data-core/src/index.js b/starfleet/data-core/src/index.js new file mode 100644 index 0000000..7e56509 --- /dev/null +++ b/starfleet/data-core/src/index.js @@ -0,0 +1,41 @@ +/** + * @starfleet/core - Pure JavaScript Logic Core + * + * This module exports all the pure business logic classes and utilities + * that have zero I/O dependencies. Perfect for testing, server-side rendering, + * or any environment where you need the core logic without file system access. + */ + +// Core utilities +export { default as PathResolver } from './PathResolver.js'; +export { default as DataInputPaths } from './DataInputPaths.js'; +export { default as DataOutputPaths } from './DataOutputPaths.js'; +export { default as ConfigSchema } from './ConfigSchema.js'; + +// Error handling +export { default as dataErrorBase } from './ArchyErrorBase.js'; + +// Migration logic +export { default as MigrationMetadata } from './MigrationMetadata.js'; +export { default as GitDeploymentLogic } from './GitDeploymentTracker.js'; + +// Safety gates +export { default as SafetyGateRules } from './SafetyGates.js'; + +// Schema definitions +export * from './schemas/DataConfigSchema.js'; + +// Test utilities +export { default as ResultParser } from './test/ResultParser.js'; +export { default as CoverageAnalyzer } from './test/CoverageAnalyzer.js'; + +// Testing libraries +export { default as TestPatternLibrary } from './testing/TestPatternLibrary.js'; +export { default as TestRequirementSchema } from './testing/TestRequirementSchema.js'; + +// Migration engines (pure logic parts) +export { default as ASTMigrationEngine } from './migration/ASTMigrationEngine.js'; +export { default as SchemaDiffAnalyzer } from './migration/SchemaDiffAnalyzer.js'; + +// Re-export commonly used constants +export const DEPLOYMENT_TAG_PREFIX = 'data-deploy-'; diff --git a/src/lib/migration/ASTMigrationEngine.js b/starfleet/data-core/src/migration/ASTMigrationEngine.js similarity index 81% rename from src/lib/migration/ASTMigrationEngine.js rename to starfleet/data-core/src/migration/ASTMigrationEngine.js index 2ad414b..a21b35e 100644 --- a/src/lib/migration/ASTMigrationEngine.js +++ b/starfleet/data-core/src/migration/ASTMigrationEngine.js @@ -1,14 +1,5 @@ -/** - * AST-based Migration Engine for D.A.T.A. - * - * Pure JavaScript PostgreSQL migration generator using AST parsing - * No Python dependencies, no temporary databases - * - * @module ASTMigrationEngine - */ - -const { parse } = require('pgsql-parser'); -const { EventEmitter } = require('events'); +import { parse } from 'pgsql-parser'; +import { EventEmitter } from 'events'; /** * Represents a single migration operation @@ -35,7 +26,7 @@ const { EventEmitter } = require('events'); class ASTMigrationEngine extends EventEmitter { constructor() { super(); - + // Destructive operation patterns this.DESTRUCTIVE_PATTERNS = [ 'DROP TABLE', @@ -51,7 +42,7 @@ class ASTMigrationEngine extends EventEmitter { 'ALTER COLUMN.*DROP DEFAULT', 'ALTER COLUMN.*DROP NOT NULL' ]; - + // Supabase-specific object patterns this.SUPABASE_PATTERNS = { storage: /storage\.(buckets|objects)/i, @@ -69,55 +60,55 @@ class ASTMigrationEngine extends EventEmitter { */ async generateMigration(fromSQL, toSQL) { this.emit('start', { message: 'Parsing SQL into AST...' }); - + try { // Parse both SQL states into AST const fromSchema = await this.parseSchema(fromSQL); const toSchema = await this.parseSchema(toSQL); - - this.emit('progress', { + + this.emit('progress', { message: 'Analyzing schema differences...', fromObjects: this.countObjects(fromSchema), toObjects: this.countObjects(toSchema) }); - + // Generate migrations for each object type const migrations = []; - + // Tables (most complex - includes columns, constraints) - migrations.push(...await this.diffTables(fromSchema.tables, toSchema.tables)); - + migrations.push(...(await this.diffTables(fromSchema.tables, toSchema.tables))); + // Functions and Triggers - migrations.push(...await this.diffFunctions(fromSchema.functions, toSchema.functions)); - migrations.push(...await this.diffTriggers(fromSchema.triggers, toSchema.triggers)); - + migrations.push(...(await this.diffFunctions(fromSchema.functions, toSchema.functions))); + migrations.push(...(await this.diffTriggers(fromSchema.triggers, toSchema.triggers))); + // RLS Policies (Supabase critical) - migrations.push(...await this.diffPolicies(fromSchema.policies, toSchema.policies)); - + migrations.push(...(await this.diffPolicies(fromSchema.policies, toSchema.policies))); + // Enums and Custom Types - migrations.push(...await this.diffEnums(fromSchema.enums, toSchema.enums)); - + migrations.push(...(await this.diffEnums(fromSchema.enums, toSchema.enums))); + // Indexes - migrations.push(...await this.diffIndexes(fromSchema.indexes, toSchema.indexes)); - + migrations.push(...(await this.diffIndexes(fromSchema.indexes, toSchema.indexes))); + // Views - migrations.push(...await this.diffViews(fromSchema.views, toSchema.views)); - + migrations.push(...(await this.diffViews(fromSchema.views, toSchema.views))); + // Detect destructive operations - const destructive = migrations.filter(m => m.type === 'DESTRUCTIVE'); + const destructive = migrations.filter((m) => m.type === 'DESTRUCTIVE'); if (destructive.length > 0) { this.emit('warning', { message: `${destructive.length} destructive operations detected`, operations: destructive }); } - + this.emit('complete', { message: 'Migration generation complete', totalOperations: migrations.length, destructiveCount: destructive.length }); - + return migrations; } catch (error) { this.emit('error', { @@ -145,60 +136,70 @@ class ASTMigrationEngine extends EventEmitter { extensions: new Map(), grants: new Map() }; - + try { const ast = parse(sql); - + for (const statement of ast) { const stmt = statement.RawStmt?.stmt; if (!stmt) continue; - - switch (stmt.CreateStmt ? 'CreateStmt' : - stmt.AlterTableStmt ? 'AlterTableStmt' : - stmt.CreateFunctionStmt ? 'CreateFunctionStmt' : - stmt.CreateTrigStmt ? 'CreateTrigStmt' : - stmt.CreatePolicyStmt ? 'CreatePolicyStmt' : - stmt.CreateEnumStmt ? 'CreateEnumStmt' : - stmt.IndexStmt ? 'IndexStmt' : - stmt.ViewStmt ? 'ViewStmt' : null) { - - case 'CreateStmt': - this.parseTable(stmt.CreateStmt, schema.tables); - break; - - case 'CreateFunctionStmt': - this.parseFunction(stmt.CreateFunctionStmt, schema.functions); - break; - - case 'CreateTrigStmt': - this.parseTrigger(stmt.CreateTrigStmt, schema.triggers); - break; - - case 'CreatePolicyStmt': - this.parsePolicy(stmt.CreatePolicyStmt, schema.policies); - break; - - case 'CreateEnumStmt': - this.parseEnum(stmt.CreateEnumStmt, schema.enums); - break; - - case 'IndexStmt': - this.parseIndex(stmt.IndexStmt, schema.indexes); - break; - - case 'ViewStmt': - this.parseView(stmt.ViewStmt, schema.views); - break; + + switch ( + stmt.CreateStmt + ? 'CreateStmt' + : stmt.AlterTableStmt + ? 'AlterTableStmt' + : stmt.CreateFunctionStmt + ? 'CreateFunctionStmt' + : stmt.CreateTrigStmt + ? 'CreateTrigStmt' + : stmt.CreatePolicyStmt + ? 'CreatePolicyStmt' + : stmt.CreateEnumStmt + ? 'CreateEnumStmt' + : stmt.IndexStmt + ? 'IndexStmt' + : stmt.ViewStmt + ? 'ViewStmt' + : null + ) { + case 'CreateStmt': + this.parseTable(stmt.CreateStmt, schema.tables); + break; + + case 'CreateFunctionStmt': + this.parseFunction(stmt.CreateFunctionStmt, schema.functions); + break; + + case 'CreateTrigStmt': + this.parseTrigger(stmt.CreateTrigStmt, schema.triggers); + break; + + case 'CreatePolicyStmt': + this.parsePolicy(stmt.CreatePolicyStmt, schema.policies); + break; + + case 'CreateEnumStmt': + this.parseEnum(stmt.CreateEnumStmt, schema.enums); + break; + + case 'IndexStmt': + this.parseIndex(stmt.IndexStmt, schema.indexes); + break; + + case 'ViewStmt': + this.parseView(stmt.ViewStmt, schema.views); + break; } } } catch (error) { // Some SQL might not parse perfectly, log but continue - this.emit('warning', { + this.emit('warning', { message: 'Some SQL statements could not be parsed', - error: error.message + error: error.message }); } - + return schema; } @@ -207,7 +208,7 @@ class ASTMigrationEngine extends EventEmitter { */ async diffTables(fromTables, toTables) { const migrations = []; - + // New tables for (const [name, table] of toTables) { if (!fromTables.has(name)) { @@ -218,7 +219,7 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Dropped tables (DESTRUCTIVE!) for (const [name, table] of fromTables) { if (!toTables.has(name)) { @@ -231,7 +232,7 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Modified tables (column changes) for (const [name, toTable] of toTables) { if (fromTables.has(name)) { @@ -239,7 +240,7 @@ class ASTMigrationEngine extends EventEmitter { migrations.push(...this.diffTableColumns(name, fromTable, toTable)); } } - + return migrations; } @@ -248,9 +249,9 @@ class ASTMigrationEngine extends EventEmitter { */ diffTableColumns(tableName, fromTable, toTable) { const migrations = []; - const fromColumns = new Map(fromTable.columns?.map(c => [c.name, c]) || []); - const toColumns = new Map(toTable.columns?.map(c => [c.name, c]) || []); - + const fromColumns = new Map(fromTable.columns?.map((c) => [c.name, c]) || []); + const toColumns = new Map(toTable.columns?.map((c) => [c.name, c]) || []); + // Added columns (SAFE) for (const [colName, col] of toColumns) { if (!fromColumns.has(colName)) { @@ -261,7 +262,7 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Dropped columns (DESTRUCTIVE!) for (const [colName, col] of fromColumns) { if (!toColumns.has(colName)) { @@ -274,12 +275,12 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Modified columns (check type, nullable, default) for (const [colName, toCol] of toColumns) { if (fromColumns.has(colName)) { const fromCol = fromColumns.get(colName); - + // Type change (potentially DESTRUCTIVE) if (this.columnTypesDiffer(fromCol, toCol)) { migrations.push({ @@ -289,7 +290,7 @@ class ASTMigrationEngine extends EventEmitter { warning: 'Type change may result in data loss or errors' }); } - + // Nullable change if (fromCol.nullable !== toCol.nullable) { if (toCol.nullable) { @@ -307,7 +308,7 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Default value change if (this.defaultsDiffer(fromCol.default, toCol.default)) { if (toCol.default) { @@ -326,7 +327,7 @@ class ASTMigrationEngine extends EventEmitter { } } } - + return migrations; } @@ -335,7 +336,7 @@ class ASTMigrationEngine extends EventEmitter { */ async diffPolicies(fromPolicies, toPolicies) { const migrations = []; - + // New policies for (const [key, policy] of toPolicies) { if (!fromPolicies.has(key)) { @@ -346,7 +347,7 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Dropped policies for (const [key, policy] of fromPolicies) { if (!toPolicies.has(key)) { @@ -358,7 +359,7 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Modified policies (drop and recreate) for (const [key, toPolicy] of toPolicies) { if (fromPolicies.has(key)) { @@ -373,7 +374,7 @@ class ASTMigrationEngine extends EventEmitter { } } } - + return migrations; } @@ -382,7 +383,7 @@ class ASTMigrationEngine extends EventEmitter { */ async diffFunctions(fromFunctions, toFunctions) { const migrations = []; - + for (const [signature, toFunc] of toFunctions) { if (!fromFunctions.has(signature)) { // New function @@ -403,7 +404,7 @@ class ASTMigrationEngine extends EventEmitter { } } } - + // Dropped functions for (const [signature, func] of fromFunctions) { if (!toFunctions.has(signature)) { @@ -415,14 +416,14 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + return migrations; } /** * Helper methods for reconstruction and comparison */ - + reconstructColumn(col) { let sql = `${col.name} ${col.type}`; if (col.default) sql += ` DEFAULT ${col.default}`; @@ -430,12 +431,12 @@ class ASTMigrationEngine extends EventEmitter { if (col.unique) sql += ' UNIQUE'; return sql; } - + reconstructCreateTable(table) { - const columns = table.columns.map(c => this.reconstructColumn(c)); + const columns = table.columns.map((c) => this.reconstructColumn(c)); return `CREATE TABLE ${table.name} (\n ${columns.join(',\n ')}\n)`; } - + reconstructPolicy(policy) { return `CREATE POLICY ${policy.name} ON ${policy.table} FOR ${policy.command || 'ALL'} @@ -444,7 +445,7 @@ class ASTMigrationEngine extends EventEmitter { ${policy.using ? `USING (${policy.using})` : ''} ${policy.check ? `WITH CHECK (${policy.check})` : ''}`; } - + reconstructFunction(func) { return `${func.name}(${func.arguments || ''}) RETURNS ${func.returnType} @@ -452,26 +453,28 @@ class ASTMigrationEngine extends EventEmitter { ${func.volatility || ''} AS $$${func.body}$$`; } - + columnTypesDiffer(col1, col2) { // Normalize types for comparison const normalize = (type) => type?.toLowerCase().replace(/\s+/g, ''); return normalize(col1.type) !== normalize(col2.type); } - + defaultsDiffer(def1, def2) { // Handle various default formats const normalize = (def) => def?.toString().replace(/['"]/g, '').trim(); return normalize(def1) !== normalize(def2); } - + policiesDiffer(pol1, pol2) { - return pol1.using !== pol2.using || - pol1.check !== pol2.check || - pol1.command !== pol2.command || - pol1.role !== pol2.role; + return ( + pol1.using !== pol2.using || + pol1.check !== pol2.check || + pol1.command !== pol2.command || + pol1.role !== pol2.role + ); } - + countObjects(schema) { return { tables: schema.tables.size, @@ -487,38 +490,41 @@ class ASTMigrationEngine extends EventEmitter { /** * Parse individual object types from AST */ - + parseTable(stmt, tables) { const tableName = stmt.relation?.relname; if (!tableName) return; - - const columns = stmt.tableElts?.map(elt => { - if (elt.ColumnDef) { - return { - name: elt.ColumnDef.colname, - type: this.extractType(elt.ColumnDef.typeName), - nullable: !elt.ColumnDef.is_not_null, - default: elt.ColumnDef.raw_default, - constraints: elt.ColumnDef.constraints - }; - } - }).filter(Boolean) || []; - + + const columns = + stmt.tableElts + ?.map((elt) => { + if (elt.ColumnDef) { + return { + name: elt.ColumnDef.colname, + type: this.extractType(elt.ColumnDef.typeName), + nullable: !elt.ColumnDef.is_not_null, + default: elt.ColumnDef.raw_default, + constraints: elt.ColumnDef.constraints + }; + } + }) + .filter(Boolean) || []; + tables.set(tableName, { name: tableName, columns, raw: stmt }); } - + parseFunction(stmt, functions) { const funcName = stmt.funcname?.[0]?.String?.str; if (!funcName) return; - + // Build signature - const args = stmt.parameters?.map(p => `${p.name} ${p.type}`).join(', ') || ''; + const args = stmt.parameters?.map((p) => `${p.name} ${p.type}`).join(', ') || ''; const signature = `${funcName}(${args})`; - + functions.set(signature, { name: funcName, signature, @@ -529,12 +535,12 @@ class ASTMigrationEngine extends EventEmitter { raw: stmt }); } - + parsePolicy(stmt, policies) { const policyName = stmt.policy_name; const tableName = stmt.table?.relname; if (!policyName || !tableName) return; - + const key = `${tableName}.${policyName}`; policies.set(key, { name: policyName, @@ -547,25 +553,25 @@ class ASTMigrationEngine extends EventEmitter { raw: stmt }); } - + parseEnum(stmt, enums) { const typeName = stmt.typeName?.[0]?.String?.str; if (!typeName) return; - - const values = stmt.vals?.map(v => v.String?.str).filter(Boolean) || []; - + + const values = stmt.vals?.map((v) => v.String?.str).filter(Boolean) || []; + enums.set(typeName, { name: typeName, values, raw: stmt }); } - + parseIndex(stmt, indexes) { const indexName = stmt.idxname; const tableName = stmt.relation?.relname; if (!indexName) return; - + indexes.set(indexName, { name: indexName, table: tableName, @@ -574,12 +580,12 @@ class ASTMigrationEngine extends EventEmitter { raw: stmt }); } - + parseTrigger(stmt, triggers) { const triggerName = stmt.trigname; const tableName = stmt.relation?.relname; if (!triggerName) return; - + triggers.set(triggerName, { name: triggerName, table: tableName, @@ -589,49 +595,49 @@ class ASTMigrationEngine extends EventEmitter { raw: stmt }); } - + parseView(stmt, views) { const viewName = stmt.view?.relname; if (!viewName) return; - + views.set(viewName, { name: viewName, query: stmt.query, raw: stmt }); } - + extractType(typeName) { if (!typeName) return 'unknown'; if (typeName.String) return typeName.String.str; - if (typeName.names) return typeName.names.map(n => n.String?.str).join('.'); + if (typeName.names) return typeName.names.map((n) => n.String?.str).join('.'); return 'unknown'; } /** * Additional diff methods */ - + async diffEnums(fromEnums, toEnums) { const migrations = []; - + // New enums for (const [name, enumDef] of toEnums) { if (!fromEnums.has(name)) { migrations.push({ type: 'SAFE', - sql: `CREATE TYPE ${name} AS ENUM (${enumDef.values.map(v => `'${v}'`).join(', ')})`, + sql: `CREATE TYPE ${name} AS ENUM (${enumDef.values.map((v) => `'${v}'`).join(', ')})`, description: `Create enum type: ${name}` }); } } - + // Modified enums (can only ADD values, not remove) for (const [name, toEnum] of toEnums) { if (fromEnums.has(name)) { const fromEnum = fromEnums.get(name); - const newValues = toEnum.values.filter(v => !fromEnum.values.includes(v)); - + const newValues = toEnum.values.filter((v) => !fromEnum.values.includes(v)); + for (const value of newValues) { migrations.push({ type: 'SAFE', @@ -639,27 +645,28 @@ class ASTMigrationEngine extends EventEmitter { description: `Add value '${value}' to enum ${name}` }); } - + // Check for removed values (PROBLEM!) - const removedValues = fromEnum.values.filter(v => !toEnum.values.includes(v)); + const removedValues = fromEnum.values.filter((v) => !toEnum.values.includes(v)); if (removedValues.length > 0) { migrations.push({ type: 'DESTRUCTIVE', sql: `-- MANUAL INTERVENTION REQUIRED: Cannot remove enum values ${removedValues.join(', ')} from ${name}`, description: `Cannot remove enum values from ${name}`, - warning: `PostgreSQL does not support removing enum values. Manual data migration required.`, + warning: + 'PostgreSQL does not support removing enum values. Manual data migration required.', requiresConfirmation: true }); } } } - + return migrations; } - + async diffIndexes(fromIndexes, toIndexes) { const migrations = []; - + // New indexes for (const [name, index] of toIndexes) { if (!fromIndexes.has(name)) { @@ -670,7 +677,7 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + // Dropped indexes for (const [name, index] of fromIndexes) { if (!toIndexes.has(name)) { @@ -682,13 +689,13 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + return migrations; } - + async diffTriggers(fromTriggers, toTriggers) { const migrations = []; - + // For triggers, we'll drop and recreate if changed for (const [name, toTrigger] of toTriggers) { if (!fromTriggers.has(name)) { @@ -709,7 +716,7 @@ class ASTMigrationEngine extends EventEmitter { } } } - + // Dropped triggers for (const [name, trigger] of fromTriggers) { if (!toTriggers.has(name)) { @@ -720,13 +727,13 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + return migrations; } - + async diffViews(fromViews, toViews) { const migrations = []; - + // Views are typically dropped and recreated for (const [name, toView] of toViews) { if (!fromViews.has(name)) { @@ -746,7 +753,7 @@ class ASTMigrationEngine extends EventEmitter { } } } - + // Dropped views for (const [name, view] of fromViews) { if (!toViews.has(name)) { @@ -758,10 +765,10 @@ class ASTMigrationEngine extends EventEmitter { }); } } - + return migrations; } - + reconstructTrigger(trigger) { return `CREATE TRIGGER ${trigger.name} ${trigger.timing} ${trigger.events} @@ -769,12 +776,10 @@ class ASTMigrationEngine extends EventEmitter { FOR EACH ROW EXECUTE FUNCTION ${trigger.function}()`; } - + triggersDiffer(t1, t2) { - return t1.timing !== t2.timing || - t1.events !== t2.events || - t1.function !== t2.function; + return t1.timing !== t2.timing || t1.events !== t2.events || t1.function !== t2.function; } } -module.exports = ASTMigrationEngine; \ No newline at end of file +export default ASTMigrationEngine; diff --git a/starfleet/data-core/src/migration/DiffEngine.js b/starfleet/data-core/src/migration/DiffEngine.js new file mode 100644 index 0000000..ac2be7a --- /dev/null +++ b/starfleet/data-core/src/migration/DiffEngine.js @@ -0,0 +1,360 @@ +/** + * Migration diff calculator for comparing database states and generating changes. + * Analyzes differences between current database schema and desired SQL state, + * producing minimal migration operations to transform the database. + * + * @fileoverview Database schema diff calculation and migration planning + */ + +import { CryptoPort, validatePort } from '../ports/index.js'; + +/** + * Types of database operations for migrations + * @readonly + * @enum {number} + */ +export const OperationType = { + CREATE_TABLE: 0, + DROP_TABLE: 1, + ALTER_TABLE: 2, + CREATE_INDEX: 3, + DROP_INDEX: 4, + CREATE_FUNCTION: 5, + DROP_FUNCTION: 6, + CREATE_VIEW: 7, + DROP_VIEW: 8, + INSERT_DATA: 9, + UPDATE_DATA: 10, + DELETE_DATA: 11 +}; + +/** + * Represents a single migration operation + */ +/** + * MigrationOperation class + * @class + */ +export class MigrationOperation { + /** + * @param {number} type - Operation type from OperationType enum + * @param {string} objectName - Name of database object being modified + * @param {string} sql - SQL statement to execute + * @param {Object} [metadata={}] - Additional operation metadata + */ + constructor(type, objectName, sql, metadata = {}) { + this.type = type; + this.objectName = objectName; + this.sql = sql; + this.metadata = metadata; + this.hash = null; + } + + /** + * Generate hash for this operation using provided crypto port + * @param {CryptoPort} cryptoPort - Crypto adapter + * @returns {string} Operation hash + */ + generateHash(cryptoPort) { + const data = `${this.type}:${this.objectName}:${this.sql}`; + this.hash = cryptoPort.hash(data); + return this.hash; + } + + /** + * Check if this operation is destructive (drops data) + * @returns {boolean} True if operation may destroy data + */ + isDestructive() { + return [ + OperationType.DROP_TABLE, + OperationType.DROP_INDEX, + OperationType.DROP_FUNCTION, + OperationType.DROP_VIEW, + OperationType.DELETE_DATA + ].includes(this.type); + } + + /** + * Get operation priority for execution ordering + * @returns {number} Priority (lower numbers execute first) + */ + getPriority() { + const priorities = { + [OperationType.DROP_VIEW]: 0, + [OperationType.DROP_FUNCTION]: 1, + [OperationType.DROP_INDEX]: 2, + [OperationType.ALTER_TABLE]: 3, + [OperationType.DROP_TABLE]: 4, + [OperationType.CREATE_TABLE]: 5, + [OperationType.CREATE_FUNCTION]: 6, + [OperationType.CREATE_VIEW]: 7, + [OperationType.CREATE_INDEX]: 8, + [OperationType.INSERT_DATA]: 9, + [OperationType.UPDATE_DATA]: 10, + [OperationType.DELETE_DATA]: 11 + }; + return priorities[this.type] ?? 50; + } +} + +/** + * Database schema state representation + */ +/** + * SchemaState class + * @class + */ +export class SchemaState { + /** + * @param {Object} [objects={}] - Database objects by type + * @param {string} [checksum=''] - Schema checksum + */ + constructor(objects = {}, checksum = '') { + this.objects = { + tables: new Map(), + views: new Map(), + functions: new Map(), + indexes: new Map(), + ...objects + }; + this.checksum = checksum; + } + + /** + * Add database object to schema state + * @param {string} type - Object type (table, view, function, index) + * @param {string} name - Object name + * @param {Object} definition - Object definition + */ + addObject(type, name, definition) { + if (!this.objects[type]) { + this.objects[type] = new Map(); + } + this.objects[type].set(name, definition); + } + + /** + * Get database object definition + * @param {string} type - Object type + * @param {string} name - Object name + * @returns {Object|undefined} Object definition + */ + getObject(type, name) { + return this.objects[type]?.get(name); + } + + /** + * Check if object exists in schema + * @param {string} type - Object type + * @param {string} name - Object name + * @returns {boolean} True if object exists + */ + hasObject(type, name) { + return this.objects[type]?.has(name) ?? false; + } + + /** + * Get all object names of specified type + * @param {string} type - Object type + * @returns {string[]} Array of object names + */ + getObjectNames(type) { + return Array.from(this.objects[type]?.keys() ?? []); + } + + /** + * Generate checksum for current state + * @param {CryptoPort} cryptoPort - Crypto adapter + * @returns {string} Schema checksum + */ + generateChecksum(cryptoPort) { + const serialized = JSON.stringify(this.objects, (key, value) => { + if (value instanceof Map) { + return Object.fromEntries(value); + } + return value; + }); + this.checksum = cryptoPort.hash(serialized); + return this.checksum; + } +} + +/** + * Migration diff calculator and operation generator + */ +/** + * DiffEngine class + * @class + */ +export class DiffEngine { + /** + * @param {CryptoPort} cryptoPort - Crypto adapter + */ + constructor(cryptoPort) { + validatePort(cryptoPort, CryptoPort); + this.cryptoPort = cryptoPort; + } + + /** + * Calculate diff between current and target schema states + * @param {SchemaState} currentState - Current database schema + * @param {SchemaState} targetState - Desired schema state + * @returns {MigrationOperation[]} Array of migration operations + */ + calculateDiff(currentState, targetState) { + const operations = []; + + // Compare each object type + const objectTypes = ['tables', 'views', 'functions', 'indexes']; + + for (const objectType of objectTypes) { + const currentObjects = currentState.objects[objectType] || new Map(); + const targetObjects = targetState.objects[objectType] || new Map(); + + // Find objects to drop (exist in current but not in target) + for (const [name, definition] of currentObjects) { + if (!targetObjects.has(name)) { + operations.push(this._createDropOperation(objectType, name, definition)); + } + } + + // Find objects to create or alter + for (const [name, targetDef] of targetObjects) { + const currentDef = currentObjects.get(name); + + if (!currentDef) { + // Create new object + operations.push(this._createCreateOperation(objectType, name, targetDef)); + } else if (!this._areDefinitionsEqual(currentDef, targetDef)) { + // Alter existing object + operations.push(this._createAlterOperation(objectType, name, currentDef, targetDef)); + } + } + } + + // Sort operations by priority + operations.sort((a, b) => a.getPriority() - b.getPriority()); + + // Generate hashes for all operations + operations.forEach((op) => op.generateHash(this.cryptoPort)); + + return operations; + } + + /** + * Create drop operation for database object + * @param {string} objectType - Type of object + * @param {string} name - Object name + * @param {Object} definition - Object definition + * @returns {MigrationOperation} Drop operation + * @private + */ + _createDropOperation(objectType, name, definition) { + const typeMap = { + tables: OperationType.DROP_TABLE, + views: OperationType.DROP_VIEW, + functions: OperationType.DROP_FUNCTION, + indexes: OperationType.DROP_INDEX + }; + + const sqlMap = { + tables: `DROP TABLE IF EXISTS ${name}`, + views: `DROP VIEW IF EXISTS ${name}`, + functions: `DROP FUNCTION IF EXISTS ${name}`, + indexes: `DROP INDEX IF EXISTS ${name}` + }; + + return new MigrationOperation(typeMap[objectType], name, sqlMap[objectType], { + originalDefinition: definition + }); + } + + /** + * Create create operation for database object + * @param {string} objectType - Type of object + * @param {string} name - Object name + * @param {Object} definition - Object definition + * @returns {MigrationOperation} Create operation + * @private + */ + _createCreateOperation(objectType, name, definition) { + const typeMap = { + tables: OperationType.CREATE_TABLE, + views: OperationType.CREATE_VIEW, + functions: OperationType.CREATE_FUNCTION, + indexes: OperationType.CREATE_INDEX + }; + + return new MigrationOperation( + typeMap[objectType], + name, + definition.sql || `CREATE ${objectType.slice(0, -1).toUpperCase()} ${name}`, + { definition } + ); + } + + /** + * Create alter operation for database object + * @param {string} objectType - Type of object + * @param {string} name - Object name + * @param {Object} currentDef - Current definition + * @param {Object} targetDef - Target definition + * @returns {MigrationOperation} Alter operation + * @private + */ + _createAlterOperation(objectType, name, currentDef, targetDef) { + // For simplicity, most alters are implemented as drop + create + // In a real implementation, this would generate specific ALTER statements + const alterSql = targetDef.sql || `-- ALTER ${objectType.slice(0, -1).toUpperCase()} ${name}`; + + return new MigrationOperation( + OperationType.ALTER_TABLE, // Simplified - would be more specific in real implementation + name, + alterSql, + { + currentDefinition: currentDef, + targetDefinition: targetDef, + changeType: 'modify' + } + ); + } + + /** + * Compare two object definitions for equality + * @param {Object} def1 - First definition + * @param {Object} def2 - Second definition + * @returns {boolean} True if definitions are equal + * @private + */ + _areDefinitionsEqual(def1, def2) { + // Simple hash-based comparison + const hash1 = this.cryptoPort.hash(JSON.stringify(def1)); + const hash2 = this.cryptoPort.hash(JSON.stringify(def2)); + return hash1 === hash2; + } + + /** + * Optimize operation list by removing redundant operations + * @param {MigrationOperation[]} operations - Operations to optimize + * @returns {MigrationOperation[]} Optimized operations + */ + optimizeOperations(operations) { + const optimized = []; + const processedObjects = new Set(); + + for (const op of operations) { + const key = `${op.type}:${op.objectName}`; + + // Skip if we've already processed this object with the same operation + if (processedObjects.has(key)) { + continue; + } + + processedObjects.add(key); + optimized.push(op); + } + + return optimized; + } +} diff --git a/src/lib/migration/MigrationCompiler.js b/starfleet/data-core/src/migration/MigrationCompiler.js similarity index 94% rename from src/lib/migration/MigrationCompiler.js rename to starfleet/data-core/src/migration/MigrationCompiler.js index 3f5a3ea..95d2a00 100644 --- a/src/lib/migration/MigrationCompiler.js +++ b/starfleet/data-core/src/migration/MigrationCompiler.js @@ -1,21 +1,21 @@ /** * MigrationCompiler - Compiles Golden SQL from numbered directories - * + * * Following Supa Fleet Directive 34.1 section 3 subsection 12: * SQL directories MUST follow strict numerical naming convention * to control compilation order (extensions first, etc.) */ -const { EventEmitter } = require('events'); -const fs = require('fs').promises; -const path = require('path'); -const { glob } = require('glob'); +import { EventEmitter } from 'events'; +import { promises as fs } from 'fs'; +import path from 'path'; +import { glob } from 'glob'; /** * Expected directory structure with internal ordering: * /sql/ * extensions/ -- PostgreSQL extensions (processed first) - * schemas/ -- Schema definitions + * schemas/ -- Schema definitions * types/ -- Custom types and enums * tables/ -- Table definitions * functions/ -- Stored procedures @@ -42,7 +42,7 @@ const DIRECTORY_ORDER = [ class MigrationCompiler extends EventEmitter { constructor(config = {}) { super(); - + this.config = { sqlDir: config.sqlDir || './sql', outputDir: config.outputDir || './migrations', @@ -51,7 +51,7 @@ class MigrationCompiler extends EventEmitter { includeComments: config.includeComments !== false, timestamp: config.timestamp || new Date() }; - + // Statistics tracking this.stats = { filesProcessed: 0, @@ -60,7 +60,7 @@ class MigrationCompiler extends EventEmitter { endTime: null, directories: [] }; - + // State management this.isRunning = false; this.lastCompilation = null; @@ -73,58 +73,57 @@ class MigrationCompiler extends EventEmitter { if (this.isRunning) { throw new Error('Compilation already in progress'); } - + this.isRunning = true; this.stats.startTime = new Date(); - + this.emit('start', { timestamp: this.stats.startTime, config: this.config }); - + try { // Validate SQL directory exists await this.validateSqlDirectory(); - + // Ensure output directory exists await fs.mkdir(this.config.outputDir, { recursive: true }); - + // Generate output filename const outputFile = this.generateOutputFilename(); - + // Write header await this.writeHeader(outputFile); - + // Process directories in dependency-resolved order const directories = await this.getOrderedDirectories(); - + for (const dir of directories) { await this.processDirectory(dir, outputFile); } - + // Write footer await this.writeFooter(outputFile); - + // Complete this.stats.endTime = new Date(); const duration = this.stats.endTime - this.stats.startTime; - + const result = { success: true, outputFile, stats: this.stats, duration }; - + this.lastCompilation = result; - + this.emit('complete', { result, timestamp: this.stats.endTime }); - + return result; - } catch (error) { this.emit('error', { error, @@ -159,12 +158,10 @@ class MigrationCompiler extends EventEmitter { */ async getOrderedDirectories() { const entries = await fs.readdir(this.config.sqlDir, { withFileTypes: true }); - + // Get all directories - const availableDirs = entries - .filter(entry => entry.isDirectory()) - .map(entry => entry.name); - + const availableDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name); + // Order directories according to DIRECTORY_ORDER const orderedDirs = []; for (const dirName of DIRECTORY_ORDER) { @@ -172,9 +169,9 @@ class MigrationCompiler extends EventEmitter { orderedDirs.push(dirName); } } - + // Add any directories not in our standard list (for custom directories) - const customDirs = availableDirs.filter(dir => !DIRECTORY_ORDER.includes(dir)); + const customDirs = availableDirs.filter((dir) => !DIRECTORY_ORDER.includes(dir)); if (customDirs.length > 0) { this.emit('warning', { message: `Found non-standard directories: ${customDirs.join(', ')}. These will be processed last.`, @@ -182,7 +179,7 @@ class MigrationCompiler extends EventEmitter { }); orderedDirs.push(...customDirs.sort()); } - + if (orderedDirs.length === 0) { this.emit('warning', { message: 'No directories found. Looking for SQL files in root.', @@ -190,13 +187,13 @@ class MigrationCompiler extends EventEmitter { }); return ['']; // Process root directory } - + this.emit('progress', { message: `Processing ${orderedDirs.length} directories in order`, directories: orderedDirs, timestamp: new Date() }); - + return orderedDirs; } @@ -205,17 +202,17 @@ class MigrationCompiler extends EventEmitter { */ async processDirectory(dirName, outputFile) { const fullPath = path.join(this.config.sqlDir, dirName); - + this.emit('directory:start', { directory: dirName || 'root', path: fullPath, timestamp: new Date() }); - + // Find all SQL files in directory const pattern = path.join(fullPath, '**/*.sql'); const sqlFiles = await glob(pattern); - + if (sqlFiles.length === 0) { this.emit('directory:skip', { directory: dirName, @@ -224,10 +221,10 @@ class MigrationCompiler extends EventEmitter { }); return; } - + // Sort files for consistent ordering sqlFiles.sort(); - + // Write directory section header if (dirName) { const sectionHeader = ` @@ -239,14 +236,14 @@ class MigrationCompiler extends EventEmitter { await fs.appendFile(outputFile, sectionHeader); this.stats.linesWritten += sectionHeader.split('\n').length; } - + // Process each SQL file for (const sqlFile of sqlFiles) { await this.processFile(sqlFile, outputFile); } - + this.stats.directories.push(dirName); - + this.emit('directory:complete', { directory: dirName, filesProcessed: sqlFiles.length, @@ -259,16 +256,16 @@ class MigrationCompiler extends EventEmitter { */ async processFile(filePath, outputFile) { const relativePath = path.relative(this.config.sqlDir, filePath); - + this.emit('file:process', { file: relativePath, timestamp: new Date() }); - + try { const content = await fs.readFile(filePath, 'utf8'); const lines = content.split('\n'); - + // Write file header comment if (this.config.includeComments) { const fileHeader = `-- โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ @@ -278,23 +275,22 @@ class MigrationCompiler extends EventEmitter { await fs.appendFile(outputFile, fileHeader); this.stats.linesWritten += fileHeader.split('\n').length; } - + // Write file content await fs.appendFile(outputFile, content); if (!content.endsWith('\n')) { await fs.appendFile(outputFile, '\n'); } await fs.appendFile(outputFile, '\n'); // Extra newline between files - + this.stats.linesWritten += lines.length + 1; this.stats.filesProcessed++; - + this.emit('file:complete', { file: relativePath, lineCount: lines.length, timestamp: new Date() }); - } catch (error) { this.emit('file:error', { file: relativePath, @@ -315,7 +311,7 @@ class MigrationCompiler extends EventEmitter { .replace(/\..+/, '') .replace(/-/g, '') .slice(0, 14); - + return path.join(this.config.outputDir, `${timestamp}_compiled.sql`); } @@ -338,10 +334,10 @@ class MigrationCompiler extends EventEmitter { -- โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• `; - + await fs.writeFile(outputFile, header); this.stats.linesWritten += header.split('\n').length; - + this.emit('header:written', { outputFile, timestamp: new Date() @@ -365,10 +361,10 @@ class MigrationCompiler extends EventEmitter { -- "The compilation is complete, Captain." - Lt. Commander Data -- โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ• `; - + await fs.appendFile(outputFile, footer); this.stats.linesWritten += footer.split('\n').length; - + this.emit('footer:written', { timestamp: new Date() }); @@ -389,4 +385,4 @@ class MigrationCompiler extends EventEmitter { } } -module.exports = MigrationCompiler; \ No newline at end of file +export { MigrationCompiler }; diff --git a/starfleet/data-core/src/migration/PlanCompiler.js b/starfleet/data-core/src/migration/PlanCompiler.js new file mode 100644 index 0000000..c89b9d0 --- /dev/null +++ b/starfleet/data-core/src/migration/PlanCompiler.js @@ -0,0 +1,467 @@ +/** + * Execution plan compiler for orchestrating migration operations. + * Compiles migration operations into executable plans with dependency resolution, + * rollback strategies, and execution phases. + * + * @fileoverview Migration execution planning and compilation + */ + +import { ProcessPort, EnvironmentPort, validatePort } from '../ports/index.js'; + +/** + * Execution phases for migration operations + * @readonly + * @enum {number} + */ +export const ExecutionPhase = { + PRE_MIGRATION: 0, + SCHEMA_DROP: 1, + SCHEMA_CREATE: 2, + DATA_MIGRATION: 3, + POST_MIGRATION: 4, + VALIDATION: 5 +}; + +/** + * Represents a single execution step in a migration plan + */ +export class ExecutionStep { + /** + * @param {string} id - Unique step identifier + * @param {string} description - Human-readable step description + * @param {string[]} sql - SQL statements to execute + * @param {number} phase - Execution phase + * @param {Object} [options={}] - Step execution options + */ + constructor(id, description, sql, phase, options = {}) { + this.id = id; + this.description = description; + this.sql = Array.isArray(sql) ? sql : [sql]; + this.phase = phase; + this.options = { + canRollback: true, + timeout: 30000, + retryCount: 0, + continueOnError: false, + ...options + }; + this.dependencies = new Set(); + this.rollbackSql = []; + this.executed = false; + this.result = null; + } + + /** + * Add dependency to this step + * @param {ExecutionStep} step - Step this depends on + */ + addDependency(step) { + this.dependencies.add(step); + } + + /** + * Set rollback SQL for this step + * @param {string[]} sql - Rollback SQL statements + */ + setRollbackSql(sql) { + this.rollbackSql = Array.isArray(sql) ? sql : [sql]; + } + + /** + * Check if step is ready for execution (all dependencies completed) + * @returns {boolean} True if ready to execute + */ + isReady() { + return Array.from(this.dependencies).every((dep) => dep.executed); + } + + /** + * Get estimated execution time in milliseconds + * @returns {number} Estimated execution time + */ + getEstimatedTime() { + // Simple heuristic based on SQL statement count and complexity + const baseTime = 1000; // 1 second base + const sqlComplexity = this.sql.reduce((total, statement) => { + const keywords = (statement.match(/\b(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE)\b/gi) || []) + .length; + const tables = (statement.match(/\b(FROM|JOIN|INTO|TABLE)\s+\w+/gi) || []).length; + return total + keywords * 500 + tables * 200; + }, 0); + + return baseTime + sqlComplexity; + } +} + +/** + * Represents a complete migration execution plan + */ +export class ExecutionPlan { + /** + * @param {string} id - Unique plan identifier + * @param {string} name - Plan name/description + */ + constructor(id, name) { + this.id = id; + this.name = name; + this.steps = []; + this.phases = new Map(); + this.metadata = {}; + this.compiled = false; + } + + /** + * Add execution step to the plan + * @param {ExecutionStep} step - Step to add + */ + addStep(step) { + this.steps.push(step); + + // Group by phase + if (!this.phases.has(step.phase)) { + this.phases.set(step.phase, []); + } + this.phases.get(step.phase).push(step); + + this.compiled = false; + } + + /** + * Get steps in execution order + * @returns {ExecutionStep[]} Steps sorted by dependencies and phase + */ + getExecutionOrder() { + const sortedSteps = [...this.steps]; + + // Sort by phase first, then by dependencies + sortedSteps.sort((a, b) => { + if (a.phase !== b.phase) { + return a.phase - b.phase; + } + + // Within same phase, dependencies determine order + if (a.dependencies.has(b)) return 1; + if (b.dependencies.has(a)) return -1; + return 0; + }); + + return sortedSteps; + } + + /** + * Get total estimated execution time + * @returns {number} Total estimated time in milliseconds + */ + getTotalEstimatedTime() { + return this.steps.reduce((total, step) => total + step.getEstimatedTime(), 0); + } + + /** + * Check if plan has circular dependencies + * @returns {boolean} True if circular dependencies exist + */ + hasCircularDependencies() { + const visited = new Set(); + const visiting = new Set(); + + const visit = (step) => { + if (visiting.has(step)) return true; + if (visited.has(step)) return false; + + visiting.add(step); + for (const dep of step.dependencies) { + if (visit(dep)) return true; + } + visiting.delete(step); + visited.add(step); + return false; + }; + + return this.steps.some((step) => visit(step)); + } + + /** + * Generate rollback plan + * @returns {ExecutionPlan} Rollback execution plan + */ + generateRollbackPlan() { + const rollbackPlan = new ExecutionPlan(`${this.id}_rollback`, `Rollback: ${this.name}`); + + // Create rollback steps in reverse order + const executedSteps = this.steps.filter((step) => step.executed && step.options.canRollback); + executedSteps.reverse(); + + for (const [index, step] of executedSteps.entries()) { + if (step.rollbackSql.length > 0) { + const rollbackStep = new ExecutionStep( + `rollback_${step.id}`, + `Rollback: ${step.description}`, + step.rollbackSql, + ExecutionPhase.SCHEMA_DROP, + { canRollback: false, timeout: step.options.timeout } + ); + rollbackPlan.addStep(rollbackStep); + } + } + + return rollbackPlan; + } +} + +/** + * Migration execution plan compiler + */ +export class PlanCompiler { + /** + * @param {ProcessPort} processPort - Process adapter + * @param {EnvironmentPort} environmentPort - Environment adapter + */ + constructor(processPort, environmentPort) { + validatePort(processPort, ProcessPort); + validatePort(environmentPort, EnvironmentPort); + this.processPort = processPort; + this.environmentPort = environmentPort; + } + + /** + * Compile migration operations into execution plan + * @param {MigrationOperation[]} operations - Migration operations + * @param {Object} [options={}] - Compilation options + * @returns {ExecutionPlan} Compiled execution plan + */ + compilePlan(operations, options = {}) { + const { + planId = `plan_${Date.now()}`, + planName = 'Migration Plan', + enableRollback = true, + parallelExecution = false + } = options; + + const plan = new ExecutionPlan(planId, planName); + plan.metadata = { enableRollback, parallelExecution, createdAt: new Date().toISOString() }; + + // Group operations by phase + const phaseGroups = this._groupOperationsByPhase(operations); + + // Create execution steps for each phase + for (const [phase, phaseOps] of phaseGroups) { + this._createPhaseSteps(plan, phase, phaseOps, enableRollback); + } + + // Add validation steps + this._addValidationSteps(plan, operations); + + // Resolve dependencies + this._resolveDependencies(plan); + + plan.compiled = true; + return plan; + } + + /** + * Group operations by execution phase + * @param {MigrationOperation[]} operations - Operations to group + * @returns {Map} Operations grouped by phase + * @private + */ + _groupOperationsByPhase(operations) { + const phaseMap = new Map(); + + for (const op of operations) { + const phase = this._getOperationPhase(op); + if (!phaseMap.has(phase)) { + phaseMap.set(phase, []); + } + phaseMap.get(phase).push(op); + } + + return phaseMap; + } + + /** + * Determine execution phase for operation + * @param {MigrationOperation} operation - Operation to analyze + * @returns {number} Execution phase + * @private + */ + _getOperationPhase(operation) { + if (operation.isDestructive()) { + return ExecutionPhase.SCHEMA_DROP; + } + + if (operation.type <= 8) { + // Schema operations + return ExecutionPhase.SCHEMA_CREATE; + } + + return ExecutionPhase.DATA_MIGRATION; + } + + /** + * Create execution steps for a phase + * @param {ExecutionPlan} plan - Plan to add steps to + * @param {number} phase - Execution phase + * @param {MigrationOperation[]} operations - Phase operations + * @param {boolean} enableRollback - Whether to generate rollback SQL + * @private + */ + _createPhaseSteps(plan, phase, operations, enableRollback) { + for (const op of operations) { + const step = new ExecutionStep( + `step_${op.objectName}_${op.type}`, + `${this._getOperationDescription(op.type)} ${op.objectName}`, + [op.sql], + phase, + { + canRollback: enableRollback && !op.isDestructive(), + timeout: this._getOperationTimeout(op), + continueOnError: false + } + ); + + if (enableRollback) { + step.setRollbackSql(this._generateRollbackSql(op)); + } + + plan.addStep(step); + } + } + + /** + * Get human-readable description for operation type + * @param {number} operationType - Operation type + * @returns {string} Operation description + * @private + */ + _getOperationDescription(operationType) { + const descriptions = { + 0: 'Create table', + 1: 'Drop table', + 2: 'Alter table', + 3: 'Create index', + 4: 'Drop index', + 5: 'Create function', + 6: 'Drop function', + 7: 'Create view', + 8: 'Drop view', + 9: 'Insert data', + 10: 'Update data', + 11: 'Delete data' + }; + return descriptions[operationType] || 'Execute'; + } + + /** + * Get timeout for operation type + * @param {MigrationOperation} operation - Operation + * @returns {number} Timeout in milliseconds + * @private + */ + _getOperationTimeout(operation) { + const timeouts = { + 0: 60000, // CREATE TABLE + 1: 30000, // DROP TABLE + 2: 120000, // ALTER TABLE + 3: 30000, // CREATE INDEX + 4: 15000, // DROP INDEX + 9: 300000, // INSERT DATA + 10: 300000 // UPDATE DATA + }; + return timeouts[operation.type] || 60000; + } + + /** + * Generate rollback SQL for operation + * @param {MigrationOperation} operation - Operation + * @returns {string[]} Rollback SQL statements + * @private + */ + _generateRollbackSql(operation) { + // Simple rollback generation - in practice this would be more sophisticated + const rollbacks = { + 0: [`DROP TABLE IF EXISTS ${operation.objectName}`], // CREATE TABLE + 3: [`DROP INDEX IF EXISTS ${operation.objectName}`], // CREATE INDEX + 5: [`DROP FUNCTION IF EXISTS ${operation.objectName}`], // CREATE FUNCTION + 7: [`DROP VIEW IF EXISTS ${operation.objectName}`] // CREATE VIEW + }; + return rollbacks[operation.type] || []; + } + + /** + * Add validation steps to plan + * @param {ExecutionPlan} plan - Plan to add validation to + * @param {MigrationOperation[]} operations - Operations to validate + * @private + */ + _addValidationSteps(plan, operations) { + const validationStep = new ExecutionStep( + 'validation', + 'Validate migration results', + ['-- Validation queries would go here'], + ExecutionPhase.VALIDATION, + { canRollback: false, continueOnError: true } + ); + + plan.addStep(validationStep); + } + + /** + * Resolve step dependencies within plan + * @param {ExecutionPlan} plan - Plan to resolve dependencies for + * @private + */ + _resolveDependencies(plan) { + const stepsByPhase = plan.phases; + const phaseOrder = Array.from(stepsByPhase.keys()).sort((a, b) => a - b); + + // Add inter-phase dependencies + for (let i = 1; i < phaseOrder.length; i++) { + const currentPhaseSteps = stepsByPhase.get(phaseOrder[i]); + const previousPhaseSteps = stepsByPhase.get(phaseOrder[i - 1]); + + for (const currentStep of currentPhaseSteps) { + for (const previousStep of previousPhaseSteps) { + currentStep.addDependency(previousStep); + } + } + } + } + + /** + * Validate compiled execution plan + * @param {ExecutionPlan} plan - Plan to validate + * @returns {Object} Validation result with issues + */ + validatePlan(plan) { + const issues = []; + const warnings = []; + + if (!plan.compiled) { + issues.push('Plan has not been compiled'); + } + + if (plan.hasCircularDependencies()) { + issues.push('Plan contains circular dependencies'); + } + + if (plan.steps.length === 0) { + warnings.push('Plan contains no execution steps'); + } + + const totalTime = plan.getTotalEstimatedTime(); + if (totalTime > 3600000) { + // 1 hour + warnings.push( + `Plan has long estimated execution time: ${Math.round(totalTime / 60000)} minutes` + ); + } + + return { + valid: issues.length === 0, + issues, + warnings, + estimatedTime: totalTime, + stepCount: plan.steps.length + }; + } +} diff --git a/src/lib/migration/SchemaDiffAnalyzer.js b/starfleet/data-core/src/migration/SchemaDiffAnalyzer.js similarity index 94% rename from src/lib/migration/SchemaDiffAnalyzer.js rename to starfleet/data-core/src/migration/SchemaDiffAnalyzer.js index 4943fef..a294150 100644 --- a/src/lib/migration/SchemaDiffAnalyzer.js +++ b/starfleet/data-core/src/migration/SchemaDiffAnalyzer.js @@ -1,13 +1,13 @@ /** * Schema Diff Analyzer for D.A.T.A. - * + * * Analyzes migration operations for risk assessment, performance impact, * and provides intelligent recommendations for safer deployments. - * + * * @module SchemaDiffAnalyzer */ -const { EventEmitter } = require('events'); +import { EventEmitter } from 'events'; /** * Risk levels for migration operations @@ -16,7 +16,7 @@ const { EventEmitter } = require('events'); */ const RISK_LEVELS = { LOW: 'LOW', - MEDIUM: 'MEDIUM', + MEDIUM: 'MEDIUM', HIGH: 'HIGH', CRITICAL: 'CRITICAL' }; @@ -49,7 +49,7 @@ const PERFORMANCE_IMPACT = { class SchemaDiffAnalyzer extends EventEmitter { constructor(options = {}) { super(); - + // Risk assessment thresholds this.thresholds = { largeTable: options.largeTableRows || 1000000, // 1M rows @@ -57,18 +57,18 @@ class SchemaDiffAnalyzer extends EventEmitter { indexCreation: options.indexCreationTime || 60, // 1 minute per 100k rows ...options.thresholds }; - + // Known high-impact operations this.highRiskPatterns = [ 'DROP TABLE', - 'DROP COLUMN', + 'DROP COLUMN', 'TRUNCATE', 'DELETE FROM', 'ALTER COLUMN.*TYPE', 'DROP CONSTRAINT', 'ALTER TABLE.*ALTER COLUMN.*NOT NULL' ]; - + // Performance-impacting operations this.performancePatterns = [ 'CREATE INDEX', @@ -78,7 +78,7 @@ class SchemaDiffAnalyzer extends EventEmitter { 'ANALYZE', 'REINDEX' ]; - + // Supabase-specific patterns this.supabasePatterns = { rls: /CREATE POLICY|ALTER POLICY|DROP POLICY/i, @@ -87,7 +87,7 @@ class SchemaDiffAnalyzer extends EventEmitter { realtime: /realtime\.(subscription)/i }; } - + /** * Analyze migration operations for risks and recommendations * @param {Array} operations - Array of migration operations @@ -96,7 +96,7 @@ class SchemaDiffAnalyzer extends EventEmitter { */ async analyzeMigration(operations, context = {}) { this.emit('progress', { message: 'Analyzing migration operations...' }); - + const analysis = { riskLevel: RISK_LEVELS.LOW, performanceImpact: PERFORMANCE_IMPACT.NONE, @@ -107,55 +107,57 @@ class SchemaDiffAnalyzer extends EventEmitter { requiresDowntime: false, rollbackPlan: [] }; - + // Analyze each operation for (const operation of operations) { const opAnalysis = await this.analyzeOperation(operation, context); - + // Update overall risk level if (this.compareRiskLevels(opAnalysis.riskLevel, analysis.riskLevel) > 0) { analysis.riskLevel = opAnalysis.riskLevel; } - + // Update performance impact - if (this.comparePerformanceImpact(opAnalysis.performanceImpact, analysis.performanceImpact) > 0) { + if ( + this.comparePerformanceImpact(opAnalysis.performanceImpact, analysis.performanceImpact) > 0 + ) { analysis.performanceImpact = opAnalysis.performanceImpact; } - + // Accumulate duration analysis.estimatedDuration += opAnalysis.estimatedDuration; - + // Collect recommendations and warnings analysis.recommendations.push(...opAnalysis.recommendations); analysis.warnings.push(...opAnalysis.warnings); - + // Check if requires downtime if (opAnalysis.requiresDowntime) { analysis.requiresDowntime = true; } - + // Add to rollback plan if (opAnalysis.rollbackStep) { analysis.rollbackPlan.push(opAnalysis.rollbackStep); } } - + // Generate overall recommendations analysis.recommendations.push(...this.generateOverallRecommendations(analysis, context)); - + // Sort recommendations by priority analysis.recommendations.sort((a, b) => this.comparePriority(a.priority, b.priority)); - + this.emit('complete', { message: 'Migration analysis complete', riskLevel: analysis.riskLevel, operations: operations.length, estimatedDuration: analysis.estimatedDuration }); - + return analysis; } - + /** * Analyze a single migration operation * @param {Object} operation - Migration operation @@ -172,7 +174,7 @@ class SchemaDiffAnalyzer extends EventEmitter { requiresDowntime: false, rollbackStep: null }; - + // Risk-specific analysis if (operation.type === 'DESTRUCTIVE') { analysis.recommendations.push({ @@ -181,19 +183,19 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Create full database backup before executing destructive operation', operation: operation.description }); - + analysis.warnings.push({ type: 'DATA_LOSS', message: `${operation.description} may result in permanent data loss`, severity: 'CRITICAL' }); - + analysis.rollbackStep = { description: `Manual intervention required to reverse: ${operation.description}`, manual: true }; } - + // Column type changes if (this.matchesPattern(operation.sql, 'ALTER COLUMN.*TYPE')) { analysis.recommendations.push({ @@ -202,18 +204,18 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Verify data compatibility before changing column type', operation: operation.description }); - + analysis.warnings.push({ type: 'TYPE_CONVERSION', message: 'Column type change may fail if existing data is incompatible', severity: 'WARNING' }); } - + // Index creation if (this.matchesPattern(operation.sql, 'CREATE.*INDEX')) { const concurrent = operation.sql.includes('CONCURRENTLY'); - + if (!concurrent && context.isProd) { analysis.recommendations.push({ type: 'CONCURRENT_INDEX', @@ -221,17 +223,17 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Use CREATE INDEX CONCURRENTLY in production to avoid locks', operation: operation.description }); - + analysis.requiresDowntime = true; } - + analysis.warnings.push({ type: 'INDEX_CREATION', - message: `Index creation may take significant time on large tables`, + message: 'Index creation may take significant time on large tables', severity: 'INFO' }); } - + // NOT NULL constraints if (this.matchesPattern(operation.sql, 'ALTER COLUMN.*SET NOT NULL')) { analysis.recommendations.push({ @@ -240,14 +242,14 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Ensure no NULL values exist before adding NOT NULL constraint', operation: operation.description }); - + analysis.warnings.push({ type: 'CONSTRAINT_FAILURE', message: 'NOT NULL constraint will fail if NULL values exist', severity: 'WARNING' }); } - + // RLS Policy changes (Supabase-specific) if (this.supabasePatterns.rls.test(operation.sql)) { if (operation.sql.includes('DROP POLICY')) { @@ -257,7 +259,7 @@ class SchemaDiffAnalyzer extends EventEmitter { severity: 'HIGH' }); } - + analysis.recommendations.push({ type: 'RLS_TESTING', priority: 'MEDIUM', @@ -265,7 +267,7 @@ class SchemaDiffAnalyzer extends EventEmitter { operation: operation.description }); } - + // Function changes if (this.matchesPattern(operation.sql, 'CREATE OR REPLACE FUNCTION')) { analysis.recommendations.push({ @@ -275,10 +277,10 @@ class SchemaDiffAnalyzer extends EventEmitter { operation: operation.description }); } - + return analysis; } - + /** * Assess the risk level of an operation * @param {Object} operation - Migration operation @@ -288,28 +290,28 @@ class SchemaDiffAnalyzer extends EventEmitter { if (operation.type === 'DESTRUCTIVE') { return RISK_LEVELS.CRITICAL; } - + if (operation.type === 'WARNING') { // Check specific patterns for risk escalation if (this.matchesPattern(operation.sql, 'ALTER COLUMN.*TYPE')) { return RISK_LEVELS.HIGH; } - + if (this.matchesPattern(operation.sql, 'DROP POLICY')) { return RISK_LEVELS.HIGH; // Security risk } - + return RISK_LEVELS.MEDIUM; } - + // SAFE operations can still have some risk if (this.matchesPattern(operation.sql, 'CREATE.*INDEX')) { return RISK_LEVELS.LOW; // Performance risk but safe } - + return RISK_LEVELS.LOW; } - + /** * Assess performance impact of operation * @param {Object} operation - Migration operation @@ -324,15 +326,15 @@ class SchemaDiffAnalyzer extends EventEmitter { return PERFORMANCE_IMPACT.MEDIUM; } } - + // Lock-inducing operations if (this.matchesPattern(operation.sql, 'ALTER TABLE.*ADD COLUMN.*NOT NULL')) { return PERFORMANCE_IMPACT.MEDIUM; } - + return PERFORMANCE_IMPACT.LOW; } - + /** * Estimate operation duration in minutes * @param {Object} operation - Migration operation @@ -342,12 +344,12 @@ class SchemaDiffAnalyzer extends EventEmitter { estimateDuration(operation, context) { // Base duration let duration = 0.1; // 6 seconds minimum - + // Index creation - estimate based on table size if (this.matchesPattern(operation.sql, 'CREATE.*INDEX')) { const concurrent = operation.sql.includes('CONCURRENTLY'); duration = concurrent ? 5 : 2; // Concurrent takes longer but safer - + // If we know table size, adjust estimate if (context.tableStats) { const tableName = this.extractTableName(operation.sql); @@ -357,30 +359,30 @@ class SchemaDiffAnalyzer extends EventEmitter { } } } - + // Column type changes else if (this.matchesPattern(operation.sql, 'ALTER COLUMN.*TYPE')) { duration = 1; // Depends on table size and type conversion } - + // NOT NULL constraints require table scan else if (this.matchesPattern(operation.sql, 'ALTER COLUMN.*NOT NULL')) { duration = 0.5; // Table scan required } - + // Function/view changes are usually fast else if (this.matchesPattern(operation.sql, 'CREATE.*FUNCTION|CREATE.*VIEW')) { duration = 0.1; } - + // RLS policies are fast else if (this.supabasePatterns.rls.test(operation.sql)) { duration = 0.1; } - + return Math.round(duration * 10) / 10; // Round to 1 decimal } - + /** * Generate overall recommendations based on analysis * @param {Object} analysis - Current analysis state @@ -389,7 +391,7 @@ class SchemaDiffAnalyzer extends EventEmitter { */ generateOverallRecommendations(analysis, context) { const recommendations = []; - + // High-risk migration recommendations if (analysis.riskLevel === RISK_LEVELS.CRITICAL) { recommendations.push({ @@ -398,7 +400,7 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Consider blue-green deployment or maintenance window for critical operations' }); } - + // Performance recommendations if (analysis.performanceImpact === PERFORMANCE_IMPACT.HIGH) { recommendations.push({ @@ -407,7 +409,7 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Schedule during low-traffic period due to high performance impact' }); } - + // Long-running migration recommendations if (analysis.estimatedDuration > 30) { recommendations.push({ @@ -416,7 +418,7 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Monitor migration progress and database performance during execution' }); } - + // Production-specific recommendations if (context.isProd) { if (analysis.riskLevel !== RISK_LEVELS.LOW) { @@ -426,14 +428,14 @@ class SchemaDiffAnalyzer extends EventEmitter { message: 'Test migration on staging environment with production-like data' }); } - + recommendations.push({ type: 'ROLLBACK_PLAN', priority: 'MEDIUM', message: 'Prepare rollback plan and verify rollback procedures' }); } - + // Multiple destructive operations const destructiveCount = analysis.statistics.destructiveOperations; if (destructiveCount > 1) { @@ -443,10 +445,10 @@ class SchemaDiffAnalyzer extends EventEmitter { message: `Consider breaking ${destructiveCount} destructive operations into separate deployments` }); } - + return recommendations; } - + /** * Calculate migration statistics * @param {Array} operations - Migration operations @@ -468,13 +470,13 @@ class SchemaDiffAnalyzer extends EventEmitter { droppedFunctions: 0, rlsPolicies: 0 }; - + for (const op of operations) { // Count by risk type if (op.type === 'SAFE') stats.safeOperations++; else if (op.type === 'WARNING') stats.warningOperations++; else if (op.type === 'DESTRUCTIVE') stats.destructiveOperations++; - + // Count specific operations const sql = op.sql.toUpperCase(); if (sql.includes('CREATE TABLE')) stats.newTables++; @@ -483,47 +485,49 @@ class SchemaDiffAnalyzer extends EventEmitter { if (sql.includes('DROP COLUMN')) stats.droppedColumns++; if (sql.includes('CREATE INDEX') || sql.includes('CREATE UNIQUE INDEX')) stats.newIndexes++; if (sql.includes('DROP INDEX')) stats.droppedIndexes++; - if (sql.includes('CREATE FUNCTION') || sql.includes('CREATE OR REPLACE FUNCTION')) stats.newFunctions++; + if (sql.includes('CREATE FUNCTION') || sql.includes('CREATE OR REPLACE FUNCTION')) + stats.newFunctions++; if (sql.includes('DROP FUNCTION')) stats.droppedFunctions++; if (sql.includes('CREATE POLICY') || sql.includes('DROP POLICY')) stats.rlsPolicies++; } - + return stats; } - + /** * Helper methods */ - + matchesPattern(sql, pattern) { const regex = new RegExp(pattern, 'i'); return regex.test(sql); } - + extractTableName(sql) { // Simple table name extraction - could be more sophisticated const match = sql.match(/(?:CREATE INDEX.*ON|ALTER TABLE|DROP TABLE)\s+([^\s(]+)/i); return match ? match[1] : null; } - + compareRiskLevels(level1, level2) { const levels = [RISK_LEVELS.LOW, RISK_LEVELS.MEDIUM, RISK_LEVELS.HIGH, RISK_LEVELS.CRITICAL]; return levels.indexOf(level1) - levels.indexOf(level2); } - + comparePerformanceImpact(impact1, impact2) { - const impacts = [PERFORMANCE_IMPACT.NONE, PERFORMANCE_IMPACT.LOW, PERFORMANCE_IMPACT.MEDIUM, PERFORMANCE_IMPACT.HIGH]; + const impacts = [ + PERFORMANCE_IMPACT.NONE, + PERFORMANCE_IMPACT.LOW, + PERFORMANCE_IMPACT.MEDIUM, + PERFORMANCE_IMPACT.HIGH + ]; return impacts.indexOf(impact1) - impacts.indexOf(impact2); } - + comparePriority(priority1, priority2) { const priorities = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']; return priorities.indexOf(priority2) - priorities.indexOf(priority1); // Reverse order (highest first) } } -module.exports = { - SchemaDiffAnalyzer, - RISK_LEVELS, - PERFORMANCE_IMPACT -}; \ No newline at end of file +export { SchemaDiffAnalyzer, RISK_LEVELS, PERFORMANCE_IMPACT }; diff --git a/starfleet/data-core/src/migration/SqlGraph.js b/starfleet/data-core/src/migration/SqlGraph.js new file mode 100644 index 0000000..8b2ea06 --- /dev/null +++ b/starfleet/data-core/src/migration/SqlGraph.js @@ -0,0 +1,255 @@ +/** + * SQL dependency graph builder for analyzing relationships between SQL files. + * Builds a directed graph of dependencies by parsing SQL statements for references + * to tables, views, functions, and other database objects. + * + * @fileoverview SQL dependency analysis and topological sorting + */ + +import { FileSystemPort, validatePort } from '../ports/index.js'; + +/** + * Represents a node in the SQL dependency graph + */ +/** + * SqlNode class + * @class + */ +export class SqlNode { + /** + * @param {string} name - Name of the SQL object (table, view, function, etc.) + * @param {string} type - Type of object (table, view, function, trigger, etc.) + * @param {string} filePath - Path to the SQL file containing this object + * @param {string} content - SQL content for this object + */ + constructor(name, type, filePath, content) { + this.name = name; + this.type = type; + this.filePath = filePath; + this.content = content; + this.dependencies = new Set(); + this.dependents = new Set(); + } + + /** + * Add a dependency to this node + * @param {SqlNode} node - Node this depends on + */ + addDependency(node) { + this.dependencies.add(node); + node.dependents.add(this); + } + + /** + * Remove a dependency from this node + * @param {SqlNode} node - Node to remove dependency on + */ + removeDependency(node) { + this.dependencies.delete(node); + node.dependents.delete(this); + } + + /** + * Check if this node has circular dependencies + * @param {Set} visited - Already visited nodes + * @returns {boolean} True if circular dependency detected + */ + hasCircularDependency(visited = new Set()) { + if (visited.has(this)) { + return true; + } + + visited.add(this); + for (const dep of this.dependencies) { + if (dep.hasCircularDependency(visited)) { + return true; + } + } + visited.delete(this); + return false; + } +} + +/** + * SQL dependency graph builder and analyzer + */ +/** + * SqlGraph class + * @class + */ +export class SqlGraph { + /** + * @param {FileSystemPort} fileSystemPort - File system adapter + */ + constructor(fileSystemPort) { + validatePort(fileSystemPort, FileSystemPort); + this.fileSystemPort = fileSystemPort; + this.nodes = new Map(); + this.sqlPatterns = { + // Pattern to match CREATE statements + create: + /CREATE\s+(?:OR\s+REPLACE\s+)?(?:TEMP|TEMPORARY\s+)?(?:TABLE|VIEW|FUNCTION|PROCEDURE|TRIGGER|INDEX)\s+(?:IF\s+NOT\s+EXISTS\s+)?([.\w]+)/gi, + // Pattern to match references (FROM, JOIN, REFERENCES, etc.) + reference: /(?:FROM|JOIN|REFERENCES|USING)\s+([.\w]+)/gi, + // Pattern to match function calls + functionCall: /([.\w]+)\s*\(/gi + }; + } + + /** + * Build dependency graph from SQL files + * @param {string[]} sqlFiles - Array of SQL file paths + * @returns {Promise} + */ + async buildGraph(sqlFiles) { + // Clear existing graph + this.nodes.clear(); + + // First pass: identify all SQL objects + for (const filePath of sqlFiles) { + await this._parseFile(filePath); + } + + // Second pass: build dependencies + for (const node of this.nodes.values()) { + this._analyzeDependencies(node); + } + } + + /** + * Parse a SQL file and extract objects + * @param {string} filePath - Path to SQL file + * @private + */ + async _parseFile(filePath) { + const content = await this.fileSystemPort.readFile(filePath); + const createMatches = [...content.matchAll(this.sqlPatterns.create)]; + + for (const match of createMatches) { + const objectName = match[1].toLowerCase(); + const objectType = match[0] + .match(/(?:TABLE|VIEW|FUNCTION|PROCEDURE|TRIGGER|INDEX)/i)[0] + .toLowerCase(); + + const node = new SqlNode(objectName, objectType, filePath, content); + this.nodes.set(objectName, node); + } + + // If no CREATE statements found, treat as migration script + if (createMatches.length === 0) { + const scriptName = filePath + .split('/') + .pop() + .replace(/\.sql$/, ''); + const node = new SqlNode(scriptName, 'script', filePath, content); + this.nodes.set(scriptName, node); + } + } + + /** + * Analyze dependencies for a SQL node + * @param {SqlNode} node - Node to analyze + * @private + */ + _analyzeDependencies(node) { + const content = node.content.toLowerCase(); + + // Find table/view references + const references = [...content.matchAll(this.sqlPatterns.reference)]; + for (const match of references) { + const referencedName = match[1].toLowerCase(); + const referencedNode = this.nodes.get(referencedName); + if (referencedNode && referencedNode !== node) { + node.addDependency(referencedNode); + } + } + + // Find function calls + const functionCalls = [...content.matchAll(this.sqlPatterns.functionCall)]; + for (const match of functionCalls) { + const functionName = match[1].toLowerCase(); + const functionNode = this.nodes.get(functionName); + if (functionNode && functionNode.type === 'function' && functionNode !== node) { + node.addDependency(functionNode); + } + } + } + + /** + * Get topologically sorted execution order + * @returns {SqlNode[]} Nodes in dependency order (dependencies first) + * @throws {Error} If circular dependencies detected + */ + getExecutionOrder() { + const result = []; + const visited = new Set(); + const visiting = new Set(); + + const visit = (node) => { + if (visiting.has(node)) { + throw new Error(`Circular dependency detected involving: ${node.name}`); + } + + if (visited.has(node)) { + return; + } + + visiting.add(node); + + // Visit dependencies first + for (const dep of node.dependencies) { + visit(dep); + } + + visiting.delete(node); + visited.add(node); + result.push(node); + }; + + // Visit all nodes + for (const node of this.nodes.values()) { + if (!visited.has(node)) { + visit(node); + } + } + + return result; + } + + /** + * Find nodes with no dependencies (entry points) + * @returns {SqlNode[]} Independent nodes + */ + getIndependentNodes() { + return Array.from(this.nodes.values()).filter((node) => node.dependencies.size === 0); + } + + /** + * Find nodes with no dependents (terminal nodes) + * @returns {SqlNode[]} Terminal nodes + */ + getTerminalNodes() { + return Array.from(this.nodes.values()).filter((node) => node.dependents.size === 0); + } + + /** + * Get all nodes in the graph + * @returns {SqlNode[]} All nodes + */ + getAllNodes() { + return Array.from(this.nodes.values()); + } + + /** + * Check if graph has circular dependencies + * @returns {boolean} True if circular dependencies exist + */ + hasCircularDependencies() { + for (const node of this.nodes.values()) { + if (node.hasCircularDependency()) { + return true; + } + } + return false; + } +} diff --git a/starfleet/data-core/src/ports/ClockPort.js b/starfleet/data-core/src/ports/ClockPort.js new file mode 100644 index 0000000..fc1f09f --- /dev/null +++ b/starfleet/data-core/src/ports/ClockPort.js @@ -0,0 +1,9 @@ +/** + * ClockPort - Interface for time operations + * Pure interface definition - no implementation + * @typedef {Object} ClockPort + * @property {() => Date} now - Get current date/time + * @property {() => number} nowMs - Get Unix timestamp in milliseconds + */ + +export {}; diff --git a/starfleet/data-core/src/ports/CryptoPort.js b/starfleet/data-core/src/ports/CryptoPort.js new file mode 100644 index 0000000..4eb1c9a --- /dev/null +++ b/starfleet/data-core/src/ports/CryptoPort.js @@ -0,0 +1,12 @@ +/** + * CryptoPort - Interface for cryptographic operations + * Pure interface definition - no implementation + * + * @typedef {Object} CryptoPort + * @property {(data: string, algorithm?: string) => string} hash - Generate hash of data + * @property {() => string} randomUUID - Generate random UUID + * @property {(length: number) => string} randomBytes - Generate random bytes as hex string + * @property {(a: string, b: string) => boolean} timingSafeEqual - Timing-safe string comparison + */ + +export {}; diff --git a/starfleet/data-core/src/ports/DbPort.js b/starfleet/data-core/src/ports/DbPort.js new file mode 100644 index 0000000..f84dbd3 --- /dev/null +++ b/starfleet/data-core/src/ports/DbPort.js @@ -0,0 +1,18 @@ +/** + * DbPort - Interface for database operations + * Pure interface definition - no implementation + * + * @typedef {Object} PgTapResult + * @property {number} passed - Number of passed tests + * @property {number} failed - Number of failed tests + * @property {number} total - Total number of tests + * @property {string[]} failures - Failed test descriptions + * + * @typedef {Object} DbPort + * @property {(sqlText: string) => Promise} apply - Apply SQL migration + * @property {(sqlText: string, params?: any[]) => Promise} query - Execute query with params + * @property {(paths: string[]) => Promise} runPgTap - Run pgTAP tests + * @property {(fn: (tx: {apply: (sql: string) => Promise, query: (sql: string, p?: any[]) => Promise}) => Promise) => Promise} withTransaction - Run function in transaction + */ + +export {}; diff --git a/starfleet/data-core/src/ports/EnvironmentPort.js b/starfleet/data-core/src/ports/EnvironmentPort.js new file mode 100644 index 0000000..8dd6f45 --- /dev/null +++ b/starfleet/data-core/src/ports/EnvironmentPort.js @@ -0,0 +1,9 @@ +/** + * EnvironmentPort - Interface for environment variables + * Pure interface definition - no implementation + * @typedef {Object} EnvironmentPort + * @property {(key: string) => string | undefined} get - Get environment variable + * @property {(key: string) => boolean} has - Check if environment variable exists + */ + +export {}; diff --git a/starfleet/data-core/src/ports/EventBusPort.js b/starfleet/data-core/src/ports/EventBusPort.js new file mode 100644 index 0000000..af29cd2 --- /dev/null +++ b/starfleet/data-core/src/ports/EventBusPort.js @@ -0,0 +1,11 @@ +/** + * EventBusPort - Interface for event publishing/subscribing + * Pure interface definition - no implementation + * @typedef {Object} EventBusPort + * @property {(type: string, handler: (payload: any) => void) => () => void} on - Subscribe to event, returns unsubscribe function + * @property {(type: string, handler: (payload: any) => void) => void} off - Unsubscribe from event + * @property {(type: string, payload: any) => void} emit - Emit event + * @property {(type: string, handler: (payload: any) => void) => void} once - Subscribe to event once + */ + +export {}; diff --git a/starfleet/data-core/src/ports/FileSystemPort.js b/starfleet/data-core/src/ports/FileSystemPort.js new file mode 100644 index 0000000..5047e36 --- /dev/null +++ b/starfleet/data-core/src/ports/FileSystemPort.js @@ -0,0 +1,14 @@ +/** + * FileSystemPort - Interface for file system operations + * Pure interface definition - no implementation + * @typedef {Object} FileSystemPort + * @property {(path: string) => Promise} readFile - Read file contents as UTF-8 + * @property {(path: string, data: string) => Promise} writeFile - Write string to file + * @property {(path: string) => Promise} exists - Check if file/directory exists + * @property {(path: string) => Promise} mkdirp - Create directory recursively + * @property {(path: string, opts?: {recursive?: boolean, force?: boolean}) => Promise} rm - Remove file or directory + * @property {(path: string) => Promise} readdir - List directory contents + * @property {(path: string) => Promise<{isFile: () => boolean, isDirectory: () => boolean, size: number}>} stat - Get file stats + */ + +export {}; diff --git a/starfleet/data-core/src/ports/GitPort.js b/starfleet/data-core/src/ports/GitPort.js new file mode 100644 index 0000000..e89aa11 --- /dev/null +++ b/starfleet/data-core/src/ports/GitPort.js @@ -0,0 +1,19 @@ +/** + * GitPort - Interface for git operations + * Pure interface definition - no implementation + * @typedef {Object} GitStatus + * @property {boolean} clean - Is working tree clean + * @property {string} branch - Current branch name + * @property {number} behind - Commits behind remote + * @property {number} ahead - Commits ahead of remote + * @property {string[]} modified - Modified files + * @property {string[]} untracked - Untracked files + * + * @typedef {Object} GitPort + * @property {() => Promise} status - Get repository status + * @property {(name: string, message?: string) => Promise} tag - Create annotated tag + * @property {(prefix: string) => Promise} latestTag - Get latest tag with prefix + * @property {(ref: string) => Promise} revParse - Resolve reference to commit SHA + */ + +export {}; diff --git a/starfleet/data-core/src/ports/GlobPort.js b/starfleet/data-core/src/ports/GlobPort.js new file mode 100644 index 0000000..b9cea8e --- /dev/null +++ b/starfleet/data-core/src/ports/GlobPort.js @@ -0,0 +1,8 @@ +/** + * GlobPort - Interface for file pattern matching + * Pure interface definition - no implementation + * @typedef {Object} GlobPort + * @property {(patterns: string[], opts?: {cwd?: string, ignore?: string[], dot?: boolean}) => Promise} find - Find files matching patterns + */ + +export {}; diff --git a/starfleet/data-core/src/ports/LoggerPort.js b/starfleet/data-core/src/ports/LoggerPort.js new file mode 100644 index 0000000..82d3b98 --- /dev/null +++ b/starfleet/data-core/src/ports/LoggerPort.js @@ -0,0 +1,12 @@ +/** + * LoggerPort - Interface for structured logging + * Pure interface definition - no implementation + * @typedef {Object} LoggerPort + * @property {(obj?: any, msg?: string) => void} info - Log info level + * @property {(obj?: any, msg?: string) => void} warn - Log warning level + * @property {(obj?: any, msg?: string) => void} error - Log error level + * @property {(obj?: any, msg?: string) => void} debug - Log debug level + * @property {(bindings: Record) => LoggerPort} child - Create child logger with bindings + */ + +export {}; diff --git a/starfleet/data-core/src/ports/ProcessPort.js b/starfleet/data-core/src/ports/ProcessPort.js new file mode 100644 index 0000000..49d5147 --- /dev/null +++ b/starfleet/data-core/src/ports/ProcessPort.js @@ -0,0 +1,26 @@ +/** + * ProcessPort - Interface for process/child process operations + * Pure interface definition - no implementation + * + * @typedef {Object} SpawnOptions + * @property {string} [cwd] - Working directory + * @property {Record} [env] - Environment variables + * @property {boolean} [shell] - Use shell + * @property {number} [timeout] - Timeout in milliseconds + * + * @typedef {Object} SpawnResult + * @property {string} stdout - Standard output + * @property {string} stderr - Standard error + * @property {number} code - Exit code + * @property {string | null} signal - Termination signal + * + * @typedef {Object} ProcessPort + * @property {(command: string, args?: string[], options?: SpawnOptions) => Promise} spawn - Spawn child process + * @property {(command: string, options?: SpawnOptions) => Promise} exec - Execute command in shell + * @property {(code?: number) => void} exit - Exit current process + * @property {() => string} cwd - Get current working directory + * @property {(dir: string) => void} chdir - Change working directory + * @property {(command: string) => Promise} which - Find command in PATH + */ + +export {}; diff --git a/starfleet/data-core/src/ports/ensurePort.js b/starfleet/data-core/src/ports/ensurePort.js new file mode 100644 index 0000000..6ea20fd --- /dev/null +++ b/starfleet/data-core/src/ports/ensurePort.js @@ -0,0 +1,18 @@ +/** + * Runtime port validation - catches missing method bugs instantly + * Use in composition root to fail fast during container setup + * + * @param {string} name - Port name for error messages + * @param {any} obj - Object that should implement the port + * @param {string[]} methods - Required method names + * @returns {any} - The validated port object + * @throws {Error} - If any required method is missing + */ +export function ensurePort(name, obj, methods) { + for (const m of methods) { + if (typeof obj?.[m] !== 'function') { + throw new Error(`Port ${name} missing method: ${m}`); + } + } + return obj; +} diff --git a/starfleet/data-core/src/ports/index.js b/starfleet/data-core/src/ports/index.js new file mode 100644 index 0000000..f9a8435 --- /dev/null +++ b/starfleet/data-core/src/ports/index.js @@ -0,0 +1,16 @@ +/** + * Ports index - Re-export all port interfaces + * These are pure interface definitions with no implementation + */ + +export * from './FileSystemPort.js'; +export * from './GlobPort.js'; +export * from './ClockPort.js'; +export * from './EnvironmentPort.js'; +export * from './LoggerPort.js'; +export * from './EventBusPort.js'; +export * from './GitPort.js'; +export * from './DbPort.js'; +export * from './ProcessPort.js'; +export * from './CryptoPort.js'; +export { ensurePort } from './ensurePort.js'; diff --git a/starfleet/data-core/src/schemas/DataConfigSchema.js b/starfleet/data-core/src/schemas/DataConfigSchema.js new file mode 100644 index 0000000..e6aa20a --- /dev/null +++ b/starfleet/data-core/src/schemas/DataConfigSchema.js @@ -0,0 +1,191 @@ +import { z } from 'zod'; + +/** + * Zod schema for data configuration validation + * Matches the JSON Schema in datarc.schema.json + */ + +// Test configuration schema +const TestConfigSchema = z + .object({ + minimum_coverage: z.number().min(0).max(100).default(80).optional(), + test_timeout: z.number().min(1).default(300).optional(), + output_formats: z + .array(z.enum(['console', 'junit', 'json', 'tap', 'html'])) + .default(['console']) + .optional(), + parallel: z.boolean().default(false).optional(), + verbose: z.boolean().default(false).optional() + }) + .strict() + .optional(); + +// Environment configuration schema +const EnvironmentSchema = z + .object({ + db: z + .string() + .url() + .regex(/^postgresql:\/\/.*/, 'Must be a PostgreSQL URL'), + supabase_url: z.string().url().optional(), + supabase_anon_key: z.string().optional(), + supabase_service_role_key: z.string().optional() + }) + .strict(); + +// Paths configuration schema +const PathsConfigSchema = z + .object({ + sql_dir: z.string().default('./sql').optional(), + tests_dir: z.string().default('./tests').optional(), + migrations_dir: z.string().default('./migrations').optional(), + functions_dir: z.string().default('./functions').optional(), + schemas_dir: z.string().default('./schemas').optional() + }) + .strict() + .optional(); + +// Compile configuration schema +const CompileConfigSchema = z + .object({ + auto_squash: z.boolean().default(false).optional(), + include_comments: z.boolean().default(true).optional(), + validate_syntax: z.boolean().default(true).optional() + }) + .strict() + .optional(); + +// Migration configuration schema +const MigrateConfigSchema = z + .object({ + auto_rollback: z.boolean().default(true).optional(), + dry_run: z.boolean().default(false).optional(), + lock_timeout: z.number().min(1).default(10).optional(), + batch_size: z.number().min(1).default(10).optional() + }) + .strict() + .optional(); + +// Functions configuration schema +const FunctionsConfigSchema = z + .object({ + deploy_on_migrate: z.boolean().default(false).optional(), + import_map: z.string().default('./import_map.json').optional(), + verify_jwt: z.boolean().default(true).optional() + }) + .strict() + .optional(); + +// Safety configuration schema +const SafetyConfigSchema = z + .object({ + require_prod_flag: z.boolean().default(true).optional(), + require_confirmation: z.boolean().default(true).optional(), + backup_before_migrate: z.boolean().default(true).optional(), + max_affected_rows: z.number().min(0).default(10000).optional() + }) + .strict() + .optional(); + +// Logging configuration schema +const LoggingConfigSchema = z + .object({ + level: z.enum(['debug', 'info', 'warn', 'error', 'silent']).default('info').optional(), + format: z.enum(['text', 'json']).default('text').optional(), + timestamps: z.boolean().default(true).optional() + }) + .strict() + .optional(); + +// Main data configuration schema +const DataConfigSchema = z + .object({ + $schema: z.string().optional(), // Allow but don't require the schema reference + test: TestConfigSchema, + environments: z + .record( + z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/, 'Environment name must start with a letter'), + EnvironmentSchema + ) + .optional(), + paths: PathsConfigSchema, + compile: CompileConfigSchema, + migrate: MigrateConfigSchema, + functions: FunctionsConfigSchema, + safety: SafetyConfigSchema, + logging: LoggingConfigSchema + }) + .strict(); + +/** + * Parse and validate data configuration + * @param {unknown} config - Raw configuration object + * @returns {z.infer} Validated configuration + * @throws {z.ZodError} If validation fails + */ +function parsedataConfig(config) { + return dataConfigSchema.parse(config); +} + +/** + * Safely parse data configuration (doesn't throw) + * @param {unknown} config - Raw configuration object + * @returns {{success: boolean, data?: z.infer, error?: z.ZodError}} + */ +function safeParsedataConfig(config) { + return dataConfigSchema.safeParse(config); +} + +/** + * Get default configuration + * @returns {z.infer} + */ +function getDefaultConfig() { + return dataConfigSchema.parse({}); +} + +/** + * Merge configurations with validation + * @param {unknown} baseConfig - Base configuration + * @param {unknown} overrides - Configuration overrides + * @returns {z.infer} Merged and validated configuration + */ +function mergeConfigs(baseConfig, overrides) { + // Parse both configs to ensure they're valid + const base = dataConfigSchema.parse(baseConfig || {}); + const over = dataConfigSchema.parse(overrides || {}); + + // Deep merge the configurations + const merged = { + ...base, + ...over, + test: { ...base.test, ...over.test }, + environments: { ...base.environments, ...over.environments }, + paths: { ...base.paths, ...over.paths }, + compile: { ...base.compile, ...over.compile }, + migrate: { ...base.migrate, ...over.migrate }, + functions: { ...base.functions, ...over.functions }, + safety: { ...base.safety, ...over.safety }, + logging: { ...base.logging, ...over.logging } + }; + + // Validate the merged result + return dataConfigSchema.parse(merged); +} + +export { + DataConfigSchema, + parsedataConfig, + safeParsedataConfig, + getDefaultConfig, + mergeConfigs, + // Export individual schemas for targeted validation + TestConfigSchema, + EnvironmentSchema, + PathsConfigSchema, + CompileConfigSchema, + MigrateConfigSchema, + FunctionsConfigSchema, + SafetyConfigSchema, + LoggingConfigSchema +}; diff --git a/src/lib/test/CoverageAnalyzer.js b/starfleet/data-core/src/test/CoverageAnalyzer.js similarity index 64% rename from src/lib/test/CoverageAnalyzer.js rename to starfleet/data-core/src/test/CoverageAnalyzer.js index 93761a4..ea0dbcf 100644 --- a/src/lib/test/CoverageAnalyzer.js +++ b/starfleet/data-core/src/test/CoverageAnalyzer.js @@ -1,16 +1,16 @@ -const chalk = require('chalk'); +import chalk from 'chalk'; /** * Test Coverage Analyzer - * + * * Processes test coverage data from database queries and formats results * with color coding and statistics. */ class CoverageAnalyzer { constructor() { this.coverageThresholds = { - good: 80, // Green: >80% coverage - medium: 50 // Yellow: 50-80%, Red: <50% + good: 80, // Green: >80% coverage + medium: 50 // Yellow: 50-80%, Red: <50% }; } @@ -30,8 +30,8 @@ class CoverageAnalyzer { }; } - const tested = rpcResults.filter(item => item.has_test); - const untested = rpcResults.filter(item => !item.has_test); + const tested = rpcResults.filter((item) => item.has_test); + const untested = rpcResults.filter((item) => !item.has_test); const percentage = Math.round((tested.length / rpcResults.length) * 100); // Group by schema @@ -70,8 +70,8 @@ class CoverageAnalyzer { }; } - const tested = policyResults.filter(item => item.has_test); - const untested = policyResults.filter(item => !item.has_test); + const tested = policyResults.filter((item) => item.has_test); + const untested = policyResults.filter((item) => !item.has_test); const percentage = Math.round((tested.length / policyResults.length) * 100); // Group by table @@ -109,7 +109,7 @@ class CoverageAnalyzer { } const summary = {}; - summaryResults.forEach(item => { + summaryResults.forEach((item) => { if (item.coverage_type === 'RPC Functions') { summary.rpc = { total: item.total_count, @@ -148,14 +148,14 @@ class CoverageAnalyzer { colorizeByPercentage(text, percentage) { const colorClass = this.getColorClass(percentage); switch (colorClass) { - case 'good': - return chalk.green(text); - case 'medium': - return chalk.yellow(text); - case 'poor': - return chalk.red(text); - default: - return text; + case 'good': + return chalk.green(text); + case 'medium': + return chalk.yellow(text); + case 'poor': + return chalk.red(text); + default: + return text; } } @@ -175,17 +175,17 @@ class CoverageAnalyzer { // Overall Summary if (summary && (summary.rpc || summary.policies)) { output.push(chalk.bold('๐Ÿ“Š Overall Coverage Summary:')); - + if (summary.rpc) { const rpcText = `RPC Functions: ${summary.rpc.percentage}% (${summary.rpc.tested}/${summary.rpc.total})`; output.push(` ${this.colorizeByPercentage(rpcText, summary.rpc.percentage)}`); } - + if (summary.policies) { const policyText = `RLS Policies: ${summary.policies.percentage}% (${summary.policies.tested}/${summary.policies.total})`; output.push(` ${this.colorizeByPercentage(policyText, summary.policies.percentage)}`); } - + output.push(''); } @@ -195,26 +195,28 @@ class CoverageAnalyzer { output.push(chalk.bold(this.colorizeByPercentage(rpcTitle, rpcAnalysis.percentage))); // Group by schema - Object.keys(rpcAnalysis.bySchema).sort().forEach(schema => { - output.push(chalk.cyan(`\n ${schema} schema:`)); - - rpcAnalysis.bySchema[schema].forEach(func => { - const status = func.has_test ? 'โœ“' : 'โœ—'; - const color = func.has_test ? chalk.green : chalk.red; - const testInfo = func.has_test ? - `(${func.test_count} test${func.test_count !== 1 ? 's' : ''})` : - '(0 tests)'; - - output.push(` ${color(status)} ${func.function_name} ${chalk.gray(testInfo)}`); - - // Show test function names if available - if (func.has_test && func.test_function_names && func.test_function_names.length > 0) { - func.test_function_names.forEach(testName => { - output.push(` ${chalk.gray('โ†ณ')} ${chalk.gray(testName)}`); - }); - } + Object.keys(rpcAnalysis.bySchema) + .sort() + .forEach((schema) => { + output.push(chalk.cyan(`\n ${schema} schema:`)); + + rpcAnalysis.bySchema[schema].forEach((func) => { + const status = func.has_test ? 'โœ“' : 'โœ—'; + const color = func.has_test ? chalk.green : chalk.red; + const testInfo = func.has_test + ? `(${func.test_count} test${func.test_count !== 1 ? 's' : ''})` + : '(0 tests)'; + + output.push(` ${color(status)} ${func.function_name} ${chalk.gray(testInfo)}`); + + // Show test function names if available + if (func.has_test && func.test_function_names && func.test_function_names.length > 0) { + func.test_function_names.forEach((testName) => { + output.push(` ${chalk.gray('โ†ณ')} ${chalk.gray(testName)}`); + }); + } + }); }); - }); } // RLS Policy Details @@ -224,57 +226,73 @@ class CoverageAnalyzer { output.push(chalk.bold(this.colorizeByPercentage(policyTitle, policyAnalysis.percentage))); // Group by table - Object.keys(policyAnalysis.byTable).sort().forEach(table => { - output.push(chalk.cyan(`\n ${table}:`)); - - policyAnalysis.byTable[table].forEach(policy => { - const status = policy.has_test ? 'โœ“' : 'โœ—'; - const color = policy.has_test ? chalk.green : chalk.red; - const testInfo = policy.has_test && policy.test_evidence ? - `(${policy.test_evidence.length} test${policy.test_evidence.length !== 1 ? 's' : ''})` : - '(0 tests)'; - - output.push(` ${color(status)} ${policy.policy_name} [${policy.policy_type}] ${chalk.gray(testInfo)}`); - - // Show test evidence if available - if (policy.has_test && policy.test_evidence && policy.test_evidence.length > 0) { - policy.test_evidence.forEach(testName => { - output.push(` ${chalk.gray('โ†ณ')} ${chalk.gray(testName)}`); - }); - } + Object.keys(policyAnalysis.byTable) + .sort() + .forEach((table) => { + output.push(chalk.cyan(`\n ${table}:`)); + + policyAnalysis.byTable[table].forEach((policy) => { + const status = policy.has_test ? 'โœ“' : 'โœ—'; + const color = policy.has_test ? chalk.green : chalk.red; + const testInfo = + policy.has_test && policy.test_evidence + ? `(${policy.test_evidence.length} test${policy.test_evidence.length !== 1 ? 's' : ''})` + : '(0 tests)'; + + output.push( + ` ${color(status)} ${policy.policy_name} [${policy.policy_type}] ${chalk.gray(testInfo)}` + ); + + // Show test evidence if available + if (policy.has_test && policy.test_evidence && policy.test_evidence.length > 0) { + policy.test_evidence.forEach((testName) => { + output.push(` ${chalk.gray('โ†ณ')} ${chalk.gray(testName)}`); + }); + } + }); }); - }); } // Untested Items Summary const allUntested = []; if (rpcAnalysis && rpcAnalysis.untested.length > 0) { - allUntested.push(...rpcAnalysis.untested.map(item => ({ - type: 'RPC Function', - name: `${item.schema_name}.${item.function_name}`, - schema: item.schema_name - }))); + allUntested.push( + ...rpcAnalysis.untested.map((item) => ({ + type: 'RPC Function', + name: `${item.schema_name}.${item.function_name}`, + schema: item.schema_name + })) + ); } if (policyAnalysis && policyAnalysis.untested.length > 0) { - allUntested.push(...policyAnalysis.untested.map(item => ({ - type: 'RLS Policy', - name: `${item.schema_name}.${item.table_name}.${item.policy_name}`, - schema: item.schema_name - }))); + allUntested.push( + ...policyAnalysis.untested.map((item) => ({ + type: 'RLS Policy', + name: `${item.schema_name}.${item.table_name}.${item.policy_name}`, + schema: item.schema_name + })) + ); } if (allUntested.length > 0) { output.push('\n' + chalk.bold.red('๐Ÿšจ Untested Items:')); - allUntested.forEach(item => { + allUntested.forEach((item) => { output.push(` ${chalk.red('โ€ข')} ${chalk.gray(`[${item.type}]`)} ${item.name}`); }); } // No coverage found message - if ((!rpcAnalysis || rpcAnalysis.total === 0) && (!policyAnalysis || policyAnalysis.total === 0)) { - output.push(chalk.yellow('โš ๏ธ No RPC functions or RLS policies found for coverage analysis.')); + if ( + (!rpcAnalysis || rpcAnalysis.total === 0) && + (!policyAnalysis || policyAnalysis.total === 0) + ) { + output.push( + chalk.yellow('โš ๏ธ No RPC functions or RLS policies found for coverage analysis.') + ); output.push(chalk.gray(' This could mean:')); - output.push(chalk.gray(' โ€ข No functions/policies exist in public, private, or security schemas')); + output.push( + chalk.gray(' โ€ข No functions/policies exist in public, private, or security schemas') + ); output.push(chalk.gray(' โ€ข Database connection issues')); output.push(chalk.gray(' โ€ข Test schema is not properly configured')); } @@ -301,20 +319,24 @@ class CoverageAnalyzer { percentage: overallPercentage, colorClass: this.getColorClass(overallPercentage) }, - rpc: rpcAnalysis ? { - total: rpcAnalysis.total, - tested: rpcAnalysis.tested, - percentage: rpcAnalysis.percentage, - colorClass: rpcAnalysis.colorClass - } : null, - policies: policyAnalysis ? { - total: policyAnalysis.total, - tested: policyAnalysis.tested, - percentage: policyAnalysis.percentage, - colorClass: policyAnalysis.colorClass - } : null + rpc: rpcAnalysis + ? { + total: rpcAnalysis.total, + tested: rpcAnalysis.tested, + percentage: rpcAnalysis.percentage, + colorClass: rpcAnalysis.colorClass + } + : null, + policies: policyAnalysis + ? { + total: policyAnalysis.total, + tested: policyAnalysis.tested, + percentage: policyAnalysis.percentage, + colorClass: policyAnalysis.colorClass + } + : null }; } } -module.exports = CoverageAnalyzer; \ No newline at end of file +export default CoverageAnalyzer; diff --git a/src/lib/test/ResultParser.js b/starfleet/data-core/src/test/ResultParser.js similarity index 88% rename from src/lib/test/ResultParser.js rename to starfleet/data-core/src/test/ResultParser.js index 2c4293a..94dc440 100644 --- a/src/lib/test/ResultParser.js +++ b/starfleet/data-core/src/test/ResultParser.js @@ -30,10 +30,10 @@ class ResultParser { } const lines = tapOutput.split('\n'); - + for (let i = 0; i < lines.length; i++) { const line = lines[i].trim(); - + if (line.startsWith('1..')) { this._parsePlan(line); } else if (line.startsWith('ok ') || line.startsWith('not ok ')) { @@ -45,7 +45,7 @@ class ResultParser { // Calculate totals this.results.total = this.results.passed + this.results.failed + this.results.skipped; - + return this.results; } @@ -67,11 +67,11 @@ class ResultParser { _parseTest(line) { const okMatch = line.match(/^ok (\d+)(.*)/); const notOkMatch = line.match(/^not ok (\d+)(.*)/); - + if (okMatch) { const testNumber = parseInt(okMatch[1], 10); const description = okMatch[2].replace(/^[^\w]*/, '').trim(); - + // Check for SKIP directive if (description.includes('# SKIP')) { this.results.skipped++; @@ -87,18 +87,18 @@ class ResultParser { this.results.tests.push({ number: testNumber, status: 'pass', - description: description + description }); } } else if (notOkMatch) { const testNumber = parseInt(notOkMatch[1], 10); const description = notOkMatch[2].replace(/^[^\w]*/, '').trim(); - + this.results.failed++; this.results.tests.push({ number: testNumber, status: 'fail', - description: description + description }); } } @@ -142,25 +142,25 @@ class ResultParser { // Individual test results if (tests.length > 0) { lines.push(''); - tests.forEach(test => { + tests.forEach((test) => { let symbol, color; - + switch (test.status) { - case 'pass': - symbol = 'โœ“'; - color = chalk.green; - break; - case 'fail': - symbol = 'โœ—'; - color = chalk.red; - break; - case 'skip': - symbol = 'โ—‹'; - color = chalk.yellow; - break; - default: - symbol = '?'; - color = chalk.gray; + case 'pass': + symbol = 'โœ“'; + color = chalk.green; + break; + case 'fail': + symbol = 'โœ—'; + color = chalk.red; + break; + case 'skip': + symbol = 'โ—‹'; + color = chalk.yellow; + break; + default: + symbol = '?'; + color = chalk.gray; } let line = color(` ${symbol} ${test.description}`); @@ -175,7 +175,7 @@ class ResultParser { if (diagnostics.length > 0) { lines.push(''); lines.push(chalk.gray('Diagnostics:')); - diagnostics.forEach(diagnostic => { + diagnostics.forEach((diagnostic) => { lines.push(chalk.gray(` ${diagnostic}`)); }); } @@ -200,4 +200,4 @@ class ResultParser { } } -module.exports = ResultParser; \ No newline at end of file +export default ResultParser; diff --git a/src/lib/testing/TestPatternLibrary.js b/starfleet/data-core/src/testing/TestPatternLibrary.js similarity index 91% rename from src/lib/testing/TestPatternLibrary.js rename to starfleet/data-core/src/testing/TestPatternLibrary.js index 3b005b0..4c8f091 100644 --- a/src/lib/testing/TestPatternLibrary.js +++ b/starfleet/data-core/src/testing/TestPatternLibrary.js @@ -1,10 +1,10 @@ /** * Test Pattern Library - * + * * Comprehensive library of reusable test patterns for pgTAP test generation. * Provides common patterns for each test type with best practices and examples. * Used by TestTemplateGenerator to ensure consistency across all generated tests. - * + * * @fileoverview Test Pattern Library for pgTAP test generation * @author D.A.T.A. Engineering Team * @version 1.0.0 @@ -27,7 +27,7 @@ /** * @typedef {Object} PatternCategory * @property {string} name - Category name - * @property {string} description - Category description + * @property {string} description - Category description * @property {Array} patterns - Patterns in this category * @property {Array} commonUseCases - Common use cases for this category * @property {Array} bestPractices - Category-level best practices @@ -40,13 +40,13 @@ class TestPatternLibrary { * @private */ this.categories = this.initializePatternCategories(); - + /** - * @type {Map} + * @type {Map} * @private */ this.patterns = this.initializePatterns(); - + /** * @type {Object>} * @private @@ -80,7 +80,7 @@ class TestPatternLibrary { */ getRecommendedPatterns(testType) { const patternNames = this.testTypePatterns[testType] || []; - return patternNames.map(name => this.patterns.get(name)).filter(Boolean); + return patternNames.map((name) => this.patterns.get(name)).filter(Boolean); } /** @@ -96,7 +96,7 @@ class TestPatternLibrary { } let rendered = pattern.sqlTemplate; - + // Replace placeholders with variables for (const [key, value] of Object.entries(variables)) { const placeholder = new RegExp(`\\$\\{${key}\\}`, 'g'); @@ -120,8 +120,9 @@ class TestPatternLibrary { * @returns {Array} Patterns at the specified difficulty */ getPatternsByDifficulty(difficulty) { - return Array.from(this.patterns.values()) - .filter(pattern => pattern.difficulty === difficulty); + return Array.from(this.patterns.values()).filter( + (pattern) => pattern.difficulty === difficulty + ); } /** @@ -236,7 +237,7 @@ class TestPatternLibrary { // =========================================================================== // DATA VALIDATION PATTERNS // =========================================================================== - + patterns.set('table_exists_basic', { name: 'table_exists_basic', category: 'data_validation', @@ -258,9 +259,7 @@ RETURN NEXT tap.has_table( 'Include schema name for clarity', 'Use descriptive test messages' ], - examples: [ - "renderPattern('table_exists_basic', { schema: 'public', tableName: 'users' })" - ], + examples: ["renderPattern('table_exists_basic', { schema: 'public', tableName: 'users' })"], difficulty: 'basic', dependencies: [] }); @@ -268,7 +267,8 @@ RETURN NEXT tap.has_table( patterns.set('column_structure_validation', { name: 'column_structure_validation', category: 'data_validation', - description: 'Comprehensive column structure validation including type, constraints, and defaults', + description: + 'Comprehensive column structure validation including type, constraints, and defaults', sqlTemplate: `-- Column: \${columnName} RETURN NEXT tap.has_column( '\${schema}', @@ -286,12 +286,27 @@ RETURN NEXT tap.has_column( \${primaryKeyTest} \${foreignKeyTest}`, - placeholders: ['schema', 'tableName', 'columnName', 'dataTypeTest', 'notNullTest', 'defaultValueTest', 'primaryKeyTest', 'foreignKeyTest'], + placeholders: [ + 'schema', + 'tableName', + 'columnName', + 'dataTypeTest', + 'notNullTest', + 'defaultValueTest', + 'primaryKeyTest', + 'foreignKeyTest' + ], metadata: { testType: 'structure', complexity: 'medium', executionTime: 'medium', - conditionalSections: ['dataTypeTest', 'notNullTest', 'defaultValueTest', 'primaryKeyTest', 'foreignKeyTest'] + conditionalSections: [ + 'dataTypeTest', + 'notNullTest', + 'defaultValueTest', + 'primaryKeyTest', + 'foreignKeyTest' + ] }, bestPractices: [ 'Test column existence before testing properties', @@ -332,7 +347,16 @@ RETURN NEXT tap.throws_ok( -- Test: Cascade behavior (if applicable) \${cascadeTest}`, - placeholders: ['sourceSchema', 'sourceTable', 'sourceColumn', 'targetSchema', 'targetTable', 'targetColumn', 'invalidValue', 'cascadeTest'], + placeholders: [ + 'sourceSchema', + 'sourceTable', + 'sourceColumn', + 'targetSchema', + 'targetTable', + 'targetColumn', + 'invalidValue', + 'cascadeTest' + ], metadata: { testType: 'integrity', complexity: 'medium', @@ -384,7 +408,15 @@ RETURN NEXT tap.throws_ok( -- Test: Boundary conditions \${boundaryTests}`, - placeholders: ['schema', 'tableName', 'constraintName', 'testColumns', 'validValues', 'invalidValues', 'boundaryTests'], + placeholders: [ + 'schema', + 'tableName', + 'constraintName', + 'testColumns', + 'validValues', + 'invalidValues', + 'boundaryTests' + ], metadata: { testType: 'validation', complexity: 'medium', @@ -443,10 +475,7 @@ RETURN NEXT tap.ok( 'Test RLS configuration before testing policies', 'Include both positive and negative checks' ], - examples: [ - 'Check RLS on users table', - 'Verify RLS enforcement on sensitive data tables' - ], + examples: ['Check RLS on users table', 'Verify RLS enforcement on sensitive data tables'], difficulty: 'basic', dependencies: [] }); @@ -583,7 +612,13 @@ RETURN NEXT tap.throws_ok( -- Test: User cannot access restricted schemas \${restrictedSchemaTest}`, - placeholders: ['privilegeEscalationAttempt', 'expectedErrorCode', 'escalationType', 'functionBypassTest', 'restrictedSchemaTest'], + placeholders: [ + 'privilegeEscalationAttempt', + 'expectedErrorCode', + 'escalationType', + 'functionBypassTest', + 'restrictedSchemaTest' + ], metadata: { testType: 'security_hardening', complexity: 'high', @@ -629,7 +664,14 @@ RETURN NEXT tap.has_index( -- Performance baseline test \${performanceTest}`, - placeholders: ['schema', 'tableName', 'indexName', 'queryPlanTest', 'selectivityTest', 'performanceTest'], + placeholders: [ + 'schema', + 'tableName', + 'indexName', + 'queryPlanTest', + 'selectivityTest', + 'performanceTest' + ], metadata: { testType: 'performance_validation', complexity: 'high', @@ -680,7 +722,13 @@ END; -- Test: Function resource usage is reasonable \${resourceUsageTest}`, - placeholders: ['functionCall', 'maxExecutionTime', 'functionName', 'concurrencyTest', 'resourceUsageTest'], + placeholders: [ + 'functionCall', + 'maxExecutionTime', + 'functionName', + 'concurrencyTest', + 'resourceUsageTest' + ], metadata: { testType: 'performance_validation', complexity: 'high', @@ -737,7 +785,16 @@ RETURN NEXT tap.throws_ok( '23503', 'Foreign key constraint violation properly detected: \${constraintName}' );`, - placeholders: ['schema', 'tableName', 'columns', 'nullValues', 'constraintName', 'duplicateInsert', 'invalidValues', 'orphanValues'], + placeholders: [ + 'schema', + 'tableName', + 'columns', + 'nullValues', + 'constraintName', + 'duplicateInsert', + 'invalidValues', + 'orphanValues' + ], metadata: { testType: 'error_validation', complexity: 'medium', @@ -797,7 +854,16 @@ EXCEPTION WHEN OTHERS THEN RETURN NEXT tap.fail('Function \${functionName} should maintain transaction integrity on error'); END;`, - placeholders: ['schema', 'functionName', 'invalidInput', 'errorInput', 'expectedErrorCode', 'errorMessage', 'transactionSetup', 'transactionStateCheck'], + placeholders: [ + 'schema', + 'functionName', + 'invalidInput', + 'errorInput', + 'expectedErrorCode', + 'errorMessage', + 'transactionSetup', + 'transactionStateCheck' + ], metadata: { testType: 'error_validation', complexity: 'high', @@ -942,7 +1008,15 @@ BEGIN 'No cross-user data leakage detected' ); END;`, - placeholders: ['createUser1Data', 'createUser2Data', 'schema', 'tableName', 'expectedUser1Count', 'expectedUser2Count', 'user2Filter'], + placeholders: [ + 'createUser1Data', + 'createUser2Data', + 'schema', + 'tableName', + 'expectedUser1Count', + 'expectedUser2Count', + 'user2Filter' + ], metadata: { testType: 'isolation_validation', complexity: 'high', @@ -968,7 +1042,7 @@ END;`, // Add patterns to their respective categories const dataValidationPatterns = [ patterns.get('table_exists_basic'), - patterns.get('column_structure_validation'), + patterns.get('column_structure_validation'), patterns.get('foreign_key_relationship'), patterns.get('constraint_validation') ]; @@ -997,7 +1071,7 @@ END;`, // Update category references this.categories.get('data_validation').patterns = dataValidationPatterns; - this.categories.get('security_testing').patterns = securityPatterns; + this.categories.get('security_testing').patterns = securityPatterns; this.categories.get('performance_testing').patterns = performancePatterns; this.categories.get('error_handling').patterns = errorHandlingPatterns; this.categories.get('multi_user_scenarios').patterns = multiUserPatterns; @@ -1021,7 +1095,7 @@ END;`, 'privilege_escalation_test' ], - // Row Level Security tests + // Row Level Security tests rls: [ 'rls_enablement_check', 'policy_existence_check', @@ -1047,7 +1121,7 @@ END;`, // Function tests (database functions) function: [ - 'function_exception_handling', + 'function_exception_handling', 'function_performance_test', 'constraint_violation_handling' ], @@ -1069,10 +1143,7 @@ END;`, ], // Index tests - index: [ - 'index_usage_verification', - 'function_performance_test' - ] + index: ['index_usage_verification', 'function_performance_test'] }; } @@ -1084,11 +1155,11 @@ END;`, getBestPractices(testType) { const patterns = this.getRecommendedPatterns(testType); const practices = new Set(); - - patterns.forEach(pattern => { - pattern.bestPractices.forEach(practice => practices.add(practice)); + + patterns.forEach((pattern) => { + pattern.bestPractices.forEach((practice) => practices.add(practice)); }); - + return Array.from(practices); } @@ -1100,13 +1171,13 @@ END;`, getUsageExamples(testType) { const patterns = this.getRecommendedPatterns(testType); const examples = []; - - patterns.forEach(pattern => { + + patterns.forEach((pattern) => { if (pattern.examples && pattern.examples.length > 0) { examples.push(...pattern.examples); } }); - + return examples; } @@ -1115,7 +1186,7 @@ END;`, * @returns {string} Formatted documentation */ generateDocumentation() { - let doc = `# Test Pattern Library Documentation\n\n`; + let doc = '# Test Pattern Library Documentation\n\n'; doc += `Generated on: ${new Date().toISOString()}\n\n`; doc += `Total Patterns: ${this.patterns.size}\n`; doc += `Categories: ${this.categories.size}\n\n`; @@ -1124,38 +1195,38 @@ END;`, for (const [categoryName, category] of this.categories) { doc += `## ${category.name.toUpperCase().replace('_', ' ')}\n\n`; doc += `${category.description}\n\n`; - - doc += `### Common Use Cases\n`; - category.commonUseCases.forEach(useCase => { + + doc += '### Common Use Cases\n'; + category.commonUseCases.forEach((useCase) => { doc += `- ${useCase}\n`; }); - doc += `\n`; + doc += '\n'; - doc += `### Best Practices\n`; - category.bestPractices.forEach(practice => { + doc += '### Best Practices\n'; + category.bestPractices.forEach((practice) => { doc += `- ${practice}\n`; }); - doc += `\n`; + doc += '\n'; - doc += `### Available Patterns\n`; - category.patterns.forEach(pattern => { + doc += '### Available Patterns\n'; + category.patterns.forEach((pattern) => { doc += `#### ${pattern.name}\n`; doc += `**Difficulty:** ${pattern.difficulty}\n`; doc += `**Description:** ${pattern.description}\n\n`; - + if (pattern.examples && pattern.examples.length > 0) { - doc += `**Examples:**\n`; - pattern.examples.forEach(example => { + doc += '**Examples:**\n'; + pattern.examples.forEach((example) => { doc += `- ${example}\n`; }); - doc += `\n`; + doc += '\n'; } }); - doc += `\n`; + doc += '\n'; } return doc; } } -module.exports = TestPatternLibrary; \ No newline at end of file +export default TestPatternLibrary; diff --git a/src/lib/testing/TestRequirementAnalyzer.js b/starfleet/data-core/src/testing/TestRequirementAnalyzer.js similarity index 78% rename from src/lib/testing/TestRequirementAnalyzer.js rename to starfleet/data-core/src/testing/TestRequirementAnalyzer.js index 84a835b..1f38be2 100644 --- a/src/lib/testing/TestRequirementAnalyzer.js +++ b/starfleet/data-core/src/testing/TestRequirementAnalyzer.js @@ -1,14 +1,14 @@ /** * Test Requirement Analyzer for D.A.T.A. - * + * * Analyzes AST migration operations and determines what pgTAP tests are required * to ensure database schema changes are properly validated. Maps schema operations * to specific test requirements for comprehensive coverage. - * + * * @module TestRequirementAnalyzer */ -const { EventEmitter } = require('events'); +import { EventEmitter } from 'events'; /** * Test requirement types @@ -16,16 +16,16 @@ const { EventEmitter } = require('events'); * @enum {string} */ const TEST_TYPES = { - SCHEMA: 'SCHEMA', // Table structure tests - DATA: 'DATA', // Data integrity tests - CONSTRAINT: 'CONSTRAINT', // Constraint validation tests - INDEX: 'INDEX', // Index existence and performance tests - FUNCTION: 'FUNCTION', // Function behavior tests - TRIGGER: 'TRIGGER', // Trigger functionality tests - RLS: 'RLS', // Row Level Security tests - VIEW: 'VIEW', // View definition tests - ENUM: 'ENUM', // Enum type tests - PERMISSION: 'PERMISSION' // Permission and security tests + SCHEMA: 'SCHEMA', // Table structure tests + DATA: 'DATA', // Data integrity tests + CONSTRAINT: 'CONSTRAINT', // Constraint validation tests + INDEX: 'INDEX', // Index existence and performance tests + FUNCTION: 'FUNCTION', // Function behavior tests + TRIGGER: 'TRIGGER', // Trigger functionality tests + RLS: 'RLS', // Row Level Security tests + VIEW: 'VIEW', // View definition tests + ENUM: 'ENUM', // Enum type tests + PERMISSION: 'PERMISSION' // Permission and security tests }; /** @@ -34,10 +34,10 @@ const TEST_TYPES = { * @enum {string} */ const TEST_PRIORITIES = { - CRITICAL: 'CRITICAL', // Must have - blocks deployment - HIGH: 'HIGH', // Should have - important coverage - MEDIUM: 'MEDIUM', // Nice to have - good practice - LOW: 'LOW' // Optional - comprehensive coverage + CRITICAL: 'CRITICAL', // Must have - blocks deployment + HIGH: 'HIGH', // Should have - important coverage + MEDIUM: 'MEDIUM', // Nice to have - good practice + LOW: 'LOW' // Optional - comprehensive coverage }; /** @@ -67,7 +67,7 @@ const TEST_PRIORITIES = { class TestRequirementAnalyzer extends EventEmitter { constructor(options = {}) { super(); - + // Configuration options this.options = { // Test coverage requirements @@ -75,32 +75,33 @@ class TestRequirementAnalyzer extends EventEmitter { requireConstraintTests: options.requireConstraintTests !== false, requirePerformanceTests: options.requirePerformanceTests || false, requireSecurityTests: options.requireSecurityTests !== false, - + // Risk-based test priorities - destructiveOperationPriority: options.destructiveOperationPriority || TEST_PRIORITIES.CRITICAL, + destructiveOperationPriority: + options.destructiveOperationPriority || TEST_PRIORITIES.CRITICAL, warningOperationPriority: options.warningOperationPriority || TEST_PRIORITIES.HIGH, safeOperationPriority: options.safeOperationPriority || TEST_PRIORITIES.MEDIUM, - + // Test complexity thresholds maxTestCasesPerRequirement: options.maxTestCasesPerRequirement || 10, estimatedEffortPerTest: options.estimatedEffortPerTest || 0.5, // hours - + ...options }; // Operation type to test type mappings this.operationTestMappings = this._initializeTestMappings(); - + // Risk patterns that require additional testing this.highRiskPatterns = [ /DROP TABLE/i, - /DROP COLUMN/i, + /DROP COLUMN/i, /ALTER.*TYPE/i, /DROP CONSTRAINT/i, /TRUNCATE/i, /DELETE FROM/i ]; - + // Security-sensitive patterns this.securityPatterns = [ /CREATE POLICY|DROP POLICY|ALTER POLICY/i, @@ -109,7 +110,7 @@ class TestRequirementAnalyzer extends EventEmitter { /security_definer|security_invoker/i ]; } - + /** * Analyze migration operations for test requirements * @param {Array} operations - Array of migration operations @@ -117,11 +118,11 @@ class TestRequirementAnalyzer extends EventEmitter { * @returns {Promise} Analysis results with test requirements */ async analyzeOperations(operations, context = {}) { - this.emit('progress', { + this.emit('progress', { message: 'Analyzing operations for test requirements...', - operations: operations.length + operations: operations.length }); - + const analysis = { requirements: [], summary: { @@ -134,53 +135,56 @@ class TestRequirementAnalyzer extends EventEmitter { estimatedEffort: 0, riskAreas: [] }; - + // Analyze each operation for (let i = 0; i < operations.length; i++) { const operation = operations[i]; - + this.emit('progress', { message: `Analyzing operation ${i + 1}/${operations.length}...`, operation: operation.description || operation.sql?.substring(0, 50) }); - + const requirements = await this.determineTestRequirements(operation, context); - + // Add requirements to analysis analysis.requirements.push(...requirements); - + // Update statistics for (const req of requirements) { analysis.summary.byType[req.type] = (analysis.summary.byType[req.type] || 0) + 1; - analysis.summary.byPriority[req.priority] = (analysis.summary.byPriority[req.priority] || 0) + 1; + analysis.summary.byPriority[req.priority] = + (analysis.summary.byPriority[req.priority] || 0) + 1; analysis.estimatedEffort += this._estimateTestEffort(req); } - + // Check for risk areas if (this._isHighRiskOperation(operation)) { - analysis.riskAreas.push(operation.description || this._extractOperationDescription(operation)); + analysis.riskAreas.push( + operation.description || this._extractOperationDescription(operation) + ); } } - + // Update total requirements analysis.summary.totalRequirements = analysis.requirements.length; - + // Generate high-level suggestions analysis.suggestions = this._generateTestingSuggestions(analysis, operations, context); - + // Sort requirements by priority analysis.requirements.sort((a, b) => this._comparePriority(a.priority, b.priority)); - + this.emit('complete', { message: 'Test requirement analysis complete', totalRequirements: analysis.summary.totalRequirements, estimatedEffort: Math.round(analysis.estimatedEffort * 10) / 10, riskAreas: analysis.riskAreas.length }); - + return analysis; } - + /** * Validate operation structure before processing * @param {Object} operation - Operation to validate @@ -192,44 +196,52 @@ class TestRequirementAnalyzer extends EventEmitter { if (!operation || typeof operation !== 'object') { throw new Error('Invalid operation: must be a non-null object'); } - + // Check required properties if (!operation.sql || typeof operation.sql !== 'string') { - throw new Error(`Invalid operation: missing or invalid 'sql' property (got ${typeof operation.sql})`); + throw new Error( + `Invalid operation: missing or invalid 'sql' property (got ${typeof operation.sql})` + ); } - + if (!operation.type || typeof operation.type !== 'string') { - throw new Error(`Invalid operation: missing or invalid 'type' property (got ${typeof operation.type})`); + throw new Error( + `Invalid operation: missing or invalid 'type' property (got ${typeof operation.type})` + ); } - + // Validate operation type is known const validTypes = ['SAFE', 'WARNING', 'DESTRUCTIVE']; if (!validTypes.includes(operation.type)) { this.emit('warning', { message: `Unknown operation type: ${operation.type}`, - operation: operation, - validTypes: validTypes + operation, + validTypes }); } - + // Validate optional properties if present if (operation.description && typeof operation.description !== 'string') { - throw new Error(`Invalid operation: 'description' must be a string (got ${typeof operation.description})`); + throw new Error( + `Invalid operation: 'description' must be a string (got ${typeof operation.description})` + ); } - + if (operation.warning && typeof operation.warning !== 'string') { - throw new Error(`Invalid operation: 'warning' must be a string (got ${typeof operation.warning})`); + throw new Error( + `Invalid operation: 'warning' must be a string (got ${typeof operation.warning})` + ); } - + // Check for malformed SQL (basic validation) if (operation.sql.length === 0) { throw new Error('Invalid operation: SQL cannot be empty'); } - + if (operation.sql.length > 100000) { throw new Error('Invalid operation: SQL exceeds maximum length (100KB)'); } - + return true; } @@ -247,111 +259,111 @@ class TestRequirementAnalyzer extends EventEmitter { this.emit('error', { message: 'Operation validation failed', error: error.message, - operation: operation + operation }); throw error; } - + const requirements = []; - + // Base priority based on operation type const basePriority = this._getBasePriority(operation); - + // Extract operation details const operationType = this._categorizeOperation(operation); const target = this._extractTargetObject(operation); - + // Generate requirements based on operation type switch (operationType) { - case 'CREATE_TABLE': - requirements.push(...this._generateTableCreationTests(operation, target, basePriority)); - break; - - case 'DROP_TABLE': - requirements.push(...this._generateTableDropTests(operation, target, basePriority)); - break; - - case 'ALTER_TABLE': - requirements.push(...this._generateTableAlterationTests(operation, target, basePriority)); - break; - - case 'CREATE_INDEX': - requirements.push(...this._generateIndexTests(operation, target, basePriority)); - break; - - case 'CREATE_FUNCTION': - requirements.push(...this._generateFunctionTests(operation, target, basePriority)); - break; - - case 'CREATE_POLICY': - requirements.push(...this._generateCreatePolicyTests(operation, target, basePriority)); - break; - - case 'ALTER_POLICY': - requirements.push(...this._generateAlterPolicyTests(operation, target, basePriority)); - break; - - case 'DROP_POLICY': - requirements.push(...this._generateDropPolicyTests(operation, target, basePriority)); - break; - - case 'ENABLE_RLS': - requirements.push(...this._generateEnableRLSTests(operation, target, basePriority)); - break; - - case 'DISABLE_RLS': - requirements.push(...this._generateDisableRLSTests(operation, target, basePriority)); - break; - - case 'CREATE_VIEW': - requirements.push(...this._generateViewTests(operation, target, basePriority)); - break; - - case 'CREATE_ENUM': - requirements.push(...this._generateEnumTests(operation, target, basePriority)); - break; - - case 'CREATE_TRIGGER': - requirements.push(...this._generateTriggerTests(operation, target, basePriority)); - break; - - case 'ALTER_TRIGGER': - requirements.push(...this._generateTriggerTests(operation, target, basePriority)); - break; - - case 'DROP_TRIGGER': - requirements.push(...this._generateTriggerTests(operation, target, basePriority)); - break; - - case 'CREATE_EVENT_TRIGGER': - requirements.push(...this._generateTriggerTests(operation, target, basePriority)); - break; - - default: - // Generic tests for unclassified operations - requirements.push(...this._generateGenericTests(operation, target, basePriority)); + case 'CREATE_TABLE': + requirements.push(...this._generateTableCreationTests(operation, target, basePriority)); + break; + + case 'DROP_TABLE': + requirements.push(...this._generateTableDropTests(operation, target, basePriority)); + break; + + case 'ALTER_TABLE': + requirements.push(...this._generateTableAlterationTests(operation, target, basePriority)); + break; + + case 'CREATE_INDEX': + requirements.push(...this._generateIndexTests(operation, target, basePriority)); + break; + + case 'CREATE_FUNCTION': + requirements.push(...this._generateFunctionTests(operation, target, basePriority)); + break; + + case 'CREATE_POLICY': + requirements.push(...this._generateCreatePolicyTests(operation, target, basePriority)); + break; + + case 'ALTER_POLICY': + requirements.push(...this._generateAlterPolicyTests(operation, target, basePriority)); + break; + + case 'DROP_POLICY': + requirements.push(...this._generateDropPolicyTests(operation, target, basePriority)); + break; + + case 'ENABLE_RLS': + requirements.push(...this._generateEnableRLSTests(operation, target, basePriority)); + break; + + case 'DISABLE_RLS': + requirements.push(...this._generateDisableRLSTests(operation, target, basePriority)); + break; + + case 'CREATE_VIEW': + requirements.push(...this._generateViewTests(operation, target, basePriority)); + break; + + case 'CREATE_ENUM': + requirements.push(...this._generateEnumTests(operation, target, basePriority)); + break; + + case 'CREATE_TRIGGER': + requirements.push(...this._generateTriggerTests(operation, target, basePriority)); + break; + + case 'ALTER_TRIGGER': + requirements.push(...this._generateTriggerTests(operation, target, basePriority)); + break; + + case 'DROP_TRIGGER': + requirements.push(...this._generateTriggerTests(operation, target, basePriority)); + break; + + case 'CREATE_EVENT_TRIGGER': + requirements.push(...this._generateTriggerTests(operation, target, basePriority)); + break; + + default: + // Generic tests for unclassified operations + requirements.push(...this._generateGenericTests(operation, target, basePriority)); } - + // Add security tests for sensitive operations if (this._requiresSecurityTests(operation)) { requirements.push(...this._generateSecurityTests(operation, target, basePriority)); } - + // Add performance tests for performance-impacting operations if (this.options.requirePerformanceTests && this._requiresPerformanceTests(operation)) { requirements.push(...this._generatePerformanceTests(operation, target, basePriority)); } - + // Enhance requirements with metadata for (const req of requirements) { req.operation = operation; req.reason = req.reason || this._generateTestReason(req, operation); req.metadata = req.metadata || this._generateTestMetadata(req, operation, context); } - + return requirements; } - + /** * Initialize operation to test type mappings * @private @@ -378,7 +390,7 @@ class TestRequirementAnalyzer extends EventEmitter { 'DROP TRIGGER': [TEST_TYPES.TRIGGER] }; } - + /** * Generate test requirements for table creation * @private @@ -387,7 +399,7 @@ class TestRequirementAnalyzer extends EventEmitter { const requirements = []; const sql = operation.sql || ''; const tableStructure = this._parseTableStructure(sql); - + // Basic table existence test requirements.push({ type: TEST_TYPES.SCHEMA, @@ -396,13 +408,19 @@ class TestRequirementAnalyzer extends EventEmitter { target, testCases: [ `has_table('${target}')`, - `columns_are('${target}', ARRAY[${tableStructure.columns.map(c => `'${c.name}'`).join(', ')}])`, - ...tableStructure.columns.map(col => `col_type_is('${target}', '${col.name}', '${col.type}')`), - ...tableStructure.columns.filter(col => col.notNull).map(col => `col_not_null('${target}', '${col.name}')`), - ...tableStructure.columns.filter(col => col.hasDefault).map(col => `col_has_default('${target}', '${col.name}')`) + `columns_are('${target}', ARRAY[${tableStructure.columns.map((c) => `'${c.name}'`).join(', ')}])`, + ...tableStructure.columns.map( + (col) => `col_type_is('${target}', '${col.name}', '${col.type}')` + ), + ...tableStructure.columns + .filter((col) => col.notNull) + .map((col) => `col_not_null('${target}', '${col.name}')`), + ...tableStructure.columns + .filter((col) => col.hasDefault) + .map((col) => `col_has_default('${target}', '${col.name}')`) ] }); - + // Primary key tests if (tableStructure.primaryKeys.length > 0) { requirements.push({ @@ -412,11 +430,11 @@ class TestRequirementAnalyzer extends EventEmitter { target, testCases: [ `has_pk('${target}')`, - ...tableStructure.primaryKeys.map(pk => `col_is_pk('${target}', '${pk}')`) + ...tableStructure.primaryKeys.map((pk) => `col_is_pk('${target}', '${pk}')`) ] }); } - + // Foreign key tests if (tableStructure.foreignKeys.length > 0) { requirements.push({ @@ -425,26 +443,29 @@ class TestRequirementAnalyzer extends EventEmitter { description: `Verify foreign key constraints on table ${target}`, target, testCases: [ - ...tableStructure.foreignKeys.map(fk => `has_fk('${target}', '${fk.column}')`), - ...tableStructure.foreignKeys.map(fk => `fk_ok('${target}', '${fk.column}', '${fk.referencedTable}', '${fk.referencedColumn}')`) + ...tableStructure.foreignKeys.map((fk) => `has_fk('${target}', '${fk.column}')`), + ...tableStructure.foreignKeys.map( + (fk) => + `fk_ok('${target}', '${fk.column}', '${fk.referencedTable}', '${fk.referencedColumn}')` + ) ] }); } - + // Constraint tests (check constraints, unique constraints) if (this.options.requireConstraintTests) { const constraintTests = []; - + // Check constraints - tableStructure.checkConstraints.forEach(constraint => { + tableStructure.checkConstraints.forEach((constraint) => { constraintTests.push(`has_check('${target}', '${constraint.name}')`); }); - + // Unique constraints - tableStructure.uniqueConstraints.forEach(constraint => { + tableStructure.uniqueConstraints.forEach((constraint) => { constraintTests.push(`has_unique('${target}', '${constraint.name}')`); }); - + if (constraintTests.length > 0) { requirements.push({ type: TEST_TYPES.CONSTRAINT, @@ -455,7 +476,7 @@ class TestRequirementAnalyzer extends EventEmitter { }); } } - + // Index tests for inline indexes if (tableStructure.indexes.length > 0) { requirements.push({ @@ -464,14 +485,17 @@ class TestRequirementAnalyzer extends EventEmitter { description: `Verify indexes created for table ${target}`, target, testCases: [ - ...tableStructure.indexes.map(idx => `has_index('${target}', '${idx.name}', ARRAY[${idx.columns.map(c => `'${c}'`).join(', ')}])`) + ...tableStructure.indexes.map( + (idx) => + `has_index('${target}', '${idx.name}', ARRAY[${idx.columns.map((c) => `'${c}'`).join(', ')}])` + ) ] }); } - + return requirements; } - + /** * Generate test requirements for table drops * @private @@ -479,36 +503,35 @@ class TestRequirementAnalyzer extends EventEmitter { _generateTableDropTests(operation, target, priority) { const sql = operation.sql || ''; const isCascade = sql.toUpperCase().includes('CASCADE'); - - const testCases = [ - `hasnt_table('${target}')`, - `-- Verify table no longer exists in schema` - ]; - + + const testCases = [`hasnt_table('${target}')`, '-- Verify table no longer exists in schema']; + if (isCascade) { testCases.push( - `-- Verify dependent objects were also dropped (CASCADE)`, - `-- Check that foreign key references are cleaned up`, - `-- Ensure dependent views were dropped`, - `-- Verify dependent functions/triggers were dropped` + '-- Verify dependent objects were also dropped (CASCADE)', + '-- Check that foreign key references are cleaned up', + '-- Ensure dependent views were dropped', + '-- Verify dependent functions/triggers were dropped' ); } else { testCases.push( - `-- Verify no dependent objects were affected (RESTRICT)`, - `-- Check that foreign key references are handled properly`, - `-- Ensure operation failed if dependencies existed` + '-- Verify no dependent objects were affected (RESTRICT)', + '-- Check that foreign key references are handled properly', + '-- Ensure operation failed if dependencies existed' ); } - - return [{ - type: TEST_TYPES.SCHEMA, - priority: TEST_PRIORITIES.CRITICAL, // Always critical for destructive ops - description: `Verify table ${target} is properly dropped${isCascade ? ' with CASCADE' : ''}`, - target, - testCases - }]; + + return [ + { + type: TEST_TYPES.SCHEMA, + priority: TEST_PRIORITIES.CRITICAL, // Always critical for destructive ops + description: `Verify table ${target} is properly dropped${isCascade ? ' with CASCADE' : ''}`, + target, + testCases + } + ]; } - + /** * Generate test requirements for table alterations * @private @@ -517,31 +540,33 @@ class TestRequirementAnalyzer extends EventEmitter { const requirements = []; const sql = operation.sql || ''; const alterations = this._parseTableAlterations(sql, target); - + // Handle ADD COLUMN operations - alterations.addedColumns.forEach(column => { + alterations.addedColumns.forEach((column) => { const testCases = [ `has_column('${target}', '${column.name}')`, `col_type_is('${target}', '${column.name}', '${column.type}')` ]; - + if (column.notNull) { testCases.push(`col_not_null('${target}', '${column.name}')`); } - + if (column.hasDefault) { testCases.push(`col_has_default('${target}', '${column.name}')`); if (column.defaultValue) { testCases.push(`col_default_is('${target}', '${column.name}', ${column.defaultValue})`); } } - + // Add foreign key test if it's a reference column if (column.foreignKey) { testCases.push(`has_fk('${target}', '${column.name}')`); - testCases.push(`fk_ok('${target}', '${column.name}', '${column.foreignKey.referencedTable}', '${column.foreignKey.referencedColumn}')`); + testCases.push( + `fk_ok('${target}', '${column.name}', '${column.foreignKey.referencedTable}', '${column.foreignKey.referencedColumn}')` + ); } - + requirements.push({ type: TEST_TYPES.SCHEMA, priority, @@ -550,9 +575,9 @@ class TestRequirementAnalyzer extends EventEmitter { testCases }); }); - + // Handle DROP COLUMN operations - alterations.droppedColumns.forEach(columnName => { + alterations.droppedColumns.forEach((columnName) => { requirements.push({ type: TEST_TYPES.SCHEMA, priority: TEST_PRIORITIES.CRITICAL, @@ -560,27 +585,25 @@ class TestRequirementAnalyzer extends EventEmitter { target, testCases: [ `hasnt_column('${target}', '${columnName}')`, - `-- Verify remaining columns are intact`, - `-- Check that dependent objects were handled properly` + '-- Verify remaining columns are intact', + '-- Check that dependent objects were handled properly' ] }); }); - + // Handle ALTER COLUMN TYPE operations - alterations.alteredColumns.forEach(column => { - const testCases = [ - `col_type_is('${target}', '${column.name}', '${column.newType}')` - ]; - + alterations.alteredColumns.forEach((column) => { + const testCases = [`col_type_is('${target}', '${column.name}', '${column.newType}')`]; + // Add data integrity tests for type changes if (column.oldType !== column.newType) { testCases.push( `-- Test data conversion from ${column.oldType} to ${column.newType}`, - `-- Verify no data loss occurred during type conversion`, - `-- Test edge cases for type conversion` + '-- Verify no data loss occurred during type conversion', + '-- Test edge cases for type conversion' ); } - + requirements.push({ type: TEST_TYPES.DATA, priority: TEST_PRIORITIES.HIGH, @@ -589,7 +612,7 @@ class TestRequirementAnalyzer extends EventEmitter { testCases }); }); - + // Handle RENAME TABLE operations if (alterations.renamedTo) { requirements.push({ @@ -600,14 +623,14 @@ class TestRequirementAnalyzer extends EventEmitter { testCases: [ `has_table('${alterations.renamedTo}')`, `hasnt_table('${target}')`, - `-- Verify all dependent objects reference new table name`, - `-- Check that foreign key references are updated` + '-- Verify all dependent objects reference new table name', + '-- Check that foreign key references are updated' ] }); } - + // Handle RENAME COLUMN operations - alterations.renamedColumns.forEach(rename => { + alterations.renamedColumns.forEach((rename) => { requirements.push({ type: TEST_TYPES.SCHEMA, priority: TEST_PRIORITIES.HIGH, @@ -617,34 +640,36 @@ class TestRequirementAnalyzer extends EventEmitter { `has_column('${target}', '${rename.newName}')`, `hasnt_column('${target}', '${rename.oldName}')`, `col_type_is('${target}', '${rename.newName}', '${rename.type}')`, - `-- Verify column maintains all constraints and properties` + '-- Verify column maintains all constraints and properties' ] }); }); - + // Handle ADD CONSTRAINT operations - alterations.addedConstraints.forEach(constraint => { + alterations.addedConstraints.forEach((constraint) => { const testCases = []; - + switch (constraint.type) { - case 'PRIMARY KEY': - testCases.push(`has_pk('${target}')`); - constraint.columns.forEach(col => { - testCases.push(`col_is_pk('${target}', '${col}')`); - }); - break; - case 'FOREIGN KEY': - testCases.push(`has_fk('${target}', '${constraint.column}')`); - testCases.push(`fk_ok('${target}', '${constraint.column}', '${constraint.referencedTable}', '${constraint.referencedColumn}')`); - break; - case 'UNIQUE': - testCases.push(`has_unique('${target}', '${constraint.name}')`); - break; - case 'CHECK': - testCases.push(`has_check('${target}', '${constraint.name}')`); - break; + case 'PRIMARY KEY': + testCases.push(`has_pk('${target}')`); + constraint.columns.forEach((col) => { + testCases.push(`col_is_pk('${target}', '${col}')`); + }); + break; + case 'FOREIGN KEY': + testCases.push(`has_fk('${target}', '${constraint.column}')`); + testCases.push( + `fk_ok('${target}', '${constraint.column}', '${constraint.referencedTable}', '${constraint.referencedColumn}')` + ); + break; + case 'UNIQUE': + testCases.push(`has_unique('${target}', '${constraint.name}')`); + break; + case 'CHECK': + testCases.push(`has_check('${target}', '${constraint.name}')`); + break; } - + requirements.push({ type: TEST_TYPES.CONSTRAINT, priority, @@ -653,9 +678,9 @@ class TestRequirementAnalyzer extends EventEmitter { testCases }); }); - + // Handle DROP CONSTRAINT operations - alterations.droppedConstraints.forEach(constraint => { + alterations.droppedConstraints.forEach((constraint) => { requirements.push({ type: TEST_TYPES.CONSTRAINT, priority: TEST_PRIORITIES.CRITICAL, @@ -663,15 +688,15 @@ class TestRequirementAnalyzer extends EventEmitter { target, testCases: [ `-- Verify constraint ${constraint.name} no longer exists`, - `-- Check that dependent functionality still works`, - `-- Test that constraint is truly removed` + '-- Check that dependent functionality still works', + '-- Test that constraint is truly removed' ] }); }); - + return requirements; } - + /** * Generate test requirements for indexes * @private @@ -679,49 +704,48 @@ class TestRequirementAnalyzer extends EventEmitter { _generateIndexTests(operation, target, priority) { const requirements = []; const sql = operation.sql?.toUpperCase() || ''; - + // Determine index operation type const operationType = this._categorizeIndexOperation(sql); - + switch (operationType) { - case 'CREATE_INDEX': - requirements.push(...this._generateCreateIndexTests(operation, target, priority, sql)); - break; - - case 'CREATE_UNIQUE_INDEX': - requirements.push(...this._generateCreateUniqueIndexTests(operation, target, priority, sql)); - break; - - case 'DROP_INDEX': - requirements.push(...this._generateDropIndexTests(operation, target, priority, sql)); - break; - - case 'ALTER_INDEX': - requirements.push(...this._generateAlterIndexTests(operation, target, priority, sql)); - break; - - default: - // Fallback for generic index operations - requirements.push({ - type: TEST_TYPES.INDEX, - priority, - description: `Verify index ${target} operation`, - target, - testCases: [ - 'has_index()', - 'Verify index operation completed successfully' - ] - }); + case 'CREATE_INDEX': + requirements.push(...this._generateCreateIndexTests(operation, target, priority, sql)); + break; + + case 'CREATE_UNIQUE_INDEX': + requirements.push( + ...this._generateCreateUniqueIndexTests(operation, target, priority, sql) + ); + break; + + case 'DROP_INDEX': + requirements.push(...this._generateDropIndexTests(operation, target, priority, sql)); + break; + + case 'ALTER_INDEX': + requirements.push(...this._generateAlterIndexTests(operation, target, priority, sql)); + break; + + default: + // Fallback for generic index operations + requirements.push({ + type: TEST_TYPES.INDEX, + priority, + description: `Verify index ${target} operation`, + target, + testCases: ['has_index()', 'Verify index operation completed successfully'] + }); } - + // Add performance tests for large table considerations if (this._requiresIndexPerformanceTests(sql)) { requirements.push(...this._generateIndexPerformanceTests(operation, target, priority, sql)); } - + return requirements; } - + /** * Categorize index operation type * @private @@ -735,7 +759,7 @@ class TestRequirementAnalyzer extends EventEmitter { if (sql.includes('ALTER INDEX')) return 'ALTER_INDEX'; return 'UNKNOWN_INDEX'; } - + /** * Generate test requirements for CREATE INDEX operations * @private @@ -743,7 +767,7 @@ class TestRequirementAnalyzer extends EventEmitter { _generateCreateIndexTests(operation, target, priority, sql) { const requirements = []; const indexDetails = this._parseIndexDetails(sql); - + // Basic index existence tests requirements.push({ type: TEST_TYPES.INDEX, @@ -762,7 +786,7 @@ class TestRequirementAnalyzer extends EventEmitter { isPartial: indexDetails.isPartial } }); - + // Column-specific tests if (indexDetails.columns && indexDetails.columns.length > 0) { requirements.push({ @@ -770,14 +794,16 @@ class TestRequirementAnalyzer extends EventEmitter { priority, description: `Verify index ${target} column mappings`, target, - testCases: indexDetails.columns.map(col => `index_is_on('${indexDetails.tableName}', '${target}', '${col}')`), + testCases: indexDetails.columns.map( + (col) => `index_is_on('${indexDetails.tableName}', '${target}', '${col}')` + ), metadata: { columns: indexDetails.columns, tableName: indexDetails.tableName } }); } - + // Partial index condition tests if (indexDetails.isPartial && indexDetails.whereClause) { requirements.push({ @@ -796,7 +822,7 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + // Index type-specific tests if (indexDetails.type) { requirements.push({ @@ -812,10 +838,10 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Generate test requirements for CREATE UNIQUE INDEX operations * @private @@ -823,10 +849,10 @@ class TestRequirementAnalyzer extends EventEmitter { _generateCreateUniqueIndexTests(operation, target, priority, sql) { const requirements = []; const indexDetails = this._parseIndexDetails(sql); - + // Include all regular index tests requirements.push(...this._generateCreateIndexTests(operation, target, priority, sql)); - + // Unique constraint validation tests requirements.push({ type: TEST_TYPES.CONSTRAINT, @@ -845,7 +871,7 @@ class TestRequirementAnalyzer extends EventEmitter { tableName: indexDetails.tableName } }); - + // Unique constraint violation tests if (indexDetails.columns && indexDetails.columns.length > 0) { requirements.push({ @@ -866,10 +892,10 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Generate test requirements for DROP INDEX operations * @private @@ -877,7 +903,7 @@ class TestRequirementAnalyzer extends EventEmitter { _generateDropIndexTests(operation, target, priority, sql) { const requirements = []; const indexDetails = this._parseIndexDetails(sql); - + // Index removal verification requirements.push({ type: TEST_TYPES.INDEX, @@ -894,7 +920,7 @@ class TestRequirementAnalyzer extends EventEmitter { tableName: indexDetails.tableName } }); - + // If it was a unique index, verify unique constraint is also removed if (sql.includes('UNIQUE')) { requirements.push({ @@ -913,7 +939,7 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + // Performance impact tests requirements.push({ type: TEST_TYPES.INDEX, @@ -930,10 +956,10 @@ class TestRequirementAnalyzer extends EventEmitter { expectedImpact: 'degradation' } }); - + return requirements; } - + /** * Generate test requirements for ALTER INDEX operations * @private @@ -941,7 +967,7 @@ class TestRequirementAnalyzer extends EventEmitter { _generateAlterIndexTests(operation, target, priority, sql) { const requirements = []; const indexDetails = this._parseIndexDetails(sql); - + // Index alteration verification requirements.push({ type: TEST_TYPES.INDEX, @@ -958,7 +984,7 @@ class TestRequirementAnalyzer extends EventEmitter { tableName: indexDetails.tableName } }); - + // Rename operations if (sql.includes('RENAME TO')) { const newName = this._extractNewIndexName(sql); @@ -974,12 +1000,12 @@ class TestRequirementAnalyzer extends EventEmitter { ], metadata: { oldName: target, - newName: newName, + newName, operation: 'rename' } }); } - + // Tablespace or other property changes if (sql.includes('SET TABLESPACE') || sql.includes('SET (')) { requirements.push({ @@ -997,10 +1023,10 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Generate performance test requirements for indexes * @private @@ -1008,7 +1034,7 @@ class TestRequirementAnalyzer extends EventEmitter { _generateIndexPerformanceTests(operation, target, priority, sql) { const requirements = []; const indexDetails = this._parseIndexDetails(sql); - + requirements.push({ type: TEST_TYPES.INDEX, priority: TEST_PRIORITIES.MEDIUM, @@ -1027,7 +1053,7 @@ class TestRequirementAnalyzer extends EventEmitter { measureMetrics: ['execution_time', 'index_usage', 'selectivity'] } }); - + // Large table considerations if (this._isLargeTableOperation(indexDetails.tableName)) { requirements.push({ @@ -1047,10 +1073,10 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Parse index details from SQL statement * @private @@ -1066,22 +1092,22 @@ class TestRequirementAnalyzer extends EventEmitter { whereClause: null, isUnique: false }; - + // Extract table name let match = sql.match(/ON\s+([^\s(]+)/i); if (match) { details.tableName = match[1]; } - + // Extract columns match = sql.match(/\(([^)]+)\)/); if (match) { details.columns = match[1] .split(',') - .map(col => col.trim()) - .map(col => col.replace(/["'`]/g, '')); // Remove quotes + .map((col) => col.trim()) + .map((col) => col.replace(/["'`]/g, '')); // Remove quotes } - + // Check for index type match = sql.match(/USING\s+(\w+)/i); if (match) { @@ -1089,20 +1115,20 @@ class TestRequirementAnalyzer extends EventEmitter { } else { details.type = 'btree'; // Default PostgreSQL index type } - + // Check if unique details.isUnique = sql.includes('UNIQUE'); - + // Check for partial index (WHERE clause) match = sql.match(/WHERE\s+(.+?)(?:$|\s*;)/i); if (match) { details.isPartial = true; details.whereClause = match[1].trim(); } - + return details; } - + /** * Extract new index name from ALTER INDEX RENAME statement * @private @@ -1113,7 +1139,7 @@ class TestRequirementAnalyzer extends EventEmitter { const match = sql.match(/RENAME TO\s+([^\s;]+)/i); return match ? match[1] : 'unknown_name'; } - + /** * Check if index operation requires performance tests * @private @@ -1125,12 +1151,14 @@ class TestRequirementAnalyzer extends EventEmitter { // - Indexes on likely large tables // - Complex expressions or functions in indexes // - Partial indexes with complex conditions - return sql.includes('CREATE INDEX') && - (sql.includes('WHERE') || // Partial index - sql.includes('(') && sql.includes('||') || // Expression index - this.options.requirePerformanceTests); + return ( + sql.includes('CREATE INDEX') && + (sql.includes('WHERE') || // Partial index + (sql.includes('(') && sql.includes('||')) || // Expression index + this.options.requirePerformanceTests) + ); } - + /** * Determine if operation is on a large table (heuristic) * @private @@ -1139,7 +1167,7 @@ class TestRequirementAnalyzer extends EventEmitter { */ _isLargeTableOperation(tableName) { if (!tableName) return false; - + // Heuristic: tables with certain naming patterns are likely large const largeTablePatterns = [ /events?$/i, @@ -1151,10 +1179,10 @@ class TestRequirementAnalyzer extends EventEmitter { /history$/i, /metrics?$/i ]; - - return largeTablePatterns.some(pattern => pattern.test(tableName)); + + return largeTablePatterns.some((pattern) => pattern.test(tableName)); } - + /** * Generate test requirements for functions * @private @@ -1162,60 +1190,68 @@ class TestRequirementAnalyzer extends EventEmitter { _generateFunctionTests(operation, target, priority) { const sql = (operation.sql || '').toUpperCase(); const requirements = []; - + // Determine specific function operation type const functionOperation = this._categorizeFunction(operation); - + // Extract function metadata const functionMetadata = this._extractFunctionMetadata(operation); - + // Base function existence and structure tests switch (functionOperation) { - case 'CREATE_FUNCTION': - case 'CREATE_OR_REPLACE_FUNCTION': - requirements.push(...this._generateFunctionCreationTests(operation, target, priority, functionMetadata)); - break; - - case 'DROP_FUNCTION': - requirements.push(...this._generateFunctionDropTests(operation, target, priority)); - break; - - case 'ALTER_FUNCTION': - requirements.push(...this._generateFunctionAlterationTests(operation, target, priority, functionMetadata)); - break; - - default: - requirements.push(...this._generateGenericFunctionTests(operation, target, priority)); + case 'CREATE_FUNCTION': + case 'CREATE_OR_REPLACE_FUNCTION': + requirements.push( + ...this._generateFunctionCreationTests(operation, target, priority, functionMetadata) + ); + break; + + case 'DROP_FUNCTION': + requirements.push(...this._generateFunctionDropTests(operation, target, priority)); + break; + + case 'ALTER_FUNCTION': + requirements.push( + ...this._generateFunctionAlterationTests(operation, target, priority, functionMetadata) + ); + break; + + default: + requirements.push(...this._generateGenericFunctionTests(operation, target, priority)); } - + // Add Supabase RPC-specific tests if applicable if (this._isSupabaseRpcFunction(operation, functionMetadata)) { - requirements.push(...this._generateSupabaseRpcTests(operation, target, priority, functionMetadata)); + requirements.push( + ...this._generateSupabaseRpcTests(operation, target, priority, functionMetadata) + ); } - + // Add security tests for security definer functions if (functionMetadata.securityDefiner) { - requirements.push(...this._generateFunctionSecurityTests(operation, target, priority, functionMetadata)); + requirements.push( + ...this._generateFunctionSecurityTests(operation, target, priority, functionMetadata) + ); } - + return requirements; } - + /** * Categorize function operations for specific test mapping * @private */ _categorizeFunction(operation) { const sql = (operation.sql || '').toUpperCase(); - + if (sql.includes('CREATE OR REPLACE FUNCTION')) return 'CREATE_OR_REPLACE_FUNCTION'; if (sql.includes('CREATE FUNCTION')) return 'CREATE_FUNCTION'; if (sql.includes('DROP FUNCTION')) return 'DROP_FUNCTION'; if (sql.includes('ALTER FUNCTION')) return 'ALTER_FUNCTION'; - + return 'UNKNOWN_FUNCTION'; } - + /** * Extract function metadata from SQL operation * @private @@ -1231,48 +1267,48 @@ class TestRequirementAnalyzer extends EventEmitter { language: null, hasParameters: false }; - + // Extract parameter types const paramMatch = sql.match(/\((.*?)\)\s*RETURNS/i); if (paramMatch && paramMatch[1].trim()) { metadata.hasParameters = true; // Basic parameter extraction - can be enhanced - metadata.parameterTypes = paramMatch[1].split(',').map(p => p.trim().split(' ').pop()); + metadata.parameterTypes = paramMatch[1].split(',').map((p) => p.trim().split(' ').pop()); } - + // Extract return type const returnMatch = sql.match(/RETURNS\s+([^\s]+)/i); if (returnMatch) { metadata.returnType = returnMatch[1]; } - + // Check for security definer metadata.securityDefiner = /SECURITY\s+DEFINER/i.test(sql); - + // Check volatility if (/VOLATILE/i.test(sql)) metadata.isVolatile = true; else if (/STABLE/i.test(sql)) metadata.isVolatile = false; else if (/IMMUTABLE/i.test(sql)) metadata.isVolatile = false; - + // Extract language const langMatch = sql.match(/LANGUAGE\s+(\w+)/i); if (langMatch) { metadata.language = langMatch[1].toLowerCase(); } - + // Check if it's likely an RPC function (exposed via API) metadata.isRpcFunction = this._isLikelyRpcFunction(sql, metadata); - + return metadata; } - + /** * Generate tests for function creation (CREATE FUNCTION or CREATE OR REPLACE) * @private */ _generateFunctionCreationTests(operation, target, priority, metadata) { const requirements = []; - + // Core function existence and structure requirements.push({ type: TEST_TYPES.FUNCTION, @@ -1285,18 +1321,19 @@ class TestRequirementAnalyzer extends EventEmitter { ...(metadata.hasParameters ? ['function_args() - parameter validation'] : []), ...(metadata.language ? [`function_lang_is() - language is ${metadata.language}`] : []), ...(metadata.securityDefiner ? ['is_definer() - security definer check'] : []), - ...(metadata.isVolatile !== null ? [`volatility_is() - volatility check`] : []) + ...(metadata.isVolatile !== null ? ['volatility_is() - volatility check'] : []) ], metadata: { functionMetadata: metadata, testType: 'structure' } }); - + // Behavioral testing requirements.push({ type: TEST_TYPES.FUNCTION, - priority: priority === TEST_PRIORITIES.CRITICAL ? TEST_PRIORITIES.HIGH : TEST_PRIORITIES.MEDIUM, + priority: + priority === TEST_PRIORITIES.CRITICAL ? TEST_PRIORITIES.HIGH : TEST_PRIORITIES.MEDIUM, description: `Verify function ${target} behavior and logic`, target, testCases: [ @@ -1304,39 +1341,43 @@ class TestRequirementAnalyzer extends EventEmitter { 'Test return value correctness', 'Test error handling for invalid inputs', 'Test edge cases and boundary conditions', - ...(metadata.returnType === 'SETOF' || metadata.returnType?.includes('[]') ? ['Test result set completeness'] : []) + ...(metadata.returnType === 'SETOF' || metadata.returnType?.includes('[]') + ? ['Test result set completeness'] + : []) ], metadata: { functionMetadata: metadata, testType: 'behavior' } }); - + return requirements; } - + /** * Generate tests for function drops * @private */ _generateFunctionDropTests(operation, target, priority) { - return [{ - type: TEST_TYPES.FUNCTION, - priority: TEST_PRIORITIES.CRITICAL, - description: `Verify function ${target} is properly dropped`, - target, - testCases: [ - 'hasnt_function() - function no longer exists', - 'Verify dependent objects are handled', - 'Check cascade behavior if applicable', - 'Verify no orphaned permissions remain' - ], - metadata: { - testType: 'removal' + return [ + { + type: TEST_TYPES.FUNCTION, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify function ${target} is properly dropped`, + target, + testCases: [ + 'hasnt_function() - function no longer exists', + 'Verify dependent objects are handled', + 'Check cascade behavior if applicable', + 'Verify no orphaned permissions remain' + ], + metadata: { + testType: 'removal' + } } - }]; + ]; } - + /** * Generate tests for function alterations * @private @@ -1344,7 +1385,7 @@ class TestRequirementAnalyzer extends EventEmitter { _generateFunctionAlterationTests(operation, target, priority, metadata) { const sql = (operation.sql || '').toUpperCase(); const requirements = []; - + if (sql.includes('RENAME TO')) { requirements.push({ type: TEST_TYPES.FUNCTION, @@ -1362,7 +1403,7 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + if (sql.includes('OWNER TO')) { requirements.push({ type: TEST_TYPES.FUNCTION, @@ -1379,7 +1420,7 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + if (sql.includes('SET') || sql.includes('RESET')) { requirements.push({ type: TEST_TYPES.FUNCTION, @@ -1396,38 +1437,40 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Generate generic function tests for unknown operations * @private */ _generateGenericFunctionTests(operation, target, priority) { - return [{ - type: TEST_TYPES.FUNCTION, - priority: TEST_PRIORITIES.LOW, - description: `Verify function ${target} after operation`, - target, - testCases: [ - 'has_function() - function exists', - 'Test basic function execution', - 'Verify no unexpected side effects' - ], - metadata: { - testType: 'generic' + return [ + { + type: TEST_TYPES.FUNCTION, + priority: TEST_PRIORITIES.LOW, + description: `Verify function ${target} after operation`, + target, + testCases: [ + 'has_function() - function exists', + 'Test basic function execution', + 'Verify no unexpected side effects' + ], + metadata: { + testType: 'generic' + } } - }]; + ]; } - + /** * Generate Supabase RPC-specific tests * @private */ _generateSupabaseRpcTests(operation, target, priority, metadata) { const requirements = []; - + // API accessibility tests requirements.push({ type: TEST_TYPES.FUNCTION, @@ -1447,7 +1490,7 @@ class TestRequirementAnalyzer extends EventEmitter { requiresSupabaseClient: true } }); - + // Security and permissions for RPC requirements.push({ type: TEST_TYPES.PERMISSION, @@ -1467,7 +1510,7 @@ class TestRequirementAnalyzer extends EventEmitter { requiresSupabaseClient: true } }); - + // Error handling for RPC requirements.push({ type: TEST_TYPES.FUNCTION, @@ -1487,36 +1530,38 @@ class TestRequirementAnalyzer extends EventEmitter { requiresSupabaseClient: true } }); - + return requirements; } - + /** * Generate security tests for security definer functions * @private */ _generateFunctionSecurityTests(operation, target, priority, metadata) { - return [{ - type: TEST_TYPES.PERMISSION, - priority: TEST_PRIORITIES.CRITICAL, - description: `Verify security definer function ${target} security`, - target, - testCases: [ - 'is_definer() - verify security definer setting', - 'Test function executes with definer privileges', - 'Test privilege escalation protection', - 'Verify input parameter sanitization', - 'Test SQL injection protection', - 'Test with different invoker roles' - ], - metadata: { - functionMetadata: metadata, - testType: 'security_definer', - securityCritical: true + return [ + { + type: TEST_TYPES.PERMISSION, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify security definer function ${target} security`, + target, + testCases: [ + 'is_definer() - verify security definer setting', + 'Test function executes with definer privileges', + 'Test privilege escalation protection', + 'Verify input parameter sanitization', + 'Test SQL injection protection', + 'Test with different invoker roles' + ], + metadata: { + functionMetadata: metadata, + testType: 'security_definer', + securityCritical: true + } } - }]; + ]; } - + /** * Determine if function is likely RPC-accessible based on characteristics * @private @@ -1532,48 +1577,71 @@ class TestRequirementAnalyzer extends EventEmitter { /list_.*\(/i, /find_.*\(/i ]; - - return apiPatterns.some(pattern => pattern.test(sql)) || - metadata.language === 'plpgsql' || - metadata.returnType?.toLowerCase().includes('json'); + + return ( + apiPatterns.some((pattern) => pattern.test(sql)) || + metadata.language === 'plpgsql' || + metadata.returnType?.toLowerCase().includes('json') + ); } - + /** * Check if operation creates a Supabase RPC function * @private */ _isSupabaseRpcFunction(operation, metadata) { if (!metadata) return false; - + const sql = operation.sql || ''; - + // Skip system schema functions - if (sql.includes('auth.') || sql.includes('storage.') || sql.includes('realtime.') || sql.includes('supabase_functions.')) { + if ( + sql.includes('auth.') || + sql.includes('storage.') || + sql.includes('realtime.') || + sql.includes('supabase_functions.') + ) { return false; } - + // Functions in public schema are typically RPC-accessible - if (sql.includes('public.') || (!sql.includes('.') && !sql.includes('CREATE FUNCTION auth.') && !sql.includes('CREATE FUNCTION storage.'))) { + if ( + sql.includes('public.') || + (!sql.includes('.') && + !sql.includes('CREATE FUNCTION auth.') && + !sql.includes('CREATE FUNCTION storage.')) + ) { return true; } - + // Functions with simple parameter types are more likely to be RPC - if (metadata.parameterTypes.length === 0 || - metadata.parameterTypes.every(type => ['text', 'integer', 'boolean', 'json', 'jsonb', 'uuid'].includes(type.toLowerCase()))) { + if ( + metadata.parameterTypes.length === 0 || + metadata.parameterTypes.every((type) => + ['text', 'integer', 'boolean', 'json', 'jsonb', 'uuid'].includes(type.toLowerCase()) + ) + ) { return true; } - + // Functions returning JSON or simple types - if (metadata.returnType && ['json', 'jsonb', 'text', 'integer', 'boolean', 'uuid'].includes(metadata.returnType.toLowerCase())) { + if ( + metadata.returnType && + ['json', 'jsonb', 'text', 'integer', 'boolean', 'uuid'].includes( + metadata.returnType.toLowerCase() + ) + ) { return true; } - + // Functions in public schema or without schema qualifier are likely RPC - return metadata.isRpcFunction || - sql.includes('public.') || - (!sql.includes('.') && !sql.includes('pg_') && !sql.includes('information_schema')); + return ( + metadata.isRpcFunction || + sql.includes('public.') || + (!sql.includes('.') && !sql.includes('pg_') && !sql.includes('information_schema')) + ); } - + /** * Generate test requirements for CREATE POLICY operations * @private @@ -1583,10 +1651,10 @@ class TestRequirementAnalyzer extends EventEmitter { const sql = operation.sql || ''; const tableMatch = sql.match(/ON\s+([^\s(]+)/i); const tableName = tableMatch ? tableMatch[1] : 'unknown_table'; - + // Extract policy details const policyDetails = this._extractPolicyDetails(sql); - + // Core policy existence test requirements.push({ type: TEST_TYPES.RLS, @@ -1607,23 +1675,21 @@ class TestRequirementAnalyzer extends EventEmitter { testType: 'policy_creation' } }); - + // RLS enablement test requirements.push({ type: TEST_TYPES.RLS, priority: TEST_PRIORITIES.CRITICAL, description: `Verify RLS is enabled on table ${tableName}`, target: tableName, - testCases: [ - 'is_rls_enabled() - ensure RLS is active on the table' - ], + testCases: ['is_rls_enabled() - ensure RLS is active on the table'], metadata: { tableName, testType: 'rls_enablement', reason: `Policy ${policyName} requires RLS to be enabled` } }); - + // Security boundary tests for different user roles const userRoles = ['anon', 'authenticated', 'service_role']; for (const role of userRoles) { @@ -1648,10 +1714,10 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Generate test requirements for ALTER POLICY operations * @private @@ -1661,9 +1727,9 @@ class TestRequirementAnalyzer extends EventEmitter { const sql = operation.sql || ''; const tableMatch = sql.match(/ON\s+([^\s(]+)/i); const tableName = tableMatch ? tableMatch[1] : 'unknown_table'; - + const policyDetails = this._extractPolicyDetails(sql); - + // Policy validation after alteration requirements.push({ type: TEST_TYPES.RLS, @@ -1683,9 +1749,10 @@ class TestRequirementAnalyzer extends EventEmitter { testType: 'policy_alteration' } }); - + // Re-test security boundaries with updated policy - const userRoles = policyDetails.roles.length > 0 ? policyDetails.roles : ['anon', 'authenticated']; + const userRoles = + policyDetails.roles.length > 0 ? policyDetails.roles : ['anon', 'authenticated']; for (const role of userRoles) { requirements.push({ type: TEST_TYPES.PERMISSION, @@ -1706,10 +1773,10 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Generate test requirements for DROP POLICY operations * @private @@ -1719,7 +1786,7 @@ class TestRequirementAnalyzer extends EventEmitter { const sql = operation.sql || ''; const tableMatch = sql.match(/ON\s+([^\s(]+)/i); const tableName = tableMatch ? tableMatch[1] : 'unknown_table'; - + // Policy absence test requirements.push({ type: TEST_TYPES.RLS, @@ -1736,7 +1803,7 @@ class TestRequirementAnalyzer extends EventEmitter { testType: 'policy_removal' } }); - + // Test security implications of policy removal requirements.push({ type: TEST_TYPES.PERMISSION, @@ -1745,7 +1812,7 @@ class TestRequirementAnalyzer extends EventEmitter { target: `${tableName}_post_drop`, testCases: [ 'results_eq() - verify expected access changes after policy drop', - 'Test that removal doesn\'t unexpectedly grant access', + "Test that removal doesn't unexpectedly grant access", 'Verify other policies still function correctly', 'Test with different user roles' ], @@ -1756,17 +1823,17 @@ class TestRequirementAnalyzer extends EventEmitter { reason: 'Dropping policies can unexpectedly grant broader access' } }); - + return requirements; } - + /** * Generate test requirements for ENABLE ROW LEVEL SECURITY operations * @private */ _generateEnableRLSTests(operation, tableName, priority) { const requirements = []; - + // RLS enablement test requirements.push({ type: TEST_TYPES.RLS, @@ -1782,7 +1849,7 @@ class TestRequirementAnalyzer extends EventEmitter { testType: 'rls_enablement' } }); - + // Security impact test - RLS should restrict access by default requirements.push({ type: TEST_TYPES.PERMISSION, @@ -1805,32 +1872,30 @@ class TestRequirementAnalyzer extends EventEmitter { ] } }); - + return requirements; } - + /** * Generate test requirements for DISABLE ROW LEVEL SECURITY operations * @private */ _generateDisableRLSTests(operation, tableName, priority) { const requirements = []; - + // RLS disablement test requirements.push({ type: TEST_TYPES.RLS, priority: TEST_PRIORITIES.CRITICAL, description: `Verify RLS is disabled on table ${tableName}`, target: tableName, - testCases: [ - 'is_rls_enabled() - verify RLS is inactive' - ], + testCases: ['is_rls_enabled() - verify RLS is inactive'], metadata: { tableName, testType: 'rls_disablement' } }); - + // Security impact test - disabling RLS might grant broader access requirements.push({ type: TEST_TYPES.PERMISSION, @@ -1848,10 +1913,10 @@ class TestRequirementAnalyzer extends EventEmitter { reason: 'Disabling RLS can unexpectedly grant broader access' } }); - + return requirements; } - + /** * Extract policy details from SQL statement * @private @@ -1864,7 +1929,7 @@ class TestRequirementAnalyzer extends EventEmitter { expression: null, checkExpression: null }; - + // Extract commands (FOR SELECT, INSERT, UPDATE, DELETE, ALL) const commandMatch = sql.match(/FOR\s+(SELECT|INSERT|UPDATE|DELETE|ALL)/i); if (commandMatch) { @@ -1877,23 +1942,23 @@ class TestRequirementAnalyzer extends EventEmitter { // Default is ALL commands details.commands = ['SELECT', 'INSERT', 'UPDATE', 'DELETE']; } - + // Extract roles (TO role1, role2, ...) const rolesMatch = sql.match(/TO\s+((?:\w+(?:\s*,\s*\w+)*))\s+(?:USING|WITH|$)/i); if (rolesMatch) { - details.roles = rolesMatch[1].split(',').map(role => role.trim()); + details.roles = rolesMatch[1].split(',').map((role) => role.trim()); } - + // Check if restrictive policy details.isPermissive = !sql.toUpperCase().includes('AS RESTRICTIVE'); - + // Extract USING expression (handle nested parentheses) const usingStart = sql.search(/USING\s*\(/i); if (usingStart !== -1) { let parenCount = 0; - let startIdx = sql.indexOf('(', usingStart); + const startIdx = sql.indexOf('(', usingStart); let endIdx = startIdx; - + for (let i = startIdx; i < sql.length; i++) { if (sql[i] === '(') parenCount++; if (sql[i] === ')') parenCount--; @@ -1902,28 +1967,28 @@ class TestRequirementAnalyzer extends EventEmitter { break; } } - + if (parenCount === 0) { details.expression = sql.substring(startIdx + 1, endIdx); } } - - // Extract WITH CHECK expression + + // Extract WITH CHECK expression const checkMatch = sql.match(/WITH\s+CHECK\s*\(([^)]+)\)/i); if (checkMatch) { details.checkExpression = checkMatch[1]; } - + return details; } - + /** * Generate security test scenarios for a policy and role combination * @private */ _generateSecurityTestScenarios(policyDetails, role) { const scenarios = []; - + for (const command of policyDetails.commands) { // Basic allowed scenario scenarios.push({ @@ -1932,7 +1997,7 @@ class TestRequirementAnalyzer extends EventEmitter { shouldAllow: this._shouldPolicyAllowOperation(policyDetails, role, command), context: { description: `Test ${command} operation for ${role}` } }); - + // Edge case scenarios if (command === 'SELECT') { scenarios.push({ @@ -1942,7 +2007,7 @@ class TestRequirementAnalyzer extends EventEmitter { context: { description: `Test filtered SELECT for ${role}` } }); } - + if (command === 'INSERT') { scenarios.push({ role, @@ -1952,7 +2017,7 @@ class TestRequirementAnalyzer extends EventEmitter { }); } } - + // Test policy bypass scenarios scenarios.push({ role: 'service_role', @@ -1960,10 +2025,10 @@ class TestRequirementAnalyzer extends EventEmitter { shouldAllow: true, context: { description: 'Verify service_role bypasses RLS policies' } }); - + return scenarios; } - + /** * Determine if a policy should allow an operation for a role * @private @@ -1971,104 +2036,110 @@ class TestRequirementAnalyzer extends EventEmitter { _shouldPolicyAllowOperation(policyDetails, role, command) { // This is a simplified heuristic - in practice, this would depend on // the specific policy expression and database state - + if (role === 'service_role') { return true; // service_role bypasses RLS } - + if (policyDetails.roles.length > 0 && !policyDetails.roles.includes(role)) { return false; // Role not in policy } - + if (!policyDetails.commands.includes(command)) { return false; // Command not covered by policy } - + // Default assumption - policy allows the operation // In practice, this would need to evaluate the USING expression return true; } - + /** * Generate test requirements for views * @private */ _generateViewTests(operation, target, priority) { - return [{ - type: TEST_TYPES.VIEW, - priority, - description: `Verify view ${target} definition and data`, - target, - testCases: [ - 'has_view()', - 'Verify view returns expected columns', - 'Test view data accuracy', - 'Verify view permissions' - ] - }]; + return [ + { + type: TEST_TYPES.VIEW, + priority, + description: `Verify view ${target} definition and data`, + target, + testCases: [ + 'has_view()', + 'Verify view returns expected columns', + 'Test view data accuracy', + 'Verify view permissions' + ] + } + ]; } - + /** * Generate test requirements for enum types * @private */ _generateEnumTests(operation, target, priority) { - return [{ - type: TEST_TYPES.ENUM, - priority, - description: `Verify enum type ${target} values`, - target, - testCases: [ - 'has_type()', - 'Test all enum values are valid', - 'Test invalid values are rejected', - 'Verify enum usage in tables' - ] - }]; + return [ + { + type: TEST_TYPES.ENUM, + priority, + description: `Verify enum type ${target} values`, + target, + testCases: [ + 'has_type()', + 'Test all enum values are valid', + 'Test invalid values are rejected', + 'Verify enum usage in tables' + ] + } + ]; } - + /** * Generate test requirements for triggers * @private */ _generateTriggerTests(operation, target, priority) { const sql = (operation.sql || '').toUpperCase(); - + // Route to specific trigger test methods based on operation type if (sql.includes('CREATE EVENT TRIGGER')) { return this._generateEventTriggerTests(operation, target, priority); } - + if (sql.includes('CREATE TRIGGER')) { return this._generateTriggerCreationTests(operation, target, priority); } - + if (sql.includes('ALTER TRIGGER')) { return this._generateTriggerAlterationTests(operation, target, priority); } - + if (sql.includes('DROP TRIGGER')) { return this._generateTriggerDropTests(operation, target, priority); } - + // Fallback for unknown trigger operations - return [{ - type: TEST_TYPES.TRIGGER, - priority, - description: `Verify trigger ${target} functionality`, - target, - testCases: [ - 'has_trigger() - trigger exists', - 'trigger_is() - verify trigger properties', - 'Test trigger fires on correct events', - 'Test trigger function execution', - 'Verify trigger timing (BEFORE/AFTER)', - 'Test trigger with different data scenarios' - ], - metadata: { - testType: 'functionality' + return [ + { + type: TEST_TYPES.TRIGGER, + priority, + description: `Verify trigger ${target} functionality`, + target, + testCases: [ + 'has_trigger() - trigger exists', + 'trigger_is() - verify trigger properties', + 'Test trigger fires on correct events', + 'Test trigger function execution', + 'Verify trigger timing (BEFORE/AFTER)', + 'Test trigger with different data scenarios' + ], + metadata: { + testType: 'functionality' + } } - }]; + ]; } /** @@ -2076,56 +2147,59 @@ class TestRequirementAnalyzer extends EventEmitter { * @private */ _generateGenericTests(operation, target, priority) { - return [{ - type: TEST_TYPES.SCHEMA, - priority: TEST_PRIORITIES.LOW, - description: `Verify operation executed successfully: ${operation.description || 'Unknown operation'}`, - target: target || 'Unknown', - testCases: [ - 'Verify operation completed without errors', - 'Check database state consistency' - ] - }]; + return [ + { + type: TEST_TYPES.SCHEMA, + priority: TEST_PRIORITIES.LOW, + description: `Verify operation executed successfully: ${operation.description || 'Unknown operation'}`, + target: target || 'Unknown', + testCases: ['Verify operation completed without errors', 'Check database state consistency'] + } + ]; } - + /** * Generate security test requirements * @private */ _generateSecurityTests(operation, target, priority) { - return [{ - type: TEST_TYPES.PERMISSION, - priority: TEST_PRIORITIES.CRITICAL, - description: `Verify security implications of ${target} changes`, - target, - testCases: [ - 'Test access control enforcement', - 'Verify unauthorized access is blocked', - 'Test with different user roles', - 'Audit security policy changes' - ] - }]; + return [ + { + type: TEST_TYPES.PERMISSION, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify security implications of ${target} changes`, + target, + testCases: [ + 'Test access control enforcement', + 'Verify unauthorized access is blocked', + 'Test with different user roles', + 'Audit security policy changes' + ] + } + ]; } - + /** * Generate performance test requirements * @private */ _generatePerformanceTests(operation, target, priority) { - return [{ - type: TEST_TYPES.INDEX, - priority: TEST_PRIORITIES.MEDIUM, - description: `Verify performance impact of ${target} changes`, - target, - testCases: [ - 'Measure query performance before/after', - 'Verify indexes are utilized', - 'Check for performance regressions', - 'Test with realistic data volumes' - ] - }]; + return [ + { + type: TEST_TYPES.INDEX, + priority: TEST_PRIORITIES.MEDIUM, + description: `Verify performance impact of ${target} changes`, + target, + testCases: [ + 'Measure query performance before/after', + 'Verify indexes are utilized', + 'Check for performance regressions', + 'Test with realistic data volumes' + ] + } + ]; } - + /** * Generate test requirements for column addition * @private @@ -2133,10 +2207,10 @@ class TestRequirementAnalyzer extends EventEmitter { _generateColumnAdditionTests(operation, tableName, columnName, priority) { const requirements = []; const sql = operation.sql || ''; - + // Extract column metadata from SQL const columnMetadata = this._parseColumnConstraints(sql, columnName); - + requirements.push({ type: TEST_TYPES.SCHEMA, priority, @@ -2161,7 +2235,7 @@ class TestRequirementAnalyzer extends EventEmitter { referencedColumn: columnMetadata.referencedColumn } }); - + // Add constraint tests if applicable if (columnMetadata.hasCheckConstraint) { requirements.push({ @@ -2169,42 +2243,41 @@ class TestRequirementAnalyzer extends EventEmitter { priority, description: `Verify check constraint on ${tableName}.${columnName}`, target: `${tableName}.${columnName}`, - testCases: [ - 'has_check()', - 'check_test()' - ], + testCases: ['has_check()', 'check_test()'], metadata: { checkExpression: columnMetadata.checkExpression } }); } - + return requirements; } - + /** * Generate test requirements for column drops * @private */ _generateColumnDropTests(operation, tableName, columnName, priority) { - return [{ - type: TEST_TYPES.SCHEMA, - priority: TEST_PRIORITIES.CRITICAL, // Always critical for destructive ops - description: `Verify column ${columnName} dropped from ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: [ - 'hasnt_column()', - 'Verify dependent constraints are handled', - 'Verify dependent indexes are handled', - 'Check data integrity after column drop' - ], - metadata: { - destructive: true, - requiresDataValidation: true + return [ + { + type: TEST_TYPES.SCHEMA, + priority: TEST_PRIORITIES.CRITICAL, // Always critical for destructive ops + description: `Verify column ${columnName} dropped from ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: [ + 'hasnt_column()', + 'Verify dependent constraints are handled', + 'Verify dependent indexes are handled', + 'Check data integrity after column drop' + ], + metadata: { + destructive: true, + requiresDataValidation: true + } } - }]; + ]; } - + /** * Generate test requirements for column type changes * @private @@ -2212,10 +2285,10 @@ class TestRequirementAnalyzer extends EventEmitter { _generateColumnTypeChangeTests(operation, tableName, columnName, priority) { const requirements = []; const sql = operation.sql || ''; - + // Extract old and new types from SQL const typeChangeInfo = this._parseTypeChange(sql, columnName); - + requirements.push({ type: TEST_TYPES.SCHEMA, priority: TEST_PRIORITIES.HIGH, @@ -2232,7 +2305,7 @@ class TestRequirementAnalyzer extends EventEmitter { requiresDataMigration: typeChangeInfo.requiresConversion } }); - + // Add data migration tests for incompatible type changes if (typeChangeInfo.requiresConversion) { requirements.push({ @@ -2252,55 +2325,59 @@ class TestRequirementAnalyzer extends EventEmitter { } }); } - + return requirements; } - + /** * Generate test requirements for setting column NOT NULL * @private */ _generateColumnNotNullTests(operation, tableName, columnName, priority) { - return [{ - type: TEST_TYPES.CONSTRAINT, - priority: TEST_PRIORITIES.HIGH, - description: `Verify column ${columnName} NOT NULL constraint in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: [ - 'col_not_null()', - 'Test null insertion rejection', - 'Verify existing data has no nulls', - 'Test constraint enforcement' - ], - metadata: { - constraintType: 'NOT NULL', - requiresDataValidation: true + return [ + { + type: TEST_TYPES.CONSTRAINT, + priority: TEST_PRIORITIES.HIGH, + description: `Verify column ${columnName} NOT NULL constraint in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: [ + 'col_not_null()', + 'Test null insertion rejection', + 'Verify existing data has no nulls', + 'Test constraint enforcement' + ], + metadata: { + constraintType: 'NOT NULL', + requiresDataValidation: true + } } - }]; + ]; } - + /** * Generate test requirements for dropping NOT NULL constraint * @private */ _generateColumnNullableTests(operation, tableName, columnName, priority) { - return [{ - type: TEST_TYPES.CONSTRAINT, - priority, - description: `Verify column ${columnName} nullable constraint removed in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: [ - 'col_is_null() - column allows nulls', - 'Test null insertion acceptance', - 'Verify constraint properly removed' - ], - metadata: { - constraintType: 'NULLABLE', - constraintRemoved: true + return [ + { + type: TEST_TYPES.CONSTRAINT, + priority, + description: `Verify column ${columnName} nullable constraint removed in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: [ + 'col_is_null() - column allows nulls', + 'Test null insertion acceptance', + 'Verify constraint properly removed' + ], + metadata: { + constraintType: 'NULLABLE', + constraintRemoved: true + } } - }]; + ]; } - + /** * Generate test requirements for setting column default * @private @@ -2308,47 +2385,51 @@ class TestRequirementAnalyzer extends EventEmitter { _generateColumnSetDefaultTests(operation, tableName, columnName, priority) { const sql = operation.sql || ''; const defaultValue = this._extractDefaultValue(sql, columnName); - - return [{ - type: TEST_TYPES.CONSTRAINT, - priority, - description: `Verify column ${columnName} default value set in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: [ - 'col_has_default()', - 'col_default_is()', - 'Test default value application on insert', - 'Verify default value type compatibility' - ], - metadata: { - defaultValue, - requiresInsertTest: true + + return [ + { + type: TEST_TYPES.CONSTRAINT, + priority, + description: `Verify column ${columnName} default value set in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: [ + 'col_has_default()', + 'col_default_is()', + 'Test default value application on insert', + 'Verify default value type compatibility' + ], + metadata: { + defaultValue, + requiresInsertTest: true + } } - }]; + ]; } - + /** * Generate test requirements for dropping column default * @private */ _generateColumnDropDefaultTests(operation, tableName, columnName, priority) { - return [{ - type: TEST_TYPES.CONSTRAINT, - priority, - description: `Verify column ${columnName} default value removed in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: [ - 'col_hasnt_default()', - 'Test explicit value requirement on insert', - 'Verify default properly removed' - ], - metadata: { - defaultRemoved: true, - requiresInsertTest: true + return [ + { + type: TEST_TYPES.CONSTRAINT, + priority, + description: `Verify column ${columnName} default value removed in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: [ + 'col_hasnt_default()', + 'Test explicit value requirement on insert', + 'Verify default properly removed' + ], + metadata: { + defaultRemoved: true, + requiresInsertTest: true + } } - }]; + ]; } - + /** * Generate test requirements for constraint additions * @private @@ -2357,96 +2438,92 @@ class TestRequirementAnalyzer extends EventEmitter { const requirements = []; const sql = operation.sql || ''; const constraintType = this._identifyConstraintType(sql); - + switch (constraintType) { - case 'PRIMARY_KEY': - requirements.push({ - type: TEST_TYPES.CONSTRAINT, - priority: TEST_PRIORITIES.CRITICAL, - description: `Verify primary key constraint ${constraintName} on ${tableName}`, - target: `${tableName}.${constraintName}`, - testCases: [ - 'has_pk()', - 'Test uniqueness enforcement', - 'Test null rejection', - 'Verify constraint naming' - ] - }); - break; - - case 'FOREIGN_KEY': - const fkInfo = this._parseForeignKeyConstraint(sql); - requirements.push({ - type: TEST_TYPES.CONSTRAINT, - priority: TEST_PRIORITIES.HIGH, - description: `Verify foreign key constraint ${constraintName} on ${tableName}`, - target: `${tableName}.${constraintName}`, - testCases: [ - 'has_fk()', - 'fk_ok()', - 'Test referential integrity', - 'Test cascade behavior if applicable' - ], - metadata: { - referencedTable: fkInfo.referencedTable, - referencedColumn: fkInfo.referencedColumn, - onDelete: fkInfo.onDelete, - onUpdate: fkInfo.onUpdate - } - }); - break; - - case 'UNIQUE': - requirements.push({ - type: TEST_TYPES.CONSTRAINT, - priority: TEST_PRIORITIES.HIGH, - description: `Verify unique constraint ${constraintName} on ${tableName}`, - target: `${tableName}.${constraintName}`, - testCases: [ - 'has_unique()', - 'Test uniqueness enforcement', - 'Test duplicate rejection', - 'Verify constraint scope' - ] - }); - break; - - case 'CHECK': - const checkExpression = this._extractCheckExpression(sql); - requirements.push({ - type: TEST_TYPES.CONSTRAINT, - priority: TEST_PRIORITIES.HIGH, - description: `Verify check constraint ${constraintName} on ${tableName}`, - target: `${tableName}.${constraintName}`, - testCases: [ - 'has_check()', - 'check_test()', - 'Test constraint violation rejection', - 'Test valid values acceptance' - ], - metadata: { - checkExpression - } - }); - break; - - default: - requirements.push({ - type: TEST_TYPES.CONSTRAINT, - priority, - description: `Verify constraint ${constraintName} on ${tableName}`, - target: `${tableName}.${constraintName}`, - testCases: [ - 'Verify constraint existence', - 'Test constraint enforcement' - ] - }); + case 'PRIMARY_KEY': + requirements.push({ + type: TEST_TYPES.CONSTRAINT, + priority: TEST_PRIORITIES.CRITICAL, + description: `Verify primary key constraint ${constraintName} on ${tableName}`, + target: `${tableName}.${constraintName}`, + testCases: [ + 'has_pk()', + 'Test uniqueness enforcement', + 'Test null rejection', + 'Verify constraint naming' + ] + }); + break; + + case 'FOREIGN_KEY': + const fkInfo = this._parseForeignKeyConstraint(sql); + requirements.push({ + type: TEST_TYPES.CONSTRAINT, + priority: TEST_PRIORITIES.HIGH, + description: `Verify foreign key constraint ${constraintName} on ${tableName}`, + target: `${tableName}.${constraintName}`, + testCases: [ + 'has_fk()', + 'fk_ok()', + 'Test referential integrity', + 'Test cascade behavior if applicable' + ], + metadata: { + referencedTable: fkInfo.referencedTable, + referencedColumn: fkInfo.referencedColumn, + onDelete: fkInfo.onDelete, + onUpdate: fkInfo.onUpdate + } + }); + break; + + case 'UNIQUE': + requirements.push({ + type: TEST_TYPES.CONSTRAINT, + priority: TEST_PRIORITIES.HIGH, + description: `Verify unique constraint ${constraintName} on ${tableName}`, + target: `${tableName}.${constraintName}`, + testCases: [ + 'has_unique()', + 'Test uniqueness enforcement', + 'Test duplicate rejection', + 'Verify constraint scope' + ] + }); + break; + + case 'CHECK': + const checkExpression = this._extractCheckExpression(sql); + requirements.push({ + type: TEST_TYPES.CONSTRAINT, + priority: TEST_PRIORITIES.HIGH, + description: `Verify check constraint ${constraintName} on ${tableName}`, + target: `${tableName}.${constraintName}`, + testCases: [ + 'has_check()', + 'check_test()', + 'Test constraint violation rejection', + 'Test valid values acceptance' + ], + metadata: { + checkExpression + } + }); + break; + + default: + requirements.push({ + type: TEST_TYPES.CONSTRAINT, + priority, + description: `Verify constraint ${constraintName} on ${tableName}`, + target: `${tableName}.${constraintName}`, + testCases: ['Verify constraint existence', 'Test constraint enforcement'] + }); } - + return requirements; } - /** * Generate comprehensive column validation test * This ensures all aspects of a column are properly tested after critical changes @@ -2479,32 +2556,32 @@ class TestRequirementAnalyzer extends EventEmitter { /** * Helper methods for column operation parsing */ - + _extractColumnName(sql, operation) { const patterns = { 'ADD COLUMN': /ADD\s+COLUMN\s+([^\s(]+)/i, 'DROP COLUMN': /DROP\s+COLUMN\s+([^\s,;]+)/i, 'ALTER COLUMN': /ALTER\s+COLUMN\s+([^\s]+)/i }; - + const pattern = patterns[operation]; if (!pattern) return 'unknown_column'; - + const match = sql.match(pattern); return match ? match[1] : 'unknown_column'; } - + _extractConstraintName(sql, operation) { const pattern = /ADD\s+CONSTRAINT\s+([^\s]+)/i; const match = sql.match(pattern); return match ? match[1] : 'unknown_constraint'; } - + _parseColumnConstraints(sql, columnName) { // Extract column definition from SQL - everything after the column name const columnDefPattern = new RegExp(`${columnName}\\s+(.+?)(?:,|$)`, 'i'); const match = sql.match(columnDefPattern); - + if (!match) { return { type: 'unknown', @@ -2515,9 +2592,9 @@ class TestRequirementAnalyzer extends EventEmitter { hasCheckConstraint: false }; } - + const definition = match[1].toUpperCase(); - + return { type: this._extractDataType(definition), notNull: definition.includes('NOT NULL'), @@ -2531,25 +2608,31 @@ class TestRequirementAnalyzer extends EventEmitter { referencedColumn: this._extractReferencedColumn(definition) }; } - + _parseTypeChange(sql, columnName) { // This is simplified - in production you'd want more sophisticated parsing - const typePattern = new RegExp(`ALTER\\s+COLUMN\\s+${columnName}\\s+(?:SET\\s+DATA\\s+)?TYPE\\s+([^\\s,;]+)`, 'i'); + const typePattern = new RegExp( + `ALTER\\s+COLUMN\\s+${columnName}\\s+(?:SET\\s+DATA\\s+)?TYPE\\s+([^\\s,;]+)`, + 'i' + ); const match = sql.match(typePattern); - + return { oldType: 'unknown', // Would need schema introspection newType: match ? match[1] : 'unknown', requiresConversion: true // Conservative assumption }; } - + _extractDefaultValue(sql, columnName) { - const defaultPattern = new RegExp(`ALTER\\s+COLUMN\\s+${columnName}\\s+SET\\s+DEFAULT\\s+([^;,\\s]+(?:\\s*'[^']*')?[^;,]*)`, 'i'); + const defaultPattern = new RegExp( + `ALTER\\s+COLUMN\\s+${columnName}\\s+SET\\s+DEFAULT\\s+([^;,\\s]+(?:\\s*'[^']*')?[^;,]*)`, + 'i' + ); const match = sql.match(defaultPattern); return match ? match[1].trim() : null; } - + _identifyConstraintType(sql) { const upperSql = sql.toUpperCase(); if (upperSql.includes('PRIMARY KEY')) return 'PRIMARY_KEY'; @@ -2558,16 +2641,18 @@ class TestRequirementAnalyzer extends EventEmitter { if (upperSql.includes('CHECK')) return 'CHECK'; return 'UNKNOWN'; } - + _parseForeignKeyConstraint(sql) { const referencesPattern = /REFERENCES\s+([^\s(]+)(?:\s*\(\s*([^)]+)\s*\))?/i; - const onDeletePattern = /ON\s+DELETE\s+(CASCADE|RESTRICT|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION)/i; - const onUpdatePattern = /ON\s+UPDATE\s+(CASCADE|RESTRICT|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION)/i; - + const onDeletePattern = + /ON\s+DELETE\s+(CASCADE|RESTRICT|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION)/i; + const onUpdatePattern = + /ON\s+UPDATE\s+(CASCADE|RESTRICT|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION)/i; + const referencesMatch = sql.match(referencesPattern); const onDeleteMatch = sql.match(onDeletePattern); const onUpdateMatch = sql.match(onUpdatePattern); - + return { referencedTable: referencesMatch ? referencesMatch[1] : null, referencedColumn: referencesMatch ? referencesMatch[2] : null, @@ -2575,37 +2660,37 @@ class TestRequirementAnalyzer extends EventEmitter { onUpdate: onUpdateMatch ? onUpdateMatch[1] : null }; } - + _extractCheckExpression(sql) { const checkPattern = /CHECK\s*\(\s*([^)]+)\s*\)/i; const match = sql.match(checkPattern); return match ? match[1] : null; } - + _extractDataType(definition) { // Extract the data type including size/precision in parentheses const typeMatch = definition.match(/^([^\s]+(?:\([^)]+\))?)/); return typeMatch ? typeMatch[1] : 'unknown'; } - + _extractDefaultFromDefinition(definition) { const defaultPattern = /DEFAULT\s+('[^']*'|[^\s]+)/i; const match = definition.match(defaultPattern); return match ? match[1].trim() : null; } - + _extractCheckFromDefinition(definition) { const checkPattern = /CHECK\s*\(\s*([^)]+)\s*\)/i; const match = definition.match(checkPattern); return match ? match[1] : null; } - + _extractReferencedTable(definition) { const referencesPattern = /REFERENCES\s+([^\s(]+)/i; const match = definition.match(referencesPattern); return match ? match[1] : null; } - + _extractReferencedColumn(definition) { const referencesPattern = /REFERENCES\s+[^\s(]+\s*\(\s*([^)]+)\s*\)/i; const match = definition.match(referencesPattern); @@ -2615,21 +2700,21 @@ class TestRequirementAnalyzer extends EventEmitter { /** * Helper methods */ - + _getBasePriority(operation) { switch (operation.type) { - case 'DESTRUCTIVE': - return this.options.destructiveOperationPriority; - case 'WARNING': - return this.options.warningOperationPriority; - default: - return this.options.safeOperationPriority; + case 'DESTRUCTIVE': + return this.options.destructiveOperationPriority; + case 'WARNING': + return this.options.warningOperationPriority; + default: + return this.options.safeOperationPriority; } } - + _categorizeOperation(operation) { const sql = (operation.sql || '').toUpperCase().trim(); - + if (sql.startsWith('CREATE TABLE')) return 'CREATE_TABLE'; if (sql.startsWith('DROP TABLE')) return 'DROP_TABLE'; if (sql.startsWith('ALTER TABLE')) { @@ -2637,13 +2722,13 @@ class TestRequirementAnalyzer extends EventEmitter { if (sql.includes('DISABLE ROW LEVEL SECURITY')) return 'DISABLE_RLS'; return 'ALTER_TABLE'; } - + // Index operations - all use CREATE_INDEX for main switching, specialized handling in _generateIndexTests if (sql.includes('CREATE UNIQUE INDEX')) return 'CREATE_INDEX'; if (sql.includes('CREATE INDEX')) return 'CREATE_INDEX'; if (sql.includes('DROP INDEX')) return 'CREATE_INDEX'; if (sql.includes('ALTER INDEX')) return 'CREATE_INDEX'; - + // Function operations - all use CREATE_FUNCTION for main switching if (sql.includes('CREATE OR REPLACE FUNCTION')) return 'CREATE_FUNCTION'; if (sql.includes('CREATE FUNCTION')) return 'CREATE_FUNCTION'; @@ -2655,27 +2740,27 @@ class TestRequirementAnalyzer extends EventEmitter { if (sql.includes('DROP POLICY')) return 'DROP_POLICY'; if (sql.includes('CREATE VIEW')) return 'CREATE_VIEW'; if (sql.includes('CREATE TYPE')) return 'CREATE_ENUM'; - + // Trigger operations (check EVENT TRIGGER before TRIGGER to avoid false matches) if (sql.includes('CREATE EVENT TRIGGER')) return 'CREATE_EVENT_TRIGGER'; if (sql.includes('CREATE TRIGGER')) return 'CREATE_TRIGGER'; if (sql.includes('ALTER TRIGGER')) return 'ALTER_TRIGGER'; if (sql.includes('DROP TRIGGER')) return 'DROP_TRIGGER'; - + return 'UNKNOWN'; } - + _extractTargetObject(operation) { const sql = operation.sql || ''; - + // Extract table name let match = sql.match(/(?:CREATE TABLE|DROP TABLE|ALTER TABLE)\s+([^\s(]+)/i); if (match) return match[1]; - + // Extract index name (handles CREATE, DROP, ALTER INDEX) match = sql.match(/(?:CREATE(?:\s+UNIQUE)?\s+INDEX|DROP\s+INDEX|ALTER\s+INDEX)\s+([^\s]+)/i); if (match) return match[1]; - + // Extract function name (handles CREATE, CREATE OR REPLACE, DROP, ALTER) // Handle DROP FUNCTION IF EXISTS specially if (sql.includes('DROP FUNCTION IF EXISTS')) { @@ -2684,73 +2769,74 @@ class TestRequirementAnalyzer extends EventEmitter { } match = sql.match(/(?:CREATE(?:\s+OR\s+REPLACE)?|DROP|ALTER)\s+FUNCTION\s+([^\s(]+)/i); if (match) return match[1]; - + // Extract policy name for CREATE, ALTER, DROP POLICY match = sql.match(/(?:CREATE|ALTER|DROP)\s+POLICY\s+([^\s]+)/i); if (match) return match[1]; - + // Extract view name match = sql.match(/CREATE VIEW\s+([^\s]+)/i); if (match) return match[1]; - + // Extract type name match = sql.match(/CREATE TYPE\s+([^\s]+)/i); if (match) return match[1]; - + // Extract trigger name for CREATE, ALTER, DROP TRIGGER match = sql.match(/(?:CREATE|ALTER|DROP)\s+TRIGGER\s+([^\s]+)/i); if (match) return match[1]; - + // Extract event trigger name match = sql.match(/CREATE\s+EVENT\s+TRIGGER\s+([^\s]+)/i); if (match) return match[1]; - + return 'unknown'; } - + _isHighRiskOperation(operation) { const sql = operation.sql || ''; - return this.highRiskPatterns.some(pattern => pattern.test(sql)) || - operation.type === 'DESTRUCTIVE'; + return ( + this.highRiskPatterns.some((pattern) => pattern.test(sql)) || operation.type === 'DESTRUCTIVE' + ); } - + _requiresSecurityTests(operation) { if (!this.options.requireSecurityTests) return false; - + const sql = operation.sql || ''; - return this.securityPatterns.some(pattern => pattern.test(sql)); + return this.securityPatterns.some((pattern) => pattern.test(sql)); } - + _requiresPerformanceTests(operation) { const sql = operation.sql || ''; return /CREATE.*INDEX|ALTER TABLE.*ADD|VACUUM|ANALYZE/i.test(sql); } - + _estimateTestEffort(requirement) { const baseEffort = this.options.estimatedEffortPerTest; const complexityMultiplier = Math.min(requirement.testCases.length / 3, 3); - + return baseEffort * complexityMultiplier; } - + _generateTestReason(requirement, operation) { switch (requirement.type) { - case TEST_TYPES.SCHEMA: - return 'Ensure schema changes are applied correctly'; - case TEST_TYPES.DATA: - return 'Verify data integrity after migration'; - case TEST_TYPES.CONSTRAINT: - return 'Validate constraint enforcement'; - case TEST_TYPES.RLS: - case TEST_TYPES.PERMISSION: - return 'Critical security validation required'; - case TEST_TYPES.FUNCTION: - return 'Ensure function behavior meets requirements'; - default: - return 'Validate operation completed successfully'; + case TEST_TYPES.SCHEMA: + return 'Ensure schema changes are applied correctly'; + case TEST_TYPES.DATA: + return 'Verify data integrity after migration'; + case TEST_TYPES.CONSTRAINT: + return 'Validate constraint enforcement'; + case TEST_TYPES.RLS: + case TEST_TYPES.PERMISSION: + return 'Critical security validation required'; + case TEST_TYPES.FUNCTION: + return 'Ensure function behavior meets requirements'; + default: + return 'Validate operation completed successfully'; } } - + _generateTestMetadata(requirement, operation, context) { return { operationType: operation.type, @@ -2762,49 +2848,53 @@ class TestRequirementAnalyzer extends EventEmitter { estimatedEffort: this._estimateTestEffort(requirement) }; } - + _extractOperationDescription(operation) { - return operation.description || - operation.sql?.substring(0, 100) + '...' || - 'Unknown operation'; + return operation.description || operation.sql?.substring(0, 100) + '...' || 'Unknown operation'; } - + _generateTestingSuggestions(analysis, operations, context) { const suggestions = []; - + // High-level coverage suggestions if (analysis.summary.totalRequirements === 0) { suggestions.push('No test requirements identified - consider reviewing migration complexity'); } else { suggestions.push(`${analysis.summary.totalRequirements} test requirements identified`); } - + // Priority-based suggestions const criticalTests = analysis.summary.byPriority[TEST_PRIORITIES.CRITICAL] || 0; if (criticalTests > 0) { - suggestions.push(`${criticalTests} critical tests required - these must pass before deployment`); + suggestions.push( + `${criticalTests} critical tests required - these must pass before deployment` + ); } - + // Risk area suggestions if (analysis.riskAreas.length > 0) { - suggestions.push(`${analysis.riskAreas.length} high-risk operations require extra testing attention`); + suggestions.push( + `${analysis.riskAreas.length} high-risk operations require extra testing attention` + ); } - + // Effort estimation if (analysis.estimatedEffort > 8) { suggestions.push('Consider parallelizing test implementation due to high effort estimate'); } - + // Security focus - const securityTests = analysis.summary.byType[TEST_TYPES.RLS] || 0 + - analysis.summary.byType[TEST_TYPES.PERMISSION] || 0; + const securityTests = + analysis.summary.byType[TEST_TYPES.RLS] || + 0 + analysis.summary.byType[TEST_TYPES.PERMISSION] || + 0; if (securityTests > 0) { suggestions.push('Security-related changes detected - prioritize RLS and permission tests'); } - + return suggestions; } - + /** * Generate column test requirements based on operation type * @param {Object} operation - Migration operation @@ -2816,80 +2906,90 @@ class TestRequirementAnalyzer extends EventEmitter { */ generateColumnTestRequirements(operation, tableName, columnName, operationType, priority) { const requirements = []; - + switch (operationType) { - case 'ADD_COLUMN': - requirements.push(...this._generateColumnAdditionTests(operation, tableName, columnName, priority)); - break; - case 'DROP_COLUMN': - requirements.push(...this._generateColumnDropTests(operation, tableName, columnName, priority)); - break; - case 'ALTER_TYPE': - requirements.push(...this._generateColumnTypeChangeTests(operation, tableName, columnName, priority)); - break; - case 'SET_NOT_NULL': - requirements.push(...this._generateColumnNotNullTests(operation, tableName, columnName, priority)); - break; - case 'DROP_NOT_NULL': - requirements.push(...this._generateColumnNullableTests(operation, tableName, columnName, priority)); - break; - case 'SET_DEFAULT': - requirements.push(...this._generateColumnSetDefaultTests(operation, tableName, columnName, priority)); - break; - case 'DROP_DEFAULT': - requirements.push(...this._generateColumnDropDefaultTests(operation, tableName, columnName, priority)); - break; - default: - // Generic column operation test - requirements.push({ - type: TEST_TYPES.SCHEMA, - priority: TEST_PRIORITIES.MEDIUM, - description: `Verify column ${columnName} operation in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: [ - 'has_column()', - `-- Verify column operation completed successfully` - ], - metadata: { - operationType, - tableName, - columnName - } - }); + case 'ADD_COLUMN': + requirements.push( + ...this._generateColumnAdditionTests(operation, tableName, columnName, priority) + ); + break; + case 'DROP_COLUMN': + requirements.push( + ...this._generateColumnDropTests(operation, tableName, columnName, priority) + ); + break; + case 'ALTER_TYPE': + requirements.push( + ...this._generateColumnTypeChangeTests(operation, tableName, columnName, priority) + ); + break; + case 'SET_NOT_NULL': + requirements.push( + ...this._generateColumnNotNullTests(operation, tableName, columnName, priority) + ); + break; + case 'DROP_NOT_NULL': + requirements.push( + ...this._generateColumnNullableTests(operation, tableName, columnName, priority) + ); + break; + case 'SET_DEFAULT': + requirements.push( + ...this._generateColumnSetDefaultTests(operation, tableName, columnName, priority) + ); + break; + case 'DROP_DEFAULT': + requirements.push( + ...this._generateColumnDropDefaultTests(operation, tableName, columnName, priority) + ); + break; + default: + // Generic column operation test + requirements.push({ + type: TEST_TYPES.SCHEMA, + priority: TEST_PRIORITIES.MEDIUM, + description: `Verify column ${columnName} operation in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: ['has_column()', '-- Verify column operation completed successfully'], + metadata: { + operationType, + tableName, + columnName + } + }); } - + return requirements; } - + /** * Generate column addition test requirements * @private */ _generateColumnAdditionTests(operation, tableName, columnName, priority) { const columnMeta = this._parseColumnDefinition(operation.sql, columnName); - const testCases = [ - 'has_column()', - 'col_type_is()', - ]; - + const testCases = ['has_column()', 'col_type_is()']; + if (columnMeta && columnMeta.notNull) { testCases.push('col_not_null()'); } - + if (columnMeta && columnMeta.hasDefault) { testCases.push('col_has_default()'); } - - return [{ - type: TEST_TYPES.SCHEMA, - priority, - description: `Verify column ${columnName} added to ${tableName}`, - target: `${tableName}.${columnName}`, - testCases, - metadata: columnMeta - }]; + + return [ + { + type: TEST_TYPES.SCHEMA, + priority, + description: `Verify column ${columnName} added to ${tableName}`, + target: `${tableName}.${columnName}`, + testCases, + metadata: columnMeta + } + ]; } - + /** * Generate column drop test requirements * @private @@ -2909,14 +3009,11 @@ class TestRequirementAnalyzer extends EventEmitter { priority: TEST_PRIORITIES.HIGH, description: `Comprehensive validation after ${columnName} drop from ${tableName}`, target: tableName, - testCases: [ - '-- Verify table structure integrity', - '-- Check remaining columns are intact' - ] + testCases: ['-- Verify table structure integrity', '-- Check remaining columns are intact'] } ]; } - + /** * Generate column type change test requirements * @private @@ -2935,24 +3032,18 @@ class TestRequirementAnalyzer extends EventEmitter { priority: TEST_PRIORITIES.CRITICAL, description: `Verify data migration for ${columnName} in ${tableName}`, target: `${tableName}.${columnName}`, - testCases: [ - '-- Test data conversion', - '-- Verify no data loss' - ] + testCases: ['-- Test data conversion', '-- Verify no data loss'] }, { type: TEST_TYPES.DATA, priority: TEST_PRIORITIES.HIGH, description: `Comprehensive validation after ${columnName} type change`, target: tableName, - testCases: [ - '-- Check data integrity', - '-- Test edge cases' - ] + testCases: ['-- Check data integrity', '-- Test edge cases'] } ]; } - + /** * Generate NOT NULL constraint test requirements * @private @@ -2970,7 +3061,7 @@ class TestRequirementAnalyzer extends EventEmitter { { type: TEST_TYPES.DATA, priority: TEST_PRIORITIES.HIGH, - description: `Comprehensive validation after NOT NULL constraint`, + description: 'Comprehensive validation after NOT NULL constraint', target: tableName, testCases: [ '-- Verify existing data compatibility', @@ -2979,52 +3070,58 @@ class TestRequirementAnalyzer extends EventEmitter { } ]; } - + /** * Generate nullable constraint test requirements * @private */ _generateColumnNullableTests(operation, tableName, columnName, priority) { - return [{ - type: TEST_TYPES.CONSTRAINT, - priority, - description: `Verify nullable constraint removed from ${columnName} in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: ['col_is_null() - column allows nulls'], - metadata: { constraintRemoved: true } - }]; + return [ + { + type: TEST_TYPES.CONSTRAINT, + priority, + description: `Verify nullable constraint removed from ${columnName} in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: ['col_is_null() - column allows nulls'], + metadata: { constraintRemoved: true } + } + ]; } - + /** * Generate SET DEFAULT test requirements * @private */ _generateColumnSetDefaultTests(operation, tableName, columnName, priority) { - return [{ - type: TEST_TYPES.CONSTRAINT, - priority, - description: `Verify default value set for ${columnName} in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: ['col_has_default()', 'col_default_is()'], - metadata: { requiresInsertTest: true } - }]; + return [ + { + type: TEST_TYPES.CONSTRAINT, + priority, + description: `Verify default value set for ${columnName} in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: ['col_has_default()', 'col_default_is()'], + metadata: { requiresInsertTest: true } + } + ]; } - + /** * Generate DROP DEFAULT test requirements * @private */ _generateColumnDropDefaultTests(operation, tableName, columnName, priority) { - return [{ - type: TEST_TYPES.CONSTRAINT, - priority, - description: `Verify default value removed from ${columnName} in ${tableName}`, - target: `${tableName}.${columnName}`, - testCases: ['col_hasnt_default()'], - metadata: { defaultRemoved: true } - }]; + return [ + { + type: TEST_TYPES.CONSTRAINT, + priority, + description: `Verify default value removed from ${columnName} in ${tableName}`, + target: `${tableName}.${columnName}`, + testCases: ['col_hasnt_default()'], + metadata: { defaultRemoved: true } + } + ]; } - + /** * Extract column name from SQL operation * @private @@ -3035,22 +3132,22 @@ class TestRequirementAnalyzer extends EventEmitter { _extractColumnName(sql, operation) { const upperSql = sql.toUpperCase(); const operationUpper = operation.toUpperCase(); - + const operationIndex = upperSql.indexOf(operationUpper); if (operationIndex === -1) { return 'unknown'; } - + const afterOperation = sql.substring(operationIndex + operation.length).trim(); const parts = afterOperation.split(/\s+/); - + if (parts.length > 0) { return parts[0].replace(/[";,]/g, '').replace(/"/g, ''); } - + return 'unknown'; } - + /** * Extract constraint name from SQL operation * @private @@ -3062,7 +3159,7 @@ class TestRequirementAnalyzer extends EventEmitter { const constraintMatch = sql.match(new RegExp(`${operation}\\s+([^\\s]+)`, 'i')); return constraintMatch ? constraintMatch[1].replace(/"/g, '') : 'unknown'; } - + /** * Identify constraint type from SQL * @private @@ -3071,7 +3168,7 @@ class TestRequirementAnalyzer extends EventEmitter { */ _identifyConstraintType(sql) { const upperSql = sql.toUpperCase(); - + if (upperSql.includes('PRIMARY KEY')) { return 'PRIMARY_KEY'; } else if (upperSql.includes('FOREIGN KEY')) { @@ -3081,15 +3178,15 @@ class TestRequirementAnalyzer extends EventEmitter { } else if (upperSql.includes('CHECK')) { return 'CHECK'; } - + return 'UNKNOWN'; } - + /** * Parse column constraints from SQL (alias for _parseColumnDefinition for test compatibility) * @private * @param {string} sql - SQL statement - * @param {string} columnName - Column name + * @param {string} columnName - Column name * @returns {Object|null} Parsed column information */ _parseColumnConstraints(sql, columnName) { @@ -3111,31 +3208,35 @@ class TestRequirementAnalyzer extends EventEmitter { uniqueConstraints: [], indexes: [] }; - + try { // Extract table definition inside parentheses const tableDefMatch = sql.match(/CREATE TABLE\s+[^\s(]+\s*\(([\s\S]*?)\)(?:\s*;|\s*$)/i); if (!tableDefMatch) { return structure; } - + const tableDef = tableDefMatch[1]; - + // Parse column definitions and constraints const items = this._splitTableItems(tableDef); - + for (const item of items) { const cleanItem = item.trim(); - + if (cleanItem.toUpperCase().startsWith('PRIMARY KEY')) { // Parse primary key constraint const pkMatch = cleanItem.match(/PRIMARY KEY\s*\(\s*([^)]+)\s*\)/i); if (pkMatch) { - structure.primaryKeys = pkMatch[1].split(',').map(col => col.trim().replace(/"/g, '')); + structure.primaryKeys = pkMatch[1] + .split(',') + .map((col) => col.trim().replace(/"/g, '')); } } else if (cleanItem.toUpperCase().startsWith('FOREIGN KEY')) { // Parse foreign key constraint - const fkMatch = cleanItem.match(/FOREIGN KEY\s*\(\s*([^)]+)\s*\)\s*REFERENCES\s+([^\s(]+)\s*\(\s*([^)]+)\s*\)/i); + const fkMatch = cleanItem.match( + /FOREIGN KEY\s*\(\s*([^)]+)\s*\)\s*REFERENCES\s+([^\s(]+)\s*\(\s*([^)]+)\s*\)/i + ); if (fkMatch) { structure.foreignKeys.push({ column: fkMatch[1].trim().replace(/"/g, ''), @@ -3149,7 +3250,7 @@ class TestRequirementAnalyzer extends EventEmitter { if (uniqueMatch) { structure.uniqueConstraints.push({ name: `unique_${uniqueMatch[1] || 'constraint'}`, - columns: uniqueMatch[1] ? uniqueMatch[1].split(',').map(c => c.trim()) : [] + columns: uniqueMatch[1] ? uniqueMatch[1].split(',').map((c) => c.trim()) : [] }); } } else if (cleanItem.toUpperCase().startsWith('CHECK')) { @@ -3167,14 +3268,18 @@ class TestRequirementAnalyzer extends EventEmitter { if (constraintMatch) { const constraintName = constraintMatch[1]; const constraintDef = constraintMatch[2]; - + if (constraintDef.toUpperCase().startsWith('PRIMARY KEY')) { const pkMatch = constraintDef.match(/PRIMARY KEY\s*\(\s*([^)]+)\s*\)/i); if (pkMatch) { - structure.primaryKeys = pkMatch[1].split(',').map(col => col.trim().replace(/"/g, '')); + structure.primaryKeys = pkMatch[1] + .split(',') + .map((col) => col.trim().replace(/"/g, '')); } } else if (constraintDef.toUpperCase().startsWith('FOREIGN KEY')) { - const fkMatch = constraintDef.match(/FOREIGN KEY\s*\(\s*([^)]+)\s*\)\s*REFERENCES\s+([^\s(]+)\s*\(\s*([^)]+)\s*\)/i); + const fkMatch = constraintDef.match( + /FOREIGN KEY\s*\(\s*([^)]+)\s*\)\s*REFERENCES\s+([^\s(]+)\s*\(\s*([^)]+)\s*\)/i + ); if (fkMatch) { structure.foreignKeys.push({ name: constraintName, @@ -3188,7 +3293,7 @@ class TestRequirementAnalyzer extends EventEmitter { if (uniqueMatch) { structure.uniqueConstraints.push({ name: constraintName, - columns: uniqueMatch[1].split(',').map(c => c.trim().replace(/"/g, '')) + columns: uniqueMatch[1].split(',').map((c) => c.trim().replace(/"/g, '')) }); } } else if (constraintDef.toUpperCase().startsWith('CHECK')) { @@ -3209,15 +3314,14 @@ class TestRequirementAnalyzer extends EventEmitter { } } } - } catch (error) { // If parsing fails, return basic structure console.warn('Failed to parse table structure:', error.message); } - + return structure; } - + /** * Parse table alterations from ALTER TABLE SQL * @private @@ -3235,28 +3339,30 @@ class TestRequirementAnalyzer extends EventEmitter { addedConstraints: [], droppedConstraints: [] }; - + try { const upperSql = sql.toUpperCase(); - + // Handle ADD COLUMN - const addColumnRegex = /ADD\s+(?:COLUMN\s+)?([^\s,;]+)\s+([^,;]*?)(?=\s*(?:,|;|$|ADD|DROP|ALTER))/gi; + const addColumnRegex = + /ADD\s+(?:COLUMN\s+)?([^\s,;]+)\s+([^,;]*?)(?=\s*(?:,|;|$|ADD|DROP|ALTER))/gi; let addMatch; while ((addMatch = addColumnRegex.exec(upperSql)) !== null) { const columnName = addMatch[1].replace(/"/g, ''); const columnDef = addMatch[2].trim(); alterations.addedColumns.push(this._parseColumnDefinition(`${columnName} ${columnDef}`)); } - + // Handle DROP COLUMN const dropColumnRegex = /DROP\s+(?:COLUMN\s+)?([^\s,;]+)/gi; let dropMatch; while ((dropMatch = dropColumnRegex.exec(upperSql)) !== null) { alterations.droppedColumns.push(dropMatch[1].replace(/"/g, '')); } - + // Handle ALTER COLUMN TYPE - const alterTypeRegex = /ALTER\s+(?:COLUMN\s+)?([^\s]+)\s+(?:SET\s+DATA\s+)?TYPE\s+([^\s,;]+)/gi; + const alterTypeRegex = + /ALTER\s+(?:COLUMN\s+)?([^\s]+)\s+(?:SET\s+DATA\s+)?TYPE\s+([^\s,;]+)/gi; let alterTypeMatch; while ((alterTypeMatch = alterTypeRegex.exec(upperSql)) !== null) { alterations.alteredColumns.push({ @@ -3265,13 +3371,13 @@ class TestRequirementAnalyzer extends EventEmitter { oldType: 'unknown' // Would need additional context to determine old type }); } - + // Handle RENAME TABLE const renameTableMatch = upperSql.match(/RENAME\s+TO\s+([^\s;]+)/i); if (renameTableMatch) { alterations.renamedTo = renameTableMatch[1].replace(/"/g, ''); } - + // Handle RENAME COLUMN const renameColumnRegex = /RENAME\s+(?:COLUMN\s+)?([^\s]+)\s+TO\s+([^\s,;]+)/gi; let renameColMatch; @@ -3282,24 +3388,27 @@ class TestRequirementAnalyzer extends EventEmitter { type: 'unknown' // Would need additional context to determine type }); } - + // Handle ADD CONSTRAINT - const addConstraintRegex = /ADD\s+(?:CONSTRAINT\s+([^\s]+)\s+)?(PRIMARY\s+KEY|FOREIGN\s+KEY|UNIQUE|CHECK)\s*([^,;]*?)(?=\s*(?:,|;|$|ADD|DROP|ALTER))/gi; + const addConstraintRegex = + /ADD\s+(?:CONSTRAINT\s+([^\s]+)\s+)?(PRIMARY\s+KEY|FOREIGN\s+KEY|UNIQUE|CHECK)\s*([^,;]*?)(?=\s*(?:,|;|$|ADD|DROP|ALTER))/gi; let constraintMatch; while ((constraintMatch = addConstraintRegex.exec(upperSql)) !== null) { const constraintName = constraintMatch[1] || `auto_${Date.now()}`; const constraintType = constraintMatch[2].replace(/\s+/g, ' '); const constraintDef = constraintMatch[3].trim(); - + const constraint = { name: constraintName.replace(/"/g, ''), type: constraintType, definition: constraintDef }; - + // Parse specific constraint details if (constraintType.includes('FOREIGN KEY')) { - const fkMatch = constraintDef.match(/\(\s*([^)]+)\s*\)\s*REFERENCES\s+([^\s(]+)\s*\(\s*([^)]+)\s*\)/i); + const fkMatch = constraintDef.match( + /\(\s*([^)]+)\s*\)\s*REFERENCES\s+([^\s(]+)\s*\(\s*([^)]+)\s*\)/i + ); if (fkMatch) { constraint.column = fkMatch[1].trim().replace(/"/g, ''); constraint.referencedTable = fkMatch[2].trim().replace(/"/g, ''); @@ -3308,13 +3417,13 @@ class TestRequirementAnalyzer extends EventEmitter { } else if (constraintType.includes('PRIMARY KEY')) { const pkMatch = constraintDef.match(/\(\s*([^)]+)\s*\)/i); if (pkMatch) { - constraint.columns = pkMatch[1].split(',').map(col => col.trim().replace(/"/g, '')); + constraint.columns = pkMatch[1].split(',').map((col) => col.trim().replace(/"/g, '')); } } - + alterations.addedConstraints.push(constraint); } - + // Handle DROP CONSTRAINT const dropConstraintRegex = /DROP\s+CONSTRAINT\s+([^\s,;]+)/gi; let dropConstraintMatch; @@ -3323,14 +3432,13 @@ class TestRequirementAnalyzer extends EventEmitter { name: dropConstraintMatch[1].replace(/"/g, '') }); } - } catch (error) { console.warn('Failed to parse table alterations:', error.message); } - + return alterations; } - + /** * Parse individual column definition * @private @@ -3341,23 +3449,23 @@ class TestRequirementAnalyzer extends EventEmitter { if (!columnDef || !columnDef.trim()) { return null; } - + try { const parts = columnDef.trim().split(/\s+/); if (parts.length < 2) { return null; } - + // Handle different SQL formats let nameIndex = null; let typeIndex = 1; - + if (columnName) { // If column name is provided separately, find it in the SQL and get the type after it const upperSql = columnDef.toUpperCase(); const upperColumnName = columnName.toUpperCase(); const columnIndex = upperSql.indexOf(upperColumnName); - + if (columnIndex !== -1) { // Find the position of the column name in the parts array const beforeColumn = columnDef.substring(0, columnIndex); @@ -3387,9 +3495,13 @@ class TestRequirementAnalyzer extends EventEmitter { nameIndex = 0; typeIndex = 1; } - + const column = { - name: columnName || (nameIndex !== null && nameIndex < parts.length ? parts[nameIndex].replace(/"/g, '') : 'unknown'), + name: + columnName || + (nameIndex !== null && nameIndex < parts.length + ? parts[nameIndex].replace(/"/g, '') + : 'unknown'), type: this._parseColumnType(parts, typeIndex), notNull: false, hasDefault: false, @@ -3397,22 +3509,24 @@ class TestRequirementAnalyzer extends EventEmitter { foreignKey: null, isUnique: false }; - + const defString = columnDef.toUpperCase(); - + // Check for NOT NULL column.notNull = defString.includes('NOT NULL'); - + // Check for UNIQUE column.isUnique = defString.includes('UNIQUE'); - + // Check for DEFAULT - more comprehensive pattern, preserve original case - const defaultMatch = columnDef.match(/DEFAULT\s+('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|\d+\.?\d*|[a-zA-Z_][a-zA-Z0-9_]*(?:\([^)]*\))?)/i); + const defaultMatch = columnDef.match( + /DEFAULT\s+('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|\d+\.?\d*|[a-zA-Z_][a-zA-Z0-9_]*(?:\([^)]*\))?)/i + ); if (defaultMatch) { column.hasDefault = true; column.defaultValue = defaultMatch[1]; } - + // Check for inline foreign key reference const referencesMatch = defString.match(/REFERENCES\s+([^\s(]+)(?:\s*\(\s*([^)]+)\s*\))?/i); if (referencesMatch) { @@ -3421,14 +3535,14 @@ class TestRequirementAnalyzer extends EventEmitter { referencedColumn: referencesMatch[2] ? referencesMatch[2].replace(/"/g, '') : 'id' }; } - + return column; } catch (error) { console.warn('Failed to parse column definition:', columnDef, error.message); return null; } } - + /** * Parse column type including size specifications * @private @@ -3440,9 +3554,9 @@ class TestRequirementAnalyzer extends EventEmitter { if (!parts || typeIndex >= parts.length) { return 'UNKNOWN'; } - + let type = parts[typeIndex].toUpperCase(); - + // Check if next part contains size specification if (typeIndex + 1 < parts.length && parts[typeIndex + 1].match(/^\(\d+(?:,\d+)?\)$/)) { type += parts[typeIndex + 1]; @@ -3455,10 +3569,10 @@ class TestRequirementAnalyzer extends EventEmitter { i++; } } - + return type; } - + /** * Split table items (columns and constraints) while respecting parentheses * @private @@ -3471,11 +3585,11 @@ class TestRequirementAnalyzer extends EventEmitter { let parenDepth = 0; let inQuotes = false; let quoteChar = null; - + for (let i = 0; i < tableDef.length; i++) { const char = tableDef[i]; const prevChar = i > 0 ? tableDef[i - 1] : null; - + // Handle quotes if ((char === '"' || char === "'") && prevChar !== '\\') { if (!inQuotes) { @@ -3486,7 +3600,7 @@ class TestRequirementAnalyzer extends EventEmitter { quoteChar = null; } } - + if (!inQuotes) { // Track parentheses depth if (char === '(') { @@ -3502,20 +3616,25 @@ class TestRequirementAnalyzer extends EventEmitter { continue; } } - + current += char; } - + // Add the last item if (current.trim()) { items.push(current.trim()); } - + return items; } _comparePriority(priority1, priority2) { - const priorities = [TEST_PRIORITIES.LOW, TEST_PRIORITIES.MEDIUM, TEST_PRIORITIES.HIGH, TEST_PRIORITIES.CRITICAL]; + const priorities = [ + TEST_PRIORITIES.LOW, + TEST_PRIORITIES.MEDIUM, + TEST_PRIORITIES.HIGH, + TEST_PRIORITIES.CRITICAL + ]; return priorities.indexOf(priority2) - priorities.indexOf(priority1); // Reverse order (highest first) } @@ -3619,7 +3738,10 @@ class TestRequirementAnalyzer extends EventEmitter { } // Performance tests for potentially expensive triggers - if (this.options.requirePerformanceTests && this._isTriggerPerformanceSensitive(triggerDetails)) { + if ( + this.options.requirePerformanceTests && + this._isTriggerPerformanceSensitive(triggerDetails) + ) { requirements.push({ type: TEST_TYPES.INDEX, priority: TEST_PRIORITIES.MEDIUM, @@ -3628,7 +3750,7 @@ class TestRequirementAnalyzer extends EventEmitter { testCases: [ 'Measure operation performance with/without trigger', 'Test trigger performance with large data sets', - 'Verify trigger doesn\'t create deadlocks', + "Verify trigger doesn't create deadlocks", 'Test concurrent operation performance' ], metadata: { @@ -3680,9 +3802,9 @@ class TestRequirementAnalyzer extends EventEmitter { description: `Test trigger ${target} ${isEnabled ? 'enabled' : 'disabled'} state`, target, testCases: [ - isEnabled ? - 'Test trigger fires after being enabled' : - 'Test trigger does not fire when disabled', + isEnabled + ? 'Test trigger fires after being enabled' + : 'Test trigger does not fire when disabled', 'Verify state change is persistent', 'Test operations that should/should not trigger' ], @@ -3792,7 +3914,7 @@ class TestRequirementAnalyzer extends EventEmitter { 'function_returns() - returns event_trigger type', 'Test function handles TG_EVENT correctly', 'Test function accesses pg_event_trigger_ddl_commands()', - 'Verify function error handling doesn\'t block DDL' + "Verify function error handling doesn't block DDL" ], metadata: { isEventTriggerFunction: true, @@ -3812,7 +3934,7 @@ class TestRequirementAnalyzer extends EventEmitter { 'Test CREATE operations trigger the event', 'Test ALTER operations trigger the event', 'Test DROP operations trigger the event', - 'Test event trigger doesn\'t break normal DDL', + "Test event trigger doesn't break normal DDL", 'Test event trigger handles DDL failures gracefully' ], metadata: { @@ -3832,39 +3954,39 @@ class TestRequirementAnalyzer extends EventEmitter { */ _parseTriggerDetails(sql) { const details = {}; - + // Extract table name const tableMatch = sql.match(/ON\s+([^\s]+)/i); details.tableName = tableMatch ? tableMatch[1] : null; - + // Extract function name const functionMatch = sql.match(/EXECUTE\s+(?:PROCEDURE\s+|FUNCTION\s+)?([^\s(]+)/i); details.functionName = functionMatch ? functionMatch[1] : null; - + // Extract timing (BEFORE, AFTER, INSTEAD OF) if (sql.toUpperCase().includes('BEFORE')) details.timing = ['BEFORE']; else if (sql.toUpperCase().includes('AFTER')) details.timing = ['AFTER']; else if (sql.toUpperCase().includes('INSTEAD OF')) details.timing = ['INSTEAD OF']; - + // Extract events details.events = []; if (sql.toUpperCase().includes('INSERT')) details.events.push('INSERT'); if (sql.toUpperCase().includes('UPDATE')) details.events.push('UPDATE'); if (sql.toUpperCase().includes('DELETE')) details.events.push('DELETE'); if (sql.toUpperCase().includes('TRUNCATE')) details.events.push('TRUNCATE'); - + // Extract level details.level = sql.toUpperCase().includes('FOR EACH ROW') ? 'ROW' : 'STATEMENT'; - + // Extract condition const conditionMatch = sql.match(/WHEN\s*\(([^)]+)\)/i); details.condition = conditionMatch ? conditionMatch[1] : null; - + // Check if constraint trigger details.isConstraintTrigger = sql.toUpperCase().includes('CONSTRAINT TRIGGER'); details.deferrable = sql.toUpperCase().includes('DEFERRABLE'); details.initiallyDeferred = sql.toUpperCase().includes('INITIALLY DEFERRED'); - + return details; } @@ -3876,11 +3998,11 @@ class TestRequirementAnalyzer extends EventEmitter { */ _parseEventTriggerDetails(sql) { const details = {}; - + // Extract function name const functionMatch = sql.match(/EXECUTE\s+(?:PROCEDURE\s+|FUNCTION\s+)?([^\s(]+)/i); details.functionName = functionMatch ? functionMatch[1] : null; - + // Extract events const eventMatch = sql.match(/ON\s+([^\s]+)/i); if (eventMatch) { @@ -3888,13 +4010,15 @@ class TestRequirementAnalyzer extends EventEmitter { } else { details.events = ['ddl_command_start']; } - + // Extract filter conditions const filterMatch = sql.match(/WHEN\s+TAG\s+IN\s*\(([^)]+)\)/i); if (filterMatch) { - details.filterConditions = filterMatch[1].split(',').map(tag => tag.trim().replace(/'/g, '')); + details.filterConditions = filterMatch[1] + .split(',') + .map((tag) => tag.trim().replace(/'/g, '')); } - + return details; } @@ -3906,15 +4030,15 @@ class TestRequirementAnalyzer extends EventEmitter { */ _generateTriggerBehaviorTests(triggerDetails) { const scenarios = []; - + // Generate scenarios based on events - (triggerDetails.events || []).forEach(event => { + (triggerDetails.events || []).forEach((event) => { scenarios.push({ scenario: `Test ${event} operation fires trigger`, operation: event, expectedResult: 'Trigger function executes and modifies data as expected' }); - + if (triggerDetails.condition) { scenarios.push({ scenario: `Test ${event} with condition evaluation`, @@ -3923,7 +4047,7 @@ class TestRequirementAnalyzer extends EventEmitter { }); } }); - + // Add timing-specific scenarios if (triggerDetails.timing && triggerDetails.timing.includes('BEFORE')) { scenarios.push({ @@ -3932,7 +4056,7 @@ class TestRequirementAnalyzer extends EventEmitter { expectedResult: 'Operation is prevented when trigger returns NULL' }); } - + // Add level-specific scenarios if (triggerDetails.level === 'ROW') { scenarios.push({ @@ -3947,7 +4071,7 @@ class TestRequirementAnalyzer extends EventEmitter { expectedResult: 'Trigger executes once regardless of rows affected' }); } - + return scenarios; } @@ -3973,20 +4097,23 @@ class TestRequirementAnalyzer extends EventEmitter { */ _isTriggerPerformanceSensitive(triggerDetails) { // Row-level triggers on high-frequency operations are performance sensitive - if (triggerDetails.level === 'ROW' && - triggerDetails.events && - (triggerDetails.events.includes('INSERT') || - triggerDetails.events.includes('UPDATE'))) { + if ( + triggerDetails.level === 'ROW' && + triggerDetails.events && + (triggerDetails.events.includes('INSERT') || triggerDetails.events.includes('UPDATE')) + ) { return true; } - + // Complex trigger functions may be performance sensitive - if (triggerDetails.functionName && - (triggerDetails.functionName.includes('complex') || - triggerDetails.functionName.includes('heavy'))) { + if ( + triggerDetails.functionName && + (triggerDetails.functionName.includes('complex') || + triggerDetails.functionName.includes('heavy')) + ) { return true; } - + return false; } @@ -3994,7 +4121,7 @@ class TestRequirementAnalyzer extends EventEmitter { * Aggregate test requirements from multiple operations * Combines requirements by target object, merges duplicates intelligently, * resolves priority conflicts, and generates summary statistics - * + * * @param {Array>} requirementsList - Array of requirement arrays from multiple operations * @returns {Object} Aggregated requirements with deduplication and statistics */ @@ -4020,7 +4147,7 @@ class TestRequirementAnalyzer extends EventEmitter { // Flatten all requirements into a single array const allRequirements = requirementsList.flat(); const totalOriginalCount = allRequirements.length; - + // Track aggregation state const aggregationState = { targetGroups: new Map(), @@ -4046,13 +4173,13 @@ class TestRequirementAnalyzer extends EventEmitter { // Generate summary statistics const summary = this._generateAggregationSummary( - aggregatedRequirements, + aggregatedRequirements, requirementsList.length, totalOriginalCount, aggregationState.duplicatesRemoved ); - this.emit('progress', { + this.emit('progress', { message: `Aggregation complete: ${totalOriginalCount} โ†’ ${aggregatedRequirements.length} requirements` }); @@ -4072,11 +4199,11 @@ class TestRequirementAnalyzer extends EventEmitter { for (const requirement of allRequirements) { const target = requirement.target || 'unknown'; const targetKey = `${target}:${requirement.type}`; - + if (!aggregationState.targetGroups.has(targetKey)) { aggregationState.targetGroups.set(targetKey, []); } - + aggregationState.targetGroups.get(targetKey).push(requirement); // Track related objects (tables + indexes + policies) @@ -4103,7 +4230,7 @@ class TestRequirementAnalyzer extends EventEmitter { } const objectInfo = aggregationState.relatedObjects.get(target); - + // Track operations affecting this object if (requirement.metadata?.operationType) { objectInfo.operations.add(requirement.metadata.operationType); @@ -4122,7 +4249,9 @@ class TestRequirementAnalyzer extends EventEmitter { if (requirement.metadata.referencedTable) { objectInfo.dependencies.add(requirement.metadata.referencedTable); this._ensureRelatedObject(requirement.metadata.referencedTable, 'TABLE', aggregationState); - aggregationState.relatedObjects.get(requirement.metadata.referencedTable).dependents.add(target); + aggregationState.relatedObjects + .get(requirement.metadata.referencedTable) + .dependents.add(target); } // Policy -> Table relationship @@ -4218,8 +4347,8 @@ class TestRequirementAnalyzer extends EventEmitter { // Similar descriptions (basic keyword matching) const desc1Keywords = this._extractDescriptionKeywords(req1.description); const desc2Keywords = this._extractDescriptionKeywords(req2.description); - const commonKeywords = desc1Keywords.filter(k => desc2Keywords.includes(k)); - + const commonKeywords = desc1Keywords.filter((k) => desc2Keywords.includes(k)); + // At least 50% keyword overlap return commonKeywords.length >= Math.max(desc1Keywords.length, desc2Keywords.length) * 0.5; } @@ -4229,9 +4358,14 @@ class TestRequirementAnalyzer extends EventEmitter { * @private */ _extractDescriptionKeywords(description) { - return description.toLowerCase() + return description + .toLowerCase() .split(/\s+/) - .filter(word => word.length > 3 && !['verify', 'test', 'check', 'with', 'that', 'this', 'table'].includes(word)); + .filter( + (word) => + word.length > 3 && + !['verify', 'test', 'check', 'with', 'that', 'this', 'table'].includes(word) + ); } /** @@ -4240,23 +4374,23 @@ class TestRequirementAnalyzer extends EventEmitter { */ _mergeRequirementGroup(group) { const base = group[0]; - + // Take highest priority - const priority = this._getHighestPriority(group.map(r => r.priority)); - + const priority = this._getHighestPriority(group.map((r) => r.priority)); + // Merge test cases (deduplicate) const allTestCases = new Set(); - group.forEach(req => { + group.forEach((req) => { if (req.testCases) { - req.testCases.forEach(testCase => allTestCases.add(testCase)); + req.testCases.forEach((testCase) => allTestCases.add(testCase)); } }); // Merge metadata - const mergedMetadata = this._mergeMetadata(group.map(r => r.metadata).filter(Boolean)); + const mergedMetadata = this._mergeMetadata(group.map((r) => r.metadata).filter(Boolean)); // Combine operations - const operations = group.map(r => r.operation).filter(Boolean); + const operations = group.map((r) => r.operation).filter(Boolean); return { type: base.type, @@ -4267,7 +4401,7 @@ class TestRequirementAnalyzer extends EventEmitter { metadata: { ...mergedMetadata, mergedFrom: group.length, - originalDescriptions: group.map(r => r.description) + originalDescriptions: group.map((r) => r.description) }, operations, reason: this._generateMergedReason(group) @@ -4279,8 +4413,13 @@ class TestRequirementAnalyzer extends EventEmitter { * @private */ _getHighestPriority(priorities) { - const priorityOrder = [TEST_PRIORITIES.LOW, TEST_PRIORITIES.MEDIUM, TEST_PRIORITIES.HIGH, TEST_PRIORITIES.CRITICAL]; - + const priorityOrder = [ + TEST_PRIORITIES.LOW, + TEST_PRIORITIES.MEDIUM, + TEST_PRIORITIES.HIGH, + TEST_PRIORITIES.CRITICAL + ]; + return priorities.reduce((highest, current) => { const currentIndex = priorityOrder.indexOf(current); const highestIndex = priorityOrder.indexOf(highest); @@ -4294,9 +4433,9 @@ class TestRequirementAnalyzer extends EventEmitter { */ _mergeMetadata(metadataArray) { if (metadataArray.length === 0) return {}; - + const merged = {}; - + for (const metadata of metadataArray) { for (const [key, value] of Object.entries(metadata)) { if (merged[key] === undefined) { @@ -4306,13 +4445,13 @@ class TestRequirementAnalyzer extends EventEmitter { merged[key] = [...new Set([...merged[key], ...value])]; } else if (merged[key] !== value) { // Handle conflicts by creating arrays - merged[key] = Array.isArray(merged[key]) + merged[key] = Array.isArray(merged[key]) ? [...new Set([...merged[key], value])] : [...new Set([merged[key], value])]; } } } - + return merged; } @@ -4322,10 +4461,10 @@ class TestRequirementAnalyzer extends EventEmitter { */ _generateMergedDescription(group) { if (group.length === 1) return group[0].description; - + const target = group[0].target; const type = group[0].type.toLowerCase(); - + return `Comprehensive ${type} validation for ${target} (merged from ${group.length} requirements)`; } @@ -4334,12 +4473,12 @@ class TestRequirementAnalyzer extends EventEmitter { * @private */ _generateMergedReason(group) { - const reasons = group.map(r => r.reason).filter(Boolean); + const reasons = group.map((r) => r.reason).filter(Boolean); if (reasons.length === 0) return undefined; - + const uniqueReasons = [...new Set(reasons)]; - return uniqueReasons.length === 1 - ? uniqueReasons[0] + return uniqueReasons.length === 1 + ? uniqueReasons[0] : `Multiple requirements: ${uniqueReasons.join('; ')}`; } @@ -4351,9 +4490,9 @@ class TestRequirementAnalyzer extends EventEmitter { for (const [objectName, objectInfo] of aggregationState.relatedObjects) { // Look for operations that might cascade const cascadingOps = ['DROP', 'RENAME', 'ALTER']; - + for (const operation of objectInfo.operations) { - if (cascadingOps.some(op => operation.toUpperCase().includes(op))) { + if (cascadingOps.some((op) => operation.toUpperCase().includes(op))) { // Check if this affects dependent objects for (const dependent of objectInfo.dependents) { aggregationState.cascadingChanges.push({ @@ -4374,7 +4513,7 @@ class TestRequirementAnalyzer extends EventEmitter { */ _assessCascadingImpact(operation, objectType) { const upperOp = operation.toUpperCase(); - + if (upperOp.includes('DROP')) { return objectType === 'TABLE' ? 'HIGH' : 'MEDIUM'; } else if (upperOp.includes('RENAME')) { @@ -4382,7 +4521,7 @@ class TestRequirementAnalyzer extends EventEmitter { } else if (upperOp.includes('ALTER')) { return 'LOW'; } - + return 'LOW'; } @@ -4409,9 +4548,19 @@ class TestRequirementAnalyzer extends EventEmitter { for (const [targetKey, requirements] of aggregationState.targetGroups) { if (targetKey.startsWith(`${target}:`)) { for (const req of requirements) { - const currentPriorityIndex = [TEST_PRIORITIES.LOW, TEST_PRIORITIES.MEDIUM, TEST_PRIORITIES.HIGH, TEST_PRIORITIES.CRITICAL].indexOf(req.priority); - const minPriorityIndex = [TEST_PRIORITIES.LOW, TEST_PRIORITIES.MEDIUM, TEST_PRIORITIES.HIGH, TEST_PRIORITIES.CRITICAL].indexOf(minPriority); - + const currentPriorityIndex = [ + TEST_PRIORITIES.LOW, + TEST_PRIORITIES.MEDIUM, + TEST_PRIORITIES.HIGH, + TEST_PRIORITIES.CRITICAL + ].indexOf(req.priority); + const minPriorityIndex = [ + TEST_PRIORITIES.LOW, + TEST_PRIORITIES.MEDIUM, + TEST_PRIORITIES.HIGH, + TEST_PRIORITIES.CRITICAL + ].indexOf(minPriority); + if (currentPriorityIndex < minPriorityIndex) { req.priority = minPriority; req.metadata = req.metadata || {}; @@ -4429,16 +4578,16 @@ class TestRequirementAnalyzer extends EventEmitter { */ _extractAggregatedRequirements(aggregationState) { const requirements = []; - + for (const [_targetKey, targetRequirements] of aggregationState.targetGroups) { requirements.push(...targetRequirements); } - + // Sort by priority (highest first), then by target return requirements.sort((a, b) => { const priorityComparison = this._comparePriority(a.priority, b.priority); if (priorityComparison !== 0) return priorityComparison; - + return (a.target || '').localeCompare(b.target || ''); }); } @@ -4447,18 +4596,23 @@ class TestRequirementAnalyzer extends EventEmitter { * Generate summary statistics for aggregation * @private */ - _generateAggregationSummary(aggregatedRequirements, operationCount, originalCount, duplicatesRemoved) { + _generateAggregationSummary( + aggregatedRequirements, + operationCount, + originalCount, + duplicatesRemoved + ) { const priorityDistribution = {}; const typeDistribution = {}; const targetCoverage = {}; - + for (const req of aggregatedRequirements) { // Priority distribution priorityDistribution[req.priority] = (priorityDistribution[req.priority] || 0) + 1; - + // Type distribution typeDistribution[req.type] = (typeDistribution[req.type] || 0) + 1; - + // Target coverage if (req.target) { targetCoverage[req.target] = (targetCoverage[req.target] || 0) + 1; @@ -4470,21 +4624,25 @@ class TestRequirementAnalyzer extends EventEmitter { totalOperations: operationCount, originalRequirements: originalCount, duplicatesRemoved, - deduplicationRate: originalCount > 0 ? ((duplicatesRemoved / originalCount) * 100).toFixed(1) : 0, + deduplicationRate: + originalCount > 0 ? ((duplicatesRemoved / originalCount) * 100).toFixed(1) : 0, priorityDistribution, typeDistribution, targetCoverage, - estimatedEffort: aggregatedRequirements.reduce((sum, req) => sum + this._estimateTestEffort(req), 0), - criticalRequirements: aggregatedRequirements.filter(r => r.priority === TEST_PRIORITIES.CRITICAL).length, - highPriorityRequirements: aggregatedRequirements.filter(r => r.priority === TEST_PRIORITIES.HIGH).length, + estimatedEffort: aggregatedRequirements.reduce( + (sum, req) => sum + this._estimateTestEffort(req), + 0 + ), + criticalRequirements: aggregatedRequirements.filter( + (r) => r.priority === TEST_PRIORITIES.CRITICAL + ).length, + highPriorityRequirements: aggregatedRequirements.filter( + (r) => r.priority === TEST_PRIORITIES.HIGH + ).length, coverageAreas: Object.keys(typeDistribution).length, uniqueTargets: Object.keys(targetCoverage).length }; } } -module.exports = { - TestRequirementAnalyzer, - TEST_TYPES, - TEST_PRIORITIES -}; \ No newline at end of file +export { TestRequirementAnalyzer, TEST_TYPES, TEST_PRIORITIES }; diff --git a/src/lib/testing/TestRequirementSchema.js b/starfleet/data-core/src/testing/TestRequirementSchema.js similarity index 99% rename from src/lib/testing/TestRequirementSchema.js rename to starfleet/data-core/src/testing/TestRequirementSchema.js index 9c84725..414fc3a 100644 --- a/src/lib/testing/TestRequirementSchema.js +++ b/starfleet/data-core/src/testing/TestRequirementSchema.js @@ -1,10 +1,10 @@ /** * Test Requirement Schema - JSDoc Type Definitions - * + * * This file defines comprehensive type schemas for test coverage enforcement * in the D.A.T.A. project. These types are used throughout the test coverage * analysis and enforcement system to ensure pgTAP test completeness. - * + * * @fileoverview JSDoc type definitions for test requirements and coverage analysis */ @@ -310,16 +310,16 @@ */ // Export all types for use in other modules -module.exports = { +export { // Type validation helpers - these are runtime functions, not types - + /** * Validate a test requirement object * @param {any} requirement - Object to validate * @returns {boolean} True if valid TestRequirement */ isValidTestRequirement(requirement) { - return requirement && + return requirement && typeof requirement === 'object' && typeof requirement.id === 'string' && typeof requirement.objectType === 'string' && @@ -386,12 +386,12 @@ module.exports = { medium: 20, low: 10 }; - + const baseScore = priorityWeights[gap.priority] || 10; const missingAssertionsWeight = Math.min(gap.missingAssertions.length * 5, 30); const typeWeight = gap.objectType === 'function' || gap.objectType === 'policy' ? 20 : 10; const criticalPathBonus = gap.metadata?.isCriticalPath ? 10 : 0; - + return Math.min(baseScore + missingAssertionsWeight + typeWeight + criticalPathBonus, 100); }, @@ -405,7 +405,7 @@ module.exports = { DEFAULT_PRIORITY: 'medium', DEFAULT_SCHEMA: 'public', - + PRIORITY_LEVELS: ['critical', 'high', 'medium', 'low'], OBJECT_TYPES: ['table', 'column', 'function', 'index', 'policy', 'trigger', 'schema', 'view', 'constraint'] -}; \ No newline at end of file +}; diff --git a/starfleet/data-core/src/testing/patterns/data-validation.js b/starfleet/data-core/src/testing/patterns/data-validation.js new file mode 100644 index 0000000..58d58cc --- /dev/null +++ b/starfleet/data-core/src/testing/patterns/data-validation.js @@ -0,0 +1,204 @@ +/** + * @fileoverview Data validation pgTAP test patterns + * Pure data structures - no I/O, no dependencies + */ + +export const dataPatterns = [ + { + id: 'table_exists', + category: 'structure', + description: 'Verify table exists', + placeholders: ['schema', 'table'], + template: ` + SELECT plan(1); + SELECT has_table('{{schema}}', '{{table}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'column_exists', + category: 'structure', + description: 'Verify column exists in table', + placeholders: ['schema', 'table', 'column'], + template: ` + SELECT plan(1); + SELECT has_column('{{schema}}', '{{table}}', '{{column}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'column_type_check', + category: 'structure', + description: 'Verify column has correct type', + placeholders: ['schema', 'table', 'column', 'type'], + template: ` + SELECT plan(1); + SELECT col_type_is('{{schema}}', '{{table}}', '{{column}}', '{{type}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'not_null_constraint', + category: 'constraint', + description: 'Verify column has NOT NULL constraint', + placeholders: ['schema', 'table', 'column'], + template: ` + SELECT plan(1); + SELECT col_not_null('{{schema}}', '{{table}}', '{{column}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'default_value_check', + category: 'constraint', + description: 'Verify column has default value', + placeholders: ['schema', 'table', 'column', 'default_value'], + template: ` + SELECT plan(2); + SELECT col_has_default('{{schema}}', '{{table}}', '{{column}}'); + SELECT col_default_is('{{schema}}', '{{table}}', '{{column}}', {{default_value}}); + SELECT finish(); + `, + difficulty: 'intermediate' + }, + + { + id: 'primary_key_check', + category: 'constraint', + description: 'Verify primary key exists', + placeholders: ['schema', 'table', 'columns'], + template: ` + SELECT plan(2); + SELECT has_pk('{{schema}}', '{{table}}'); + SELECT col_is_pk('{{schema}}', '{{table}}', ARRAY[{{columns}}]); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'foreign_key_check', + category: 'constraint', + description: 'Verify foreign key relationship', + placeholders: ['schema', 'table', 'column', 'ref_schema', 'ref_table', 'ref_column'], + template: ` + SELECT plan(2); + SELECT has_fk('{{schema}}', '{{table}}', '{{column}}'); + SELECT fk_ok( + '{{schema}}', '{{table}}', '{{column}}', + '{{ref_schema}}', '{{ref_table}}', '{{ref_column}}' + ); + SELECT finish(); + `, + difficulty: 'intermediate' + }, + + { + id: 'unique_constraint_check', + category: 'constraint', + description: 'Verify unique constraint exists', + placeholders: ['schema', 'table', 'constraint_name'], + template: ` + SELECT plan(1); + SELECT has_unique('{{schema}}', '{{table}}', '{{constraint_name}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'check_constraint_validation', + category: 'constraint', + description: 'Verify check constraint exists and works', + placeholders: ['schema', 'table', 'constraint_name', 'valid_insert', 'invalid_insert'], + template: ` + SELECT plan(3); + SELECT has_check('{{schema}}', '{{table}}', '{{constraint_name}}'); + + -- Test valid data passes + SELECT lives_ok( + '{{valid_insert}}', + 'Valid data passes check constraint' + ); + + -- Test invalid data fails + SELECT throws_ok( + '{{invalid_insert}}', + '23514', + 'new row for relation', + 'Invalid data violates check constraint' + ); + + SELECT finish(); + `, + difficulty: 'advanced', + bestPractices: ['Test both valid and invalid cases for constraints'] + }, + + { + id: 'data_type_conversion_test', + category: 'data', + description: 'Test data type conversion after ALTER COLUMN TYPE', + placeholders: ['schema', 'table', 'column', 'old_type', 'new_type'], + template: ` + SELECT plan(3); + + -- Verify new type + SELECT col_type_is('{{schema}}', '{{table}}', '{{column}}', '{{new_type}}'); + + -- Test data integrity + SELECT is( + (SELECT COUNT(*) FROM {{schema}}.{{table}} WHERE {{column}} IS NOT NULL), + (SELECT COUNT(*) FROM {{schema}}.{{table}}), + 'No NULL values introduced during type conversion' + ); + + -- Test data validity + SELECT ok( + NOT EXISTS ( + SELECT 1 FROM {{schema}}.{{table}} + WHERE pg_typeof({{column}})::text != '{{new_type}}' + ), + 'All values successfully converted to {{new_type}}' + ); + + SELECT finish(); + `, + difficulty: 'advanced' + }, + + { + id: 'cascade_delete_test', + category: 'data', + description: 'Test CASCADE delete behavior', + placeholders: ['parent_table', 'child_table', 'parent_id', 'child_fk_column'], + template: ` + SELECT plan(2); + + -- Insert test data + INSERT INTO {{parent_table}} (id) VALUES ({{parent_id}}); + INSERT INTO {{child_table}} ({{child_fk_column}}) VALUES ({{parent_id}}); + + -- Delete parent and verify cascade + DELETE FROM {{parent_table}} WHERE id = {{parent_id}}; + + SELECT is( + (SELECT COUNT(*) FROM {{child_table}} WHERE {{child_fk_column}} = {{parent_id}}), + 0::bigint, + 'Child records deleted via CASCADE' + ); + + SELECT finish(); + `, + difficulty: 'intermediate', + bestPractices: ['Always test CASCADE behavior with actual data'] + } +]; diff --git a/starfleet/data-core/src/testing/patterns/index.js b/starfleet/data-core/src/testing/patterns/index.js new file mode 100644 index 0000000..d1b2966 --- /dev/null +++ b/starfleet/data-core/src/testing/patterns/index.js @@ -0,0 +1,49 @@ +/** + * @fileoverview Central registry of all pgTAP test patterns + * Pure data - no I/O, no dependencies + */ + +import { securityPatterns } from './security.js'; +import { dataPatterns } from './data-validation.js'; +import { performancePatterns } from './performance.js'; + +/** + * Complete pattern library + * @type {Array} + */ +export const PATTERNS = [...securityPatterns, ...dataPatterns, ...performancePatterns]; + +/** + * Get patterns by category + * @param {string} category - Category name + * @returns {Array} Filtered patterns + */ +export function getPatternsByCategory(category) { + return PATTERNS.filter((p) => p.category === category); +} + +/** + * Get pattern by ID + * @param {string} id - Pattern ID + * @returns {Object|undefined} Pattern or undefined + */ +export function getPatternById(id) { + return PATTERNS.find((p) => p.id === id); +} + +/** + * Get all categories + * @returns {Array} Unique category names + */ +export function getCategories() { + return [...new Set(PATTERNS.map((p) => p.category))]; +} + +/** + * Get patterns by difficulty + * @param {string} difficulty - basic, intermediate, or advanced + * @returns {Array} Filtered patterns + */ +export function getPatternsByDifficulty(difficulty) { + return PATTERNS.filter((p) => p.difficulty === difficulty); +} diff --git a/starfleet/data-core/src/testing/patterns/performance.js b/starfleet/data-core/src/testing/patterns/performance.js new file mode 100644 index 0000000..3c986e9 --- /dev/null +++ b/starfleet/data-core/src/testing/patterns/performance.js @@ -0,0 +1,203 @@ +/** + * @fileoverview Performance testing pgTAP patterns + * Pure data structures - no I/O, no dependencies + */ + +export const performancePatterns = [ + { + id: 'index_exists', + category: 'performance', + description: 'Verify index exists on table', + placeholders: ['schema', 'table', 'index_name'], + template: ` + SELECT plan(1); + SELECT has_index('{{schema}}', '{{table}}', '{{index_name}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'index_type_check', + category: 'performance', + description: 'Verify index has correct type', + placeholders: ['schema', 'table', 'index_name', 'index_type'], + template: ` + SELECT plan(1); + SELECT index_is_type('{{schema}}', '{{table}}', '{{index_name}}', '{{index_type}}'); + SELECT finish(); + `, + difficulty: 'intermediate' + }, + + { + id: 'query_plan_uses_index', + category: 'performance', + description: 'Verify query uses specific index', + placeholders: ['query', 'index_name'], + template: ` + SELECT plan(1); + + -- Get execution plan + CREATE TEMP TABLE plan_output AS + EXPLAIN (FORMAT JSON) {{query}}; + + -- Check for index usage + SELECT ok( + EXISTS ( + SELECT 1 FROM plan_output, + json_array_elements(plan_output::json -> 0 -> 'Plan' -> 'Plans') as subplan + WHERE subplan::text LIKE '%{{index_name}}%' + ), + 'Query uses index {{index_name}}' + ); + + DROP TABLE plan_output; + SELECT finish(); + `, + difficulty: 'advanced', + bestPractices: ['Always clean up temp tables', 'Consider ANALYZE before testing plans'] + }, + + { + id: 'execution_time_threshold', + category: 'performance', + description: 'Verify query executes within time threshold', + placeholders: ['query', 'max_ms'], + template: ` + SELECT plan(1); + + DO $$ + DECLARE + start_time timestamp; + end_time timestamp; + exec_time_ms numeric; + BEGIN + start_time := clock_timestamp(); + EXECUTE '{{query}}'; + end_time := clock_timestamp(); + + exec_time_ms := EXTRACT(MILLISECONDS FROM (end_time - start_time)); + + PERFORM ok( + exec_time_ms < {{max_ms}}, + format('Query executes in < {{max_ms}}ms (actual: %sms)', exec_time_ms) + ); + END $$; + + SELECT finish(); + `, + difficulty: 'advanced', + bestPractices: ['Run multiple times to account for caching', 'Use realistic data volumes'] + }, + + { + id: 'table_size_check', + category: 'performance', + description: 'Monitor table size for performance implications', + placeholders: ['schema', 'table', 'max_size_mb'], + template: ` + SELECT plan(1); + + SELECT ok( + pg_relation_size('{{schema}}.{{table}}') / 1024 / 1024 < {{max_size_mb}}, + format('Table {{table}} is under {{max_size_mb}}MB (actual: %sMB)', + pg_relation_size('{{schema}}.{{table}}') / 1024 / 1024) + ); + + SELECT finish(); + `, + difficulty: 'intermediate' + }, + + { + id: 'vacuum_analyze_status', + category: 'performance', + description: 'Check table vacuum and analyze status', + placeholders: ['schema', 'table', 'max_days_old'], + template: ` + SELECT plan(2); + + -- Check last vacuum + SELECT ok( + COALESCE( + EXTRACT(DAYS FROM (now() - last_vacuum)) < {{max_days_old}}, + false + ), + 'Table vacuumed within {{max_days_old}} days' + ) + FROM pg_stat_user_tables + WHERE schemaname = '{{schema}}' AND tablename = '{{table}}'; + + -- Check last analyze + SELECT ok( + COALESCE( + EXTRACT(DAYS FROM (now() - last_analyze)) < {{max_days_old}}, + false + ), + 'Table analyzed within {{max_days_old}} days' + ) + FROM pg_stat_user_tables + WHERE schemaname = '{{schema}}' AND tablename = '{{table}}'; + + SELECT finish(); + `, + difficulty: 'intermediate', + bestPractices: ['Regular VACUUM and ANALYZE are critical for performance'] + }, + + { + id: 'concurrent_access_test', + category: 'performance', + description: 'Test performance under concurrent access', + placeholders: ['schema', 'table', 'operation', 'concurrent_sessions'], + template: ` + SELECT plan(1); + + -- Note: This is a simplified pattern. Real concurrent testing + -- typically requires external tooling like pgbench + + SELECT ok( + true, + 'Concurrent access test placeholder - use pgbench for real testing' + ); + + -- Suggested pgbench command: + -- pgbench -c {{concurrent_sessions}} -t 100 -f script.sql + + SELECT finish(); + `, + difficulty: 'advanced', + bestPractices: ['Use pgbench or similar for real concurrent testing'] + }, + + { + id: 'index_bloat_check', + category: 'performance', + description: 'Check for index bloat', + placeholders: ['schema', 'index_name', 'max_bloat_ratio'], + template: ` + SELECT plan(1); + + WITH index_bloat AS ( + SELECT + schemaname, + tablename, + indexname, + pg_relation_size(indexrelid) AS index_size, + pg_relation_size(indexrelid) - pg_relation_size(indexrelid, 'main') AS bloat_size + FROM pg_stat_user_indexes + WHERE schemaname = '{{schema}}' AND indexname = '{{index_name}}' + ) + SELECT ok( + COALESCE(bloat_size::numeric / NULLIF(index_size, 0) < {{max_bloat_ratio}}, true), + format('Index bloat under {{max_bloat_ratio}} (actual: %s)', + ROUND(bloat_size::numeric / NULLIF(index_size, 0), 2)) + ) + FROM index_bloat; + + SELECT finish(); + `, + difficulty: 'advanced' + } +]; diff --git a/starfleet/data-core/src/testing/patterns/security.js b/starfleet/data-core/src/testing/patterns/security.js new file mode 100644 index 0000000..0d2e733 --- /dev/null +++ b/starfleet/data-core/src/testing/patterns/security.js @@ -0,0 +1,163 @@ +/** + * @fileoverview Security-related pgTAP test patterns + * Pure data structures - no I/O, no dependencies + */ + +export const securityPatterns = [ + { + id: 'rls_enablement_check', + category: 'security', + description: 'Verify RLS is enabled on a table', + placeholders: ['schema', 'table'], + template: ` + SELECT plan(1); + SELECT is_rls_enabled('{{schema}}.{{table}}'); + SELECT finish(); + `, + difficulty: 'basic', + bestPractices: ['Always verify RLS is enabled before testing policies'] + }, + + { + id: 'policy_exists', + category: 'security', + description: 'Verify a specific RLS policy exists', + placeholders: ['schema', 'table', 'policy_name'], + template: ` + SELECT plan(1); + SELECT policy_exists('{{schema}}.{{table}}', '{{policy_name}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'policy_cmd_verification', + category: 'security', + description: 'Verify policy applies to correct commands', + placeholders: ['schema', 'table', 'policy_name', 'commands'], + template: ` + SELECT plan(1); + SELECT policy_cmd_is('{{schema}}.{{table}}', '{{policy_name}}', ARRAY[{{commands}}]); + SELECT finish(); + `, + difficulty: 'intermediate' + }, + + { + id: 'role_based_access', + category: 'security', + description: 'Test data visibility for specific role', + placeholders: ['role', 'schema', 'table', 'expected_count'], + template: ` + SELECT plan(2); + SET ROLE {{role}}; + SELECT results_eq( + 'SELECT COUNT(*) FROM {{schema}}.{{table}}', + 'SELECT {{expected_count}}::bigint', + 'Role {{role}} sees expected row count' + ); + RESET ROLE; + SELECT finish(); + `, + difficulty: 'intermediate', + bestPractices: ['Always RESET ROLE after testing'] + }, + + { + id: 'privilege_escalation_test', + category: 'security', + description: 'Test that role cannot escalate privileges', + placeholders: ['role', 'schema', 'table', 'forbidden_operation'], + template: ` + SELECT plan(1); + SET ROLE {{role}}; + SELECT throws_ok( + '{{forbidden_operation}}', + '42501', + 'permission denied', + 'Role {{role}} cannot perform forbidden operation' + ); + RESET ROLE; + SELECT finish(); + `, + difficulty: 'advanced', + bestPractices: ['Test both positive and negative cases for permissions'] + }, + + { + id: 'security_definer_validation', + category: 'security', + description: 'Verify function runs with definer privileges', + placeholders: ['schema', 'function_name'], + template: ` + SELECT plan(1); + SELECT is_definer('{{schema}}.{{function_name}}'); + SELECT finish(); + `, + difficulty: 'basic' + }, + + { + id: 'multi_role_data_isolation', + category: 'security', + description: 'Test data isolation between different roles', + placeholders: ['role1', 'role2', 'schema', 'table'], + template: ` + SELECT plan(2); + + -- Test role1 data + SET ROLE {{role1}}; + CREATE TEMP TABLE role1_data AS + SELECT * FROM {{schema}}.{{table}}; + RESET ROLE; + + -- Test role2 data + SET ROLE {{role2}}; + CREATE TEMP TABLE role2_data AS + SELECT * FROM {{schema}}.{{table}}; + RESET ROLE; + + -- Verify isolation + SELECT isnt( + 'SELECT * FROM role1_data', + 'SELECT * FROM role2_data', + 'Data is properly isolated between roles' + ); + + DROP TABLE role1_data, role2_data; + SELECT finish(); + `, + difficulty: 'advanced', + bestPractices: ['Clean up temp tables after testing'] + }, + + { + id: 'service_role_bypass', + category: 'security', + description: 'Verify service_role bypasses RLS', + placeholders: ['schema', 'table'], + template: ` + SELECT plan(2); + + -- Count as service_role + SET ROLE service_role; + SELECT ok( + (SELECT COUNT(*) FROM {{schema}}.{{table}}) > 0, + 'service_role can access all data' + ); + RESET ROLE; + + -- Count as anon (should be restricted) + SET ROLE anon; + SELECT ok( + (SELECT COUNT(*) FROM {{schema}}.{{table}}) >= 0, + 'anon role access is restricted by RLS' + ); + RESET ROLE; + + SELECT finish(); + `, + difficulty: 'intermediate' + } +]; diff --git a/starfleet/data-core/src/testing/render/renderPattern.js b/starfleet/data-core/src/testing/render/renderPattern.js new file mode 100644 index 0000000..9b176da --- /dev/null +++ b/starfleet/data-core/src/testing/render/renderPattern.js @@ -0,0 +1,155 @@ +/** + * @fileoverview Pure pattern rendering functions + * No I/O, no side effects - just string manipulation + */ + +/** + * Render a pattern template with variables + * @param {string} patternId - Pattern identifier + * @param {Object} vars - Variables to interpolate + * @param {Array} registry - Pattern registry (defaults to PATTERNS) + * @returns {string} Rendered SQL + * @throws {Error} If pattern not found or missing variables + */ +export function renderPattern(patternId, vars, registry) { + const pattern = registry.find((p) => p.id === patternId); + + if (!pattern) { + throw new Error(`Unknown pattern: ${patternId}`); + } + + // Check all required placeholders are provided + for (const placeholder of pattern.placeholders || []) { + if (!(placeholder in vars)) { + throw new Error(`Missing variable for pattern ${patternId}: ${placeholder}`); + } + } + + // Replace placeholders with values + return (pattern.template || '').replace(/\{\{(\w+)\}\}/g, (match, key) => { + if (key in vars) { + return String(vars[key]); + } + // If not in vars but also not in placeholders, leave as-is + return match; + }); +} + +/** + * Get recommended patterns for a test type + * @param {string} testType - Type from TEST_TYPES + * @returns {Array} Pattern IDs + */ +export function getRecommendedPatterns(testType) { + const recommendations = { + SCHEMA: ['table_exists', 'column_exists', 'column_type_check'], + CONSTRAINT: [ + 'not_null_constraint', + 'primary_key_check', + 'foreign_key_check', + 'unique_constraint_check' + ], + INDEX: ['index_exists', 'index_type_check', 'query_plan_uses_index'], + RLS: ['rls_enablement_check', 'policy_exists', 'role_based_access'], + PERMISSION: ['role_based_access', 'privilege_escalation_test', 'multi_role_data_isolation'], + FUNCTION: ['security_definer_validation'], + DATA: ['data_type_conversion_test', 'cascade_delete_test'], + VIEW: ['table_exists'], // Views can reuse table existence pattern + TRIGGER: [], // No specific patterns yet + ENUM: [] // No specific patterns yet + }; + + return recommendations[testType] || []; +} + +/** + * Generate enhanced template with recommended patterns + * @param {Object} requirement - Test requirement object + * @param {Array} extraPatternIds - Additional pattern IDs to include + * @param {Array} registry - Pattern registry + * @returns {Object} { sql: string, metadata: Object } + */ +export function generateEnhancedTemplate(requirement, extraPatternIds = [], registry) { + const recommendedIds = getRecommendedPatterns(requirement.type); + const allIds = [...new Set([...recommendedIds, ...extraPatternIds])]; + + const chunks = []; + const usedPatterns = []; + + for (const patternId of allIds) { + try { + const rendered = renderPattern(patternId, requirement.vars || {}, registry); + chunks.push(`-- Pattern: ${patternId}\n${rendered}`); + usedPatterns.push(patternId); + } catch (error) { + // Skip patterns that can't be rendered (missing vars) + console.warn(`Skipping pattern ${patternId}: ${error.message}`); + } + } + + return { + sql: chunks.join('\n\n'), + metadata: { + patternsUsed: usedPatterns, + testType: requirement.type, + target: requirement.target + } + }; +} + +/** + * Validate pattern structure + * @param {Object} pattern - Pattern to validate + * @returns {Array} Validation errors (empty if valid) + */ +export function validatePattern(pattern) { + const errors = []; + + if (!pattern.id) { + errors.push('Pattern missing required field: id'); + } + + if (!pattern.category) { + errors.push('Pattern missing required field: category'); + } + + if (!pattern.template) { + errors.push('Pattern missing required field: template'); + } + + if (!pattern.difficulty) { + errors.push('Pattern missing required field: difficulty'); + } + + const validDifficulties = ['basic', 'intermediate', 'advanced']; + if (pattern.difficulty && !validDifficulties.includes(pattern.difficulty)) { + errors.push( + `Invalid difficulty: ${pattern.difficulty}. Must be one of: ${validDifficulties.join(', ')}` + ); + } + + // Check that placeholders in template match declared placeholders + if (pattern.template && pattern.placeholders) { + const templateVars = new Set(); + const regex = /\{\{(\w+)\}\}/g; + let match; + + while ((match = regex.exec(pattern.template)) !== null) { + templateVars.add(match[1]); + } + + for (const declared of pattern.placeholders) { + if (!templateVars.has(declared)) { + errors.push(`Declared placeholder '${declared}' not used in template`); + } + } + + for (const used of templateVars) { + if (!pattern.placeholders.includes(used)) { + errors.push(`Template uses undeclared placeholder '${used}'`); + } + } + } + + return errors; +} diff --git a/starfleet/data-host-node/.eslintrc.js b/starfleet/data-host-node/.eslintrc.js new file mode 100644 index 0000000..82d1582 --- /dev/null +++ b/starfleet/data-host-node/.eslintrc.js @@ -0,0 +1,41 @@ +/** + * ESLint configuration for data-host-node + * Node adapters can use Node.js built-ins + */ + +module.exports = { + env: { + es2022: true, + node: true // Host layer CAN use Node + }, + parserOptions: { + ecmaVersion: 2022, + sourceType: 'module' + }, + rules: { + // Host-node should not import from CLI + 'no-restricted-imports': [ + 'error', + { + patterns: [ + '@starfleet/data-cli/*' // Host cannot import from CLI layer + ] + } + ], + + // Async/await best practices + 'require-await': 'error', + 'no-return-await': 'error', + + // General code quality + 'no-unused-vars': [ + 'error', + { + argsIgnorePattern: '^_', + varsIgnorePattern: '^_' + } + ], + 'prefer-const': 'error', + 'no-var': 'error' + } +}; diff --git a/starfleet/data-host-node/adapters/CryptoAdapter.js b/starfleet/data-host-node/adapters/CryptoAdapter.js new file mode 100644 index 0000000..d8b4971 --- /dev/null +++ b/starfleet/data-host-node/adapters/CryptoAdapter.js @@ -0,0 +1,124 @@ +import { createHash, createHmac, randomBytes, timingSafeEqual } from 'crypto'; +import { CryptoPort } from '../../data-core/ports/index.js'; + +/** + * Node.js implementation of the Crypto port. + * Wraps Node.js crypto APIs to provide standardized cryptographic operations. + * + * @class CryptoAdapter + */ +export class CryptoAdapter extends CryptoPort { + /** + * Create a new CryptoAdapter instance. + * + * @param {Object} options - Configuration options + * @param {string} [options.defaultAlgorithm='sha256'] - Default hash algorithm + * @param {string} [options.encoding='hex'] - Default output encoding + */ + constructor(options = {}) { + super(); + this.defaultAlgorithm = options.defaultAlgorithm || 'sha256'; + this.encoding = options.encoding || 'hex'; + } + + /** + * Generate hash of data. + * + * @param {Buffer|Uint8Array|string} data - Data to hash + * @param {string} [algorithm] - Hash algorithm override + * @param {string} [encoding] - Output encoding override + * @returns {string} Hex-encoded hash + * @throws {CryptoError} When hashing fails + */ + hash(data, algorithm, encoding) { + try { + const hashAlgorithm = algorithm || this.defaultAlgorithm; + const outputEncoding = encoding || this.encoding; + + const hash = createHash(hashAlgorithm); + hash.update(data); + return hash.digest(outputEncoding); + } catch (error) { + throw this._normalizeError(error, 'hash', { algorithm, data: typeof data }); + } + } + + /** + * Generate HMAC of data with a key. + * + * @param {string} key - Secret key + * @param {Buffer|Uint8Array|string} data - Data to sign + * @param {string} [algorithm] - Hash algorithm + * @param {string} [encoding] - Output encoding + * @returns {string} HMAC signature + * @throws {CryptoError} When HMAC generation fails + */ + hmac(key, data, algorithm, encoding) { + try { + const hashAlgorithm = algorithm || this.defaultAlgorithm; + const outputEncoding = encoding || this.encoding; + + const hmac = createHmac(hashAlgorithm, key); + hmac.update(data); + return hmac.digest(outputEncoding); + } catch (error) { + throw this._normalizeError(error, 'hmac', { algorithm, data: typeof data }); + } + } + + /** + * Generate random bytes. + * + * @param {number} size - Number of bytes to generate + * @param {string} [encoding] - Output encoding (defaults to Buffer) + * @returns {Buffer|string} Random bytes + * @throws {CryptoError} When random generation fails + */ + randomBytes(size, encoding) { + try { + const bytes = randomBytes(size); + return encoding ? bytes.toString(encoding) : bytes; + } catch (error) { + throw this._normalizeError(error, 'randomBytes', { size, encoding }); + } + } + + /** + * Compare two values in constant time to prevent timing attacks. + * + * @param {Buffer|Uint8Array} a - First value + * @param {Buffer|Uint8Array} b - Second value + * @returns {boolean} True if values are equal + * @throws {CryptoError} When comparison fails + */ + timingSafeEqual(a, b) { + try { + return timingSafeEqual(a, b); + } catch (error) { + throw this._normalizeError(error, 'timingSafeEqual', { + aLength: a.length, + bLength: b.length + }); + } + } + + /** + * Normalize crypto errors into consistent format. + * + * @private + * @param {Error} error - Original error + * @param {string} operation - Operation that failed + * @param {Object} context - Operation context + * @returns {CryptoError} Normalized error + */ + _normalizeError(error, operation, context = {}) { + const normalizedError = new Error(`Crypto ${operation} failed: ${error.message}`); + normalizedError.name = 'CryptoError'; + normalizedError.code = error.code; + normalizedError.operation = operation; + normalizedError.context = context; + normalizedError.originalError = error; + + return normalizedError; + } +} diff --git a/starfleet/data-host-node/adapters/EnvironmentAdapter.js b/starfleet/data-host-node/adapters/EnvironmentAdapter.js new file mode 100644 index 0000000..0405ab0 --- /dev/null +++ b/starfleet/data-host-node/adapters/EnvironmentAdapter.js @@ -0,0 +1,314 @@ +import { EnvironmentPort } from '../../data-core/ports/index.js'; + +/** + * Node.js implementation of the Environment port. + * Wraps process.env and related APIs to provide standardized environment access. + * + * @class EnvironmentAdapter + */ +export class EnvironmentAdapter extends EnvironmentPort { + /** + * Create a new EnvironmentAdapter instance. + * + * @param {Object} options - Configuration options + * @param {Object} [options.defaults={}] - Default environment variables + * @param {string} [options.prefix=''] - Prefix for scoped variable access + * @param {boolean} [options.caseSensitive=true] - Case sensitive variable names + */ + constructor(options = {}) { + super(); + this.defaults = options.defaults || {}; + this.prefix = options.prefix || ''; + this.caseSensitive = options.caseSensitive !== false; + this._cache = new Map(); + } + + /** + * Get an environment variable value. + * + * @param {string} key - Environment variable name + * @param {string} [defaultValue] - Default value if not found + * @returns {string|undefined} Environment variable value + */ + get(key, defaultValue) { + const normalizedKey = this._normalizeKey(key); + const cacheKey = `get:${normalizedKey}`; + + if (this._cache.has(cacheKey)) { + const cached = this._cache.get(cacheKey); + return cached !== undefined ? cached : defaultValue; + } + + const value = process.env[normalizedKey] || this.defaults[key] || this.defaults[normalizedKey]; + this._cache.set(cacheKey, value); + + return value !== undefined ? value : defaultValue; + } + + /** + * Set an environment variable value. + * + * @param {string} key - Environment variable name + * @param {string} value - Value to set + * @returns {boolean} True if value was set successfully + */ + set(key, value) { + try { + const normalizedKey = this._normalizeKey(key); + process.env[normalizedKey] = String(value); + + // Clear cache for this key + this._cache.delete(`get:${normalizedKey}`); + this._cache.delete(`has:${normalizedKey}`); + + return true; + } catch (error) { + return false; + } + } + + /** + * Check if an environment variable exists. + * + * @param {string} key - Environment variable name + * @returns {boolean} True if variable exists + */ + has(key) { + const normalizedKey = this._normalizeKey(key); + const cacheKey = `has:${normalizedKey}`; + + if (this._cache.has(cacheKey)) { + return this._cache.get(cacheKey); + } + + const exists = + normalizedKey in process.env || key in this.defaults || normalizedKey in this.defaults; + + this._cache.set(cacheKey, exists); + return exists; + } + + /** + * Delete an environment variable. + * + * @param {string} key - Environment variable name + * @returns {boolean} True if variable was deleted + */ + delete(key) { + try { + const normalizedKey = this._normalizeKey(key); + const existed = normalizedKey in process.env; + + delete process.env[normalizedKey]; + + // Clear cache for this key + this._cache.delete(`get:${normalizedKey}`); + this._cache.delete(`has:${normalizedKey}`); + + return existed; + } catch (error) { + return false; + } + } + + /** + * Get all environment variables with optional prefix filtering. + * + * @param {string} [prefix] - Filter by prefix (uses instance prefix if not provided) + * @returns {Object} Object containing matching environment variables + */ + getAll(prefix) { + const filterPrefix = prefix !== undefined ? prefix : this.prefix; + const result = {}; + + // Get from process.env + for (const [key, value] of Object.entries(process.env)) { + if (!filterPrefix || key.startsWith(filterPrefix)) { + const displayKey = filterPrefix ? key.slice(filterPrefix.length) : key; + result[displayKey] = value; + } + } + + // Merge defaults + for (const [key, value] of Object.entries(this.defaults)) { + const prefixedKey = filterPrefix ? `${filterPrefix}${key}` : key; + const displayKey = + filterPrefix && key.startsWith(filterPrefix) ? key.slice(filterPrefix.length) : key; + + if (!filterPrefix || prefixedKey.startsWith(filterPrefix)) { + if (!(prefixedKey in process.env)) { + result[displayKey] = value; + } + } + } + + return result; + } + + /** + * Get environment variable as specific type. + * + * @param {string} key - Environment variable name + * @param {'string'|'number'|'boolean'|'json'} type - Target type + * @param {*} [defaultValue] - Default value if not found or conversion fails + * @returns {*} Typed environment variable value + * @throws {EnvironmentError} When type conversion fails and no default provided + */ + getTyped(key, type, defaultValue) { + const value = this.get(key); + + if (value === undefined) { + if (defaultValue !== undefined) return defaultValue; + throw this._createError(`Environment variable "${key}" not found`, key); + } + + try { + switch (type) { + case 'string': + return String(value); + + case 'number': { + const num = Number(value); + if (isNaN(num)) throw new Error(`Cannot convert "${value}" to number`); + return num; + } + + case 'boolean': { + const lower = String(value).toLowerCase(); + if (['true', '1', 'yes', 'on'].includes(lower)) return true; + if (['false', '0', 'no', 'off', ''].includes(lower)) return false; + throw new Error(`Cannot convert "${value}" to boolean`); + } + + case 'json': + return JSON.parse(value); + + default: + throw new Error(`Unsupported type: ${type}`); + } + } catch (error) { + if (defaultValue !== undefined) return defaultValue; + throw this._createError( + `Failed to convert environment variable "${key}" to ${type}: ${error.message}`, + key, + error + ); + } + } + + /** + * Get required environment variable (throws if not found). + * + * @param {string} key - Environment variable name + * @param {'string'|'number'|'boolean'|'json'} [type='string'] - Target type + * @returns {*} Environment variable value + * @throws {EnvironmentError} When variable not found or conversion fails + */ + getRequired(key, type = 'string') { + if (!this.has(key)) { + throw this._createError(`Required environment variable "${key}" not found`, key); + } + + return this.getTyped(key, type); + } + + /** + * Expand environment variables in a string (${VAR} or $VAR syntax). + * + * @param {string} template - Template string with variables + * @param {Object} [options] - Expansion options + * @param {boolean} [options.throwOnMissing=false] - Throw if variable not found + * @returns {string} Expanded string + * @throws {EnvironmentError} When variable not found and throwOnMissing is true + */ + expand(template, options = {}) { + const throwOnMissing = options.throwOnMissing || false; + + return String(template).replace( + /\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, + (match, braced, unbraced) => { + const varName = braced || unbraced; + const value = this.get(varName); + + if (value === undefined) { + if (throwOnMissing) { + throw this._createError( + `Environment variable "${varName}" not found during expansion`, + varName + ); + } + return match; // Return original if not found and not throwing + } + + return value; + } + ); + } + + /** + * Clear internal cache. + * + * @returns {number} Number of cached items cleared + */ + clearCache() { + const size = this._cache.size; + this._cache.clear(); + return size; + } + + /** + * Get current platform information. + * + * @returns {PlatformInfo} Platform and process information + */ + getPlatformInfo() { + return { + platform: process.platform, + arch: process.arch, + version: process.version, + pid: process.pid, + ppid: process.ppid, + cwd: process.cwd(), + execPath: process.execPath, + nodeEnv: this.get('NODE_ENV', 'development'), + isProduction: this.get('NODE_ENV') === 'production', + isDevelopment: this.get('NODE_ENV') === 'development', + isTest: this.get('NODE_ENV') === 'test' + }; + } + + /** + * Normalize environment variable key based on configuration. + * + * @private + * @param {string} key - Original key + * @returns {string} Normalized key + */ + _normalizeKey(key) { + let normalized = this.prefix ? `${this.prefix}${key}` : key; + + if (!this.caseSensitive) { + normalized = normalized.toUpperCase(); + } + + return normalized; + } + + /** + * Create normalized environment error. + * + * @private + * @param {string} message - Error message + * @param {string} key - Environment variable key + * @param {Error} [originalError] - Original error if any + * @returns {EnvironmentError} Normalized error + */ + _createError(message, key, originalError = null) { + const error = new Error(message); + error.name = 'EnvironmentError'; + error.key = key; + error.originalError = originalError; + + return error; + } +} diff --git a/starfleet/data-host-node/adapters/FileSystemAdapter.js b/starfleet/data-host-node/adapters/FileSystemAdapter.js new file mode 100644 index 0000000..f79c438 --- /dev/null +++ b/starfleet/data-host-node/adapters/FileSystemAdapter.js @@ -0,0 +1,226 @@ +import { promises as fs, constants } from 'fs'; +import { dirname, resolve } from 'path'; +import { FileSystemPort } from '../../data-core/ports/index.js'; + +/** + * Node.js implementation of the FileSystem port. + * Wraps fs/promises APIs to provide standardized file system operations. + * + * @class FileSystemAdapter + */ +export class FileSystemAdapter extends FileSystemPort { + /** + * Create a new FileSystemAdapter instance. + * + * @param {Object} options - Configuration options + * @param {string} [options.encoding='utf8'] - Default file encoding + * @param {number} [options.mode=0o644] - Default file creation mode + */ + constructor(options = {}) { + super(); + this.encoding = options.encoding || 'utf8'; + this.defaultMode = options.mode || 0o644; + } + + /** + * Read file contents as text. + * + * @param {string} filePath - Path to the file + * @param {Object} [options] - Read options + * @param {string} [options.encoding] - File encoding override + * @returns {Promise} File contents + * @throws {FileSystemError} When file cannot be read + */ + async readFile(filePath, options = {}) { + try { + const encoding = options.encoding || this.encoding; + return fs.readFile(resolve(filePath), { encoding }); + } catch (error) { + throw this._normalizeError(error, 'readFile', filePath); + } + } + + /** + * Write text content to file. + * + * @param {string} filePath - Path to the file + * @param {string} content - Content to write + * @param {Object} [options] - Write options + * @param {string} [options.encoding] - File encoding override + * @param {number} [options.mode] - File creation mode override + * @returns {Promise} + * @throws {FileSystemError} When file cannot be written + */ + async writeFile(filePath, content, options = {}) { + try { + const encoding = options.encoding || this.encoding; + const mode = options.mode || this.defaultMode; + + // Ensure directory exists + await this.ensureDir(dirname(filePath)); + + return fs.writeFile(resolve(filePath), content, { encoding, mode }); + } catch (error) { + throw this._normalizeError(error, 'writeFile', filePath); + } + } + + /** + * Check if file or directory exists. + * + * @param {string} path - Path to check + * @returns {Promise} True if path exists + */ + async exists(path) { + try { + await fs.access(resolve(path), constants.F_OK); + return true; + } catch { + return false; + } + } + + /** + * Get file or directory stats. + * + * @param {string} path - Path to stat + * @returns {Promise} Stat information with normalized properties + * @throws {FileSystemError} When path cannot be accessed + */ + async stat(path) { + try { + const stats = await fs.stat(resolve(path)); + return { + isFile: stats.isFile(), + isDirectory: stats.isDirectory(), + size: stats.size, + mtime: stats.mtime, + ctime: stats.ctime, + mode: stats.mode + }; + } catch (error) { + throw this._normalizeError(error, 'stat', path); + } + } + + /** + * Create directory recursively. + * + * @param {string} dirPath - Directory path to create + * @param {Object} [options] - Creation options + * @param {number} [options.mode] - Directory creation mode + * @returns {Promise} + * @throws {FileSystemError} When directory cannot be created + */ + async ensureDir(dirPath, options = {}) { + try { + const mode = options.mode || 0o755; + await fs.mkdir(resolve(dirPath), { recursive: true, mode }); + } catch (error) { + throw this._normalizeError(error, 'ensureDir', dirPath); + } + } + + /** + * Remove file or directory. + * + * @param {string} path - Path to remove + * @param {Object} [options] - Removal options + * @param {boolean} [options.recursive=false] - Remove directories recursively + * @returns {Promise} + * @throws {FileSystemError} When path cannot be removed + */ + async remove(path, options = {}) { + try { + const resolvedPath = resolve(path); + const stats = await this.stat(resolvedPath); + + if (stats.isDirectory) { + if (options.recursive) { + await fs.rm(resolvedPath, { recursive: true, force: true }); + } else { + await fs.rmdir(resolvedPath); + } + } else { + await fs.unlink(resolvedPath); + } + } catch (error) { + throw this._normalizeError(error, 'remove', path); + } + } + + /** + * List directory contents. + * + * @param {string} dirPath - Directory path + * @param {Object} [options] - List options + * @param {boolean} [options.withFileTypes=false] - Return file type info + * @returns {Promise>} Directory entries + * @throws {FileSystemError} When directory cannot be read + */ + async readDir(dirPath, options = {}) { + try { + const resolvedPath = resolve(dirPath); + + if (options.withFileTypes) { + const entries = await fs.readdir(resolvedPath, { withFileTypes: true }); + return entries.map((entry) => ({ + name: entry.name, + isFile: entry.isFile(), + isDirectory: entry.isDirectory() + })); + } else { + return fs.readdir(resolvedPath); + } + } catch (error) { + throw this._normalizeError(error, 'readDir', dirPath); + } + } + + /** + * Copy file or directory. + * + * @param {string} src - Source path + * @param {string} dest - Destination path + * @param {Object} [options] - Copy options + * @param {boolean} [options.recursive=false] - Copy directories recursively + * @returns {Promise} + * @throws {FileSystemError} When copy operation fails + */ + async copy(src, dest, options = {}) { + try { + const srcPath = resolve(src); + const destPath = resolve(dest); + + await fs.cp(srcPath, destPath, { + recursive: options.recursive || false, + force: true, + preserveTimestamps: true + }); + } catch (error) { + throw this._normalizeError(error, 'copy', `${src} -> ${dest}`); + } + } + + /** + * Normalize file system errors into consistent format. + * + * @private + * @param {Error} error - Original error + * @param {string} operation - Operation that failed + * @param {string} path - Path involved in operation + * @returns {FileSystemError} Normalized error + */ + _normalizeError(error, operation, path) { + const normalizedError = new Error( + `FileSystem ${operation} failed for "${path}": ${error.message}` + ); + normalizedError.name = 'FileSystemError'; + normalizedError.code = error.code; + normalizedError.operation = operation; + normalizedError.path = path; + normalizedError.originalError = error; + + return normalizedError; + } +} diff --git a/starfleet/data-host-node/adapters/GlobAdapter.js b/starfleet/data-host-node/adapters/GlobAdapter.js new file mode 100644 index 0000000..11df237 --- /dev/null +++ b/starfleet/data-host-node/adapters/GlobAdapter.js @@ -0,0 +1,291 @@ +import { glob } from 'glob'; +import { resolve, relative, isAbsolute } from 'path'; +import minimatch from 'minimatch'; + +/** + * Node.js implementation of the Glob port. + * Provides file pattern matching and globbing functionality. + * + * @class GlobAdapter + */ +export class GlobAdapter { + /** + * Create a new GlobAdapter instance. + * + * @param {Object} options - Configuration options + * @param {string} [options.cwd] - Default working directory + * @param {boolean} [options.absolute=false] - Return absolute paths by default + * @param {boolean} [options.followSymlinks=false] - Follow symbolic links + * @param {boolean} [options.caseSensitive] - Case sensitive matching (OS default) + * @param {Array} [options.ignore=[]] - Default ignore patterns + */ + constructor(options = {}) { + this.defaultCwd = options.cwd || process.cwd(); + this.defaultAbsolute = options.absolute || false; + this.followSymlinks = options.followSymlinks || false; + this.caseSensitive = options.caseSensitive; + this.defaultIgnore = options.ignore || []; + } + + /** + * Find files matching a glob pattern. + * + * @param {string} pattern - Glob pattern to match + * @param {Object} [options] - Globbing options + * @param {string} [options.cwd] - Working directory override + * @param {boolean} [options.absolute] - Return absolute paths + * @param {boolean} [options.onlyFiles=true] - Only return files (not directories) + * @param {boolean} [options.onlyDirectories=false] - Only return directories + * @param {Array} [options.ignore] - Additional ignore patterns + * @param {number} [options.maxDepth] - Maximum directory depth + * @returns {Promise>} Array of matching file paths + * @throws {GlobError} When pattern matching fails + */ + async find(pattern, options = {}) { + try { + const globOptions = this._buildGlobOptions(options); + + const matches = await glob(pattern, globOptions); + + // Apply post-processing filters + let results = matches; + + if (options.onlyDirectories) { + const { FileSystemAdapter } = await import('./FileSystemAdapter.js'); + const fs = new FileSystemAdapter(); + const filtered = []; + + for (const match of matches) { + const stats = await fs.stat(match).catch(() => null); + if (stats && stats.isDirectory) { + filtered.push(match); + } + } + results = filtered; + } + + // Sort results for consistency + results.sort(); + + return results; + } catch (error) { + throw this._normalizeError(error, 'find', pattern); + } + } + + /** + * Find files matching multiple glob patterns. + * + * @param {Array} patterns - Array of glob patterns + * @param {Object} [options] - Globbing options (same as find) + * @returns {Promise>} Array of unique matching file paths + * @throws {GlobError} When pattern matching fails + */ + async findMultiple(patterns, options = {}) { + try { + const allMatches = await Promise.all(patterns.map((pattern) => this.find(pattern, options))); + + // Flatten and deduplicate results + const uniqueMatches = [...new Set(allMatches.flat())]; + uniqueMatches.sort(); + + return uniqueMatches; + } catch (error) { + throw this._normalizeError(error, 'findMultiple', patterns.join(', ')); + } + } + + /** + * Test if a file path matches a glob pattern. + * + * @param {string} filePath - File path to test + * @param {string} pattern - Glob pattern + * @param {Object} [options] - Matching options + * @param {string} [options.cwd] - Working directory for relative paths + * @param {boolean} [options.caseSensitive] - Case sensitive matching override + * @returns {boolean} True if path matches pattern + */ + matches(filePath, pattern, options = {}) { + try { + const cwd = options.cwd || this.defaultCwd; + const caseSensitive = + options.caseSensitive !== undefined ? options.caseSensitive : this.caseSensitive; + + // Normalize path relative to cwd if not absolute + let normalizedPath = filePath; + if (!isAbsolute(filePath)) { + normalizedPath = resolve(cwd, filePath); + } + + // Convert to relative path for matching if pattern is relative + if (!isAbsolute(pattern)) { + normalizedPath = relative(cwd, normalizedPath); + } + + const minimatchOptions = { + dot: true, + nocase: caseSensitive === false + }; + + return minimatch(normalizedPath, pattern, minimatchOptions); + } catch (error) { + return false; + } + } + + /** + * Test if a file path matches any of the provided patterns. + * + * @param {string} filePath - File path to test + * @param {Array} patterns - Array of glob patterns + * @param {Object} [options] - Matching options (same as matches) + * @returns {boolean} True if path matches any pattern + */ + matchesAny(filePath, patterns, options = {}) { + return patterns.some((pattern) => this.matches(filePath, pattern, options)); + } + + /** + * Filter an array of file paths by glob patterns. + * + * @param {Array} filePaths - Array of file paths + * @param {Array} includePatterns - Patterns to include + * @param {Array} [excludePatterns=[]] - Patterns to exclude + * @param {Object} [options] - Filtering options + * @param {string} [options.cwd] - Working directory + * @returns {Array} Filtered file paths + */ + filter(filePaths, includePatterns, excludePatterns = [], options = {}) { + return filePaths.filter((filePath) => { + // Must match at least one include pattern + const included = + includePatterns.length === 0 || this.matchesAny(filePath, includePatterns, options); + + // Must not match any exclude pattern + const excluded = + excludePatterns.length > 0 && this.matchesAny(filePath, excludePatterns, options); + + return included && !excluded; + }); + } + + /** + * Expand a glob pattern to see what files it would match (dry run). + * + * @param {string} pattern - Glob pattern to expand + * @param {Object} [options] - Expansion options (same as find) + * @returns {Promise} Expansion result with stats + */ + async expand(pattern, options = {}) { + const startTime = Date.now(); + + try { + const matches = await this.find(pattern, options); + const endTime = Date.now(); + + return { + pattern, + matches, + count: matches.length, + duration: endTime - startTime, + options: { ...options } + }; + } catch (error) { + throw this._normalizeError(error, 'expand', pattern); + } + } + + /** + * Watch for file changes matching glob patterns. + * + * @param {string|Array} patterns - Glob pattern(s) to watch + * @param {Object} [options] - Watch options + * @param {string} [options.cwd] - Working directory + * @param {Array} [options.ignore] - Ignore patterns + * @param {boolean} [options.persistent=true] - Keep process alive + * @param {number} [options.interval=100] - Polling interval for non-native watchers + * @returns {Promise} File system watcher + * @throws {GlobError} When watcher setup fails + */ + async watch(patterns, options = {}) { + try { + const { watch: chokidarWatch } = await import('chokidar'); + + const watchPatterns = Array.isArray(patterns) ? patterns : [patterns]; + const watchOptions = { + cwd: options.cwd || this.defaultCwd, + ignored: [...this.defaultIgnore, ...(options.ignore || [])], + persistent: options.persistent !== false, + ignoreInitial: true, + followSymlinks: this.followSymlinks, + interval: options.interval || 100, + binaryInterval: options.binaryInterval || 300 + }; + + const watcher = chokidarWatch(watchPatterns, watchOptions); + + return { + watcher, + close: () => watcher.close(), + on: (event, callback) => watcher.on(event, callback), + off: (event, callback) => watcher.off(event, callback), + getWatched: () => watcher.getWatched() + }; + } catch (error) { + throw this._normalizeError( + error, + 'watch', + Array.isArray(patterns) ? patterns.join(', ') : patterns + ); + } + } + + /** + * Build glob options from input parameters. + * + * @private + * @param {Object} options - Input options + * @returns {Object} Glob library compatible options + */ + _buildGlobOptions(options = {}) { + const cwd = options.cwd || this.defaultCwd; + const absolute = options.absolute !== undefined ? options.absolute : this.defaultAbsolute; + + return { + cwd: resolve(cwd), + absolute, + dot: true, + ignore: [...this.defaultIgnore, ...(options.ignore || [])], + followSymbolicLinks: this.followSymlinks, + onlyFiles: options.onlyFiles !== false && !options.onlyDirectories, + onlyDirectories: options.onlyDirectories || false, + maxDepth: options.maxDepth, + caseSensitiveMatch: this.caseSensitive, + suppressErrors: false + }; + } + + /** + * Normalize glob errors into consistent format. + * + * @private + * @param {Error} error - Original error + * @param {string} operation - Operation that failed + * @param {string} pattern - Pattern(s) involved + * @returns {GlobError} Normalized error + */ + _normalizeError(error, operation, pattern) { + const normalizedError = new Error( + `Glob ${operation} failed for pattern "${pattern}": ${error.message}` + ); + normalizedError.name = 'GlobError'; + normalizedError.operation = operation; + normalizedError.pattern = pattern; + normalizedError.originalError = error; + + return normalizedError; + } +} + +// Note: chokidar is an optional dependency for watching functionality +// If not available, watch() will throw an appropriate error diff --git a/starfleet/data-host-node/adapters/ProcessAdapter.js b/starfleet/data-host-node/adapters/ProcessAdapter.js new file mode 100644 index 0000000..a9cad30 --- /dev/null +++ b/starfleet/data-host-node/adapters/ProcessAdapter.js @@ -0,0 +1,269 @@ +import { spawn, exec } from 'child_process'; +import { promisify } from 'util'; +import { ProcessPort } from '../../data-core/ports/index.js'; + +const execAsync = promisify(exec); + +/** + * Node.js implementation of the Process port. + * Wraps child_process APIs to provide standardized process execution. + * + * @class ProcessAdapter + */ +export class ProcessAdapter extends ProcessPort { + /** + * Create a new ProcessAdapter instance. + * + * @param {Object} options - Configuration options + * @param {string} [options.shell='/bin/sh'] - Default shell to use + * @param {number} [options.timeout=30000] - Default timeout in milliseconds + * @param {string} [options.encoding='utf8'] - Default output encoding + */ + constructor(options = {}) { + super(); + this.defaultShell = options.shell || '/bin/sh'; + this.defaultTimeout = options.timeout || 30000; + this.encoding = options.encoding || 'utf8'; + } + + /** + * Execute a command and return the result. + * + * @param {string} command - Command to execute + * @param {Object} [options] - Execution options + * @param {string} [options.cwd] - Working directory + * @param {Object} [options.env] - Environment variables + * @param {number} [options.timeout] - Timeout in milliseconds + * @param {string} [options.encoding] - Output encoding + * @param {boolean} [options.shell=true] - Run in shell + * @returns {Promise} Process execution result + * @throws {ProcessError} When process execution fails + */ + async execute(command, options = {}) { + try { + const execOptions = { + cwd: options.cwd || process.cwd(), + env: { ...process.env, ...options.env }, + timeout: options.timeout || this.defaultTimeout, + encoding: options.encoding || this.encoding, + shell: options.shell !== false + }; + + const { stdout, stderr } = await execAsync(command, execOptions); + + return { + stdout: stdout || '', + stderr: stderr || '', + exitCode: 0, + command, + success: true + }; + } catch (error) { + // Handle timeout and other exec errors + const result = { + stdout: error.stdout || '', + stderr: error.stderr || '', + exitCode: error.code || 1, + command, + success: false, + signal: error.signal, + timedOut: error.killed && error.signal === 'SIGTERM' + }; + + if (options.throwOnError !== false) { + throw this._normalizeError(error, command, result); + } + + return result; + } + } + + /** + * Spawn a process with streaming support. + * + * @param {string} command - Command to spawn + * @param {Array} [args=[]] - Command arguments + * @param {Object} [options] - Spawn options + * @param {string} [options.cwd] - Working directory + * @param {Object} [options.env] - Environment variables + * @param {boolean} [options.shell=false] - Run in shell + * @param {'pipe'|'inherit'|'ignore'} [options.stdio='pipe'] - Stdio configuration + * @returns {Promise} Process stream interface + */ + async spawn(command, args = [], options = {}) { + return new Promise((resolve, _reject) => { + try { + const spawnOptions = { + cwd: options.cwd || process.cwd(), + env: { ...process.env, ...options.env }, + shell: options.shell || false, + stdio: options.stdio || 'pipe' + }; + + const child = spawn(command, args, spawnOptions); + + let stdout = ''; + let stderr = ''; + + if (child.stdout) { + child.stdout.setEncoding(this.encoding); + child.stdout.on('data', (data) => { + stdout += data; + }); + } + + if (child.stderr) { + child.stderr.setEncoding(this.encoding); + child.stderr.on('data', (data) => { + stderr += data; + }); + } + + child.on('error', (error) => { + reject(this._normalizeError(error, `${command} ${args.join(' ')}`)); + }); + + child.on('close', (exitCode, signal) => { + resolve({ + process: child, + stdout, + stderr, + exitCode, + signal, + success: exitCode === 0, + pid: child.pid + }); + }); + + // Return stream interface immediately + resolve({ + process: child, + stdout: child.stdout, + stderr: child.stderr, + stdin: child.stdin, + pid: child.pid, + kill: (signal = 'SIGTERM') => child.kill(signal), + wait: () => + new Promise((res, rej) => { + child.on('close', (code, sig) => res({ exitCode: code, signal: sig })); + child.on('error', rej); + }) + }); + } catch (error) { + reject(this._normalizeError(error, `${command} ${args.join(' ')}`)); + } + }); + } + + /** + * Execute a command in a specific shell. + * + * @param {string} script - Shell script to execute + * @param {Object} [options] - Execution options + * @param {string} [options.shell] - Shell to use + * @param {string} [options.cwd] - Working directory + * @param {Object} [options.env] - Environment variables + * @param {number} [options.timeout] - Timeout in milliseconds + * @returns {Promise} Process execution result + * @throws {ProcessError} When shell execution fails + */ + async shell(script, options = {}) { + const shell = options.shell || this.defaultShell; + const shellArgs = shell.endsWith('sh') ? ['-c'] : ['/c']; + + return this.execute(`${shell} ${shellArgs.join(' ')} "${script.replace(/"/g, '\\"')}"`, { + ...options, + shell: false // We're handling shell ourselves + }); + } + + /** + * Get current process information. + * + * @returns {ProcessInfo} Current process information + */ + getProcessInfo() { + return { + pid: process.pid, + ppid: process.ppid, + platform: process.platform, + arch: process.arch, + version: process.version, + cwd: process.cwd(), + execPath: process.execPath, + argv: [...process.argv], + uptime: process.uptime(), + memoryUsage: process.memoryUsage(), + cpuUsage: process.cpuUsage() + }; + } + + /** + * Kill a process by PID. + * + * @param {number} pid - Process ID to kill + * @param {string} [signal='SIGTERM'] - Signal to send + * @returns {Promise} True if process was killed successfully + * @throws {ProcessError} When process cannot be killed + */ + async kill(pid, signal = 'SIGTERM') { + try { + process.kill(pid, signal); + return true; + } catch (error) { + if (error.code === 'ESRCH') { + // Process doesn't exist + return false; + } + throw this._normalizeError(error, `kill ${pid} ${signal}`); + } + } + + /** + * Check if a process is running. + * + * @param {number} pid - Process ID to check + * @returns {Promise} True if process is running + */ + async isRunning(pid) { + try { + process.kill(pid, 0); // Signal 0 checks existence without killing + return true; + } catch (error) { + if (error.code === 'ESRCH') { + return false; + } + // EPERM means process exists but we can't signal it + return error.code === 'EPERM'; + } + } + + /** + * Normalize process errors into consistent format. + * + * @private + * @param {Error} error - Original error + * @param {string} command - Command that failed + * @param {Object} [result] - Process result if available + * @returns {ProcessError} Normalized error + */ + _normalizeError(error, command, result = null) { + const normalizedError = new Error( + `Process execution failed for "${command}": ${error.message}` + ); + normalizedError.name = 'ProcessError'; + normalizedError.code = error.code; + normalizedError.command = command; + normalizedError.signal = error.signal; + normalizedError.killed = error.killed; + normalizedError.originalError = error; + + if (result) { + normalizedError.stdout = result.stdout; + normalizedError.stderr = result.stderr; + normalizedError.exitCode = result.exitCode; + } + + return normalizedError; + } +} diff --git a/starfleet/data-host-node/index.js b/starfleet/data-host-node/index.js new file mode 100644 index 0000000..3dc0089 --- /dev/null +++ b/starfleet/data-host-node/index.js @@ -0,0 +1,209 @@ +/** + * @fileoverview Node.js host adapters for data-core ports. + * + * This module provides Node.js-specific implementations of the ports that + * data-core requires. These adapters wrap Node.js built-ins to match the + * port interfaces defined by data-core. + * + * @module data-host-node + * @version 1.0.0 + */ + +// Import all adapter implementations +import { FileSystemAdapter } from './adapters/FileSystemAdapter.js'; +import { CryptoAdapter } from './adapters/CryptoAdapter.js'; +import { ProcessAdapter } from './adapters/ProcessAdapter.js'; +import { EnvironmentAdapter } from './adapters/EnvironmentAdapter.js'; +import { GlobAdapter } from './adapters/GlobAdapter.js'; + +/** + * Create a complete set of Node.js adapters with default configuration. + * + * @param {Object} [config] - Global configuration options + * @param {Object} [config.fileSystem] - FileSystem adapter options + * @param {Object} [config.crypto] - Crypto adapter options + * @param {Object} [config.process] - Process adapter options + * @param {Object} [config.environment] - Environment adapter options + * @param {Object} [config.glob] - Glob adapter options + * @returns {NodeAdapters} Object containing all configured adapters + * + * @example + * ```javascript + * import { createNodeAdapters } from 'data-host-node'; + * + * const adapters = createNodeAdapters({ + * fileSystem: { encoding: 'utf8' }, + * environment: { prefix: 'DATA_' }, + * glob: { followSymlinks: true } + * }); + * + * // Use with data-core + * const core = new DataCore(adapters); + * ``` + */ +export function createNodeAdapters(config = {}) { + return { + fileSystem: new FileSystemAdapter(config.fileSystem), + crypto: new CryptoAdapter(config.crypto), + process: new ProcessAdapter(config.process), + environment: new EnvironmentAdapter(config.environment), + glob: new GlobAdapter(config.glob) + }; +} + +/** + * Create Node.js adapters with development-optimized configuration. + * + * @param {Object} [overrides] - Configuration overrides + * @returns {NodeAdapters} Development-configured adapters + * + * @example + * ```javascript + * import { createDevAdapters } from 'data-host-node'; + * + * const adapters = createDevAdapters(); + * // Includes helpful defaults for development work + * ``` + */ +export function createDevAdapters(overrides = {}) { + return createNodeAdapters({ + fileSystem: { + encoding: 'utf8', + mode: 0o644, + ...overrides.fileSystem + }, + process: { + timeout: 60000, // Longer timeout for dev builds + shell: '/bin/bash', + ...overrides.process + }, + environment: { + defaults: { + NODE_ENV: 'development', + DEBUG: '1' + }, + ...overrides.environment + }, + glob: { + absolute: false, + followSymlinks: true, + ignore: [ + 'node_modules/**', + '.git/**', + 'dist/**', + 'build/**', + 'coverage/**', + '.nyc_output/**' + ], + ...overrides.glob + } + }); +} + +/** + * Create Node.js adapters with production-optimized configuration. + * + * @param {Object} [overrides] - Configuration overrides + * @returns {NodeAdapters} Production-configured adapters + * + * @example + * ```javascript + * import { createProdAdapters } from 'data-host-node'; + * + * const adapters = createProdAdapters(); + * // Includes optimized defaults for production use + * ``` + */ +export function createProdAdapters(overrides = {}) { + return createNodeAdapters({ + fileSystem: { + encoding: 'utf8', + mode: 0o644, + ...overrides.fileSystem + }, + process: { + timeout: 30000, // Shorter timeout for prod + shell: '/bin/sh', + ...overrides.process + }, + environment: { + defaults: { + NODE_ENV: 'production' + }, + caseSensitive: true, + ...overrides.environment + }, + glob: { + absolute: true, + followSymlinks: false, // Security: don't follow symlinks in prod + caseSensitive: true, + ignore: ['node_modules/**', '.git/**', '**/.env*', '**/.*'], + ...overrides.glob + } + }); +} + +/** + * Wire adapters to a data-core instance. + * This is a convenience function that handles the common pattern + * of injecting adapters into data-core's dependency injection system. + * + * @param {Object} core - data-core instance + * @param {NodeAdapters} adapters - Node.js adapters + * @returns {Object} The core instance with adapters wired + * + * @example + * ```javascript + * import { DataCore } from 'data-core'; + * import { createNodeAdapters, wireAdapters } from 'data-host-node'; + * + * const core = new DataCore(); + * const adapters = createNodeAdapters(); + * + * // Wire the adapters to the core + * wireAdapters(core, adapters); + * + * // Now core can use the Node.js implementations + * await core.initialize(); + * ``` + */ +export function wireAdapters(core, adapters) { + // Register adapters with data-core's dependency injection + if (typeof core.register === 'function') { + core.register('fileSystem', adapters.fileSystem); + core.register('process', adapters.process); + core.register('environment', adapters.environment); + core.register('glob', adapters.glob); + } else if (typeof core.setAdapters === 'function') { + core.setAdapters(adapters); + } else { + // Fallback: try direct property assignment + Object.assign(core, adapters); + } + + return core; +} + +// Export individual adapter classes for advanced use cases +export { FileSystemAdapter, CryptoAdapter, ProcessAdapter, EnvironmentAdapter, GlobAdapter }; + +/** + * @typedef {Object} NodeAdapters + * @property {FileSystemAdapter} fileSystem - File system operations adapter + * @property {CryptoAdapter} crypto - Cryptographic operations adapter + * @property {ProcessAdapter} process - Process execution adapter + * @property {EnvironmentAdapter} environment - Environment variables adapter + * @property {GlobAdapter} glob - File pattern matching adapter + */ + +/** + * Default export provides the most common use case. + * + * @example + * ```javascript + * import nodeAdapters from 'data-host-node'; + * + * const adapters = nodeAdapters(); // Uses createNodeAdapters() with defaults + * ``` + */ +export default createNodeAdapters; diff --git a/starfleet/data-host-node/package.json b/starfleet/data-host-node/package.json new file mode 100644 index 0000000..7d21452 --- /dev/null +++ b/starfleet/data-host-node/package.json @@ -0,0 +1,47 @@ +{ + "name": "@starfleet/data-host-node", + "version": "1.0.0", + "description": "Node.js host adapters for data-core ports", + "type": "module", + "main": "./src/index.js", + "exports": { + ".": "./src/index.js", + "./adapters/*": "./src/adapters/*" + }, + "scripts": { + "lint": "eslint \"src/**/*.{js,mjs,cjs,ts,tsx}\"", + "test": "vitest --run --passWithNoTests", + "build": "echo \"No build needed for pure JS\"" + }, + "keywords": [ + "data", + "adapters", + "node", + "ports" + ], + "author": "Flyingrobots Development Team", + "license": "MIT", + "dependencies": { + "@starfleet/data-core": "workspace:*", + "@supabase/supabase-js": "^2.45.0", + "chalk": "^4.1.2", + "chokidar": "^4.0.3", + "dotenv": "^16.4.5", + "glob": "^10.3.0", + "globby": "^14.0.0", + "minimatch": "^9.0.0", + "pg": "^8.12.0", + "pino": "^9.0.0", + "pino-pretty": "^11.0.0" + }, + "files": [ + "src" + ], + "sideEffects": false, + "publishConfig": { + "access": "public" + }, + "engines": { + "node": ">=18" + } +} \ No newline at end of file diff --git a/starfleet/data-host-node/src/adapters/ClockAdapter.js b/starfleet/data-host-node/src/adapters/ClockAdapter.js new file mode 100644 index 0000000..62fd587 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/ClockAdapter.js @@ -0,0 +1,7 @@ +/** + * ClockAdapter - Node.js implementation of ClockPort + */ +export const ClockAdapter = { + now: () => new Date(), + nowMs: () => Date.now() +}; diff --git a/starfleet/data-host-node/src/adapters/CryptoPortNodeAdapter.js b/starfleet/data-host-node/src/adapters/CryptoPortNodeAdapter.js new file mode 100644 index 0000000..5d33964 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/CryptoPortNodeAdapter.js @@ -0,0 +1,25 @@ +/** + * CryptoPortNodeAdapter - Node.js crypto implementation of CryptoPort + */ +import { createHash, randomUUID, randomBytes, timingSafeEqual } from 'node:crypto'; + +export class CryptoPortNodeAdapter { + hash(data, algorithm = 'sha256') { + return createHash(algorithm).update(data).digest('hex'); + } + + randomUUID() { + return randomUUID(); + } + + randomBytes(length) { + return randomBytes(length).toString('hex'); + } + + timingSafeEqual(a, b) { + if (a.length !== b.length) return false; + const bufA = Buffer.from(a); + const bufB = Buffer.from(b); + return timingSafeEqual(bufA, bufB); + } +} diff --git a/starfleet/data-host-node/src/adapters/DbPortNodeAdapter.js b/starfleet/data-host-node/src/adapters/DbPortNodeAdapter.js new file mode 100644 index 0000000..2d66d83 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/DbPortNodeAdapter.js @@ -0,0 +1,156 @@ +/** + * DbPortNodeAdapter - Node.js PostgreSQL implementation of DbPort + * Uses psql for migrations and pg_prove for tests + */ +import { execFile } from 'node:child_process'; +import { promisify } from 'node:util'; +import pg from 'pg'; + +const exec = promisify(execFile); + +export class DbPortNodeAdapter { + constructor(connectionString) { + this.connectionString = connectionString; + this.pool = null; + } + + async _getPool() { + if (!this.pool) { + this.pool = new pg.Pool({ + connectionString: this.connectionString, + max: 10, + idleTimeoutMillis: 30000, + connectionTimeoutMillis: 2000 + }); + } + return this.pool; + } + + async apply(sqlText) { + // Use psql for migrations (better for DDL) + const env = { + ...process.env, + DATABASE_URL: this.connectionString + }; + + await exec('psql', ['--no-psqlrc', '-v', 'ON_ERROR_STOP=1', '-c', sqlText], { env }); + } + + async query(sqlText, params = []) { + const pool = await this._getPool(); + const result = await pool.query(sqlText, params); + return result.rows; + } + + async runPgTap(paths) { + try { + // Run pg_prove or custom pgTAP runner + const { stdout } = await exec( + 'pg_prove', + ['--verbose', '--formatter', 'TAP::Formatter::Console', ...paths], + { + env: { + ...process.env, + DATABASE_URL: this.connectionString + } + } + ); + + // Parse TAP output + const lines = stdout.split('\n'); + let passed = 0; + let failed = 0; + const failures = []; + + for (const line of lines) { + if (line.includes('ok ')) passed++; + if (line.includes('not ok ')) { + failed++; + failures.push(line); + } + } + + return { + passed, + failed, + total: passed + failed, + failures + }; + } catch (error) { + // Fallback: run tests directly via psql + return this._runPgTapViaPsql(paths); + } + } + + async _runPgTapViaPsql(paths) { + // Implementation for running pgTAP tests via psql + let passed = 0; + let failed = 0; + const failures = []; + + for (const path of paths) { + try { + const { stdout } = await exec('psql', ['--no-psqlrc', '-tA', '-f', path], { + env: { + ...process.env, + DATABASE_URL: this.connectionString + } + }); + + const lines = stdout.split('\n'); + for (const line of lines) { + if (line.startsWith('ok ')) passed++; + if (line.startsWith('not ok ')) { + failed++; + failures.push(line); + } + } + } catch (error) { + failed++; + failures.push(`Error running ${path}: ${error.message}`); + } + } + + return { + passed, + failed, + total: passed + failed, + failures + }; + } + + async withTransaction(fn) { + const pool = await this._getPool(); + const client = await pool.connect(); + + try { + await client.query('BEGIN'); + + const txApi = { + apply: (sql) => client.query(sql).then(() => undefined), + query: (sql, params) => client.query(sql, params).then((r) => r.rows) + }; + + const result = await fn(txApi); + await client.query('COMMIT'); + return result; + } catch (error) { + try { + await client.query('ROLLBACK'); + } catch (rollbackError) { + // Log rollback error but throw original + console.error('Rollback failed:', rollbackError); + } + throw error; + } finally { + client.release(); + } + } + + async close() { + if (this.pool) { + await this.pool.end(); + this.pool = null; + } + } +} diff --git a/starfleet/data-host-node/src/adapters/EnvironmentAdapter.js b/starfleet/data-host-node/src/adapters/EnvironmentAdapter.js new file mode 100644 index 0000000..70b9541 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/EnvironmentAdapter.js @@ -0,0 +1,7 @@ +/** + * EnvironmentAdapter - Node.js implementation of EnvironmentPort + */ +export const EnvironmentAdapter = { + get: (key) => process.env[key], + has: (key) => key in process.env +}; diff --git a/starfleet/data-host-node/src/adapters/EventBusNodeAdapter.js b/starfleet/data-host-node/src/adapters/EventBusNodeAdapter.js new file mode 100644 index 0000000..dd78bd4 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/EventBusNodeAdapter.js @@ -0,0 +1,28 @@ +/** + * EventBusNodeAdapter - Node.js EventEmitter implementation of EventBusPort + */ +import { EventEmitter } from 'node:events'; + +export class EventBusNodeAdapter { + constructor() { + this.emitter = new EventEmitter(); + } + + on(type, handler) { + this.emitter.on(type, handler); + // Return unsubscribe function + return () => this.off(type, handler); + } + + off(type, handler) { + this.emitter.off(type, handler); + } + + emit(type, payload) { + this.emitter.emit(type, payload); + } + + once(type, handler) { + this.emitter.once(type, handler); + } +} diff --git a/starfleet/data-host-node/src/adapters/FileSystemAdapter.js b/starfleet/data-host-node/src/adapters/FileSystemAdapter.js new file mode 100644 index 0000000..aa81d3d --- /dev/null +++ b/starfleet/data-host-node/src/adapters/FileSystemAdapter.js @@ -0,0 +1,38 @@ +/** + * FileSystemAdapter - Node.js implementation of FileSystemPort + */ +import { promises as fs } from 'node:fs'; +import { dirname } from 'node:path'; + +export const FileSystemAdapter = { + readFile: (path) => fs.readFile(path, 'utf8'), + + writeFile: (path, data) => fs.writeFile(path, data, 'utf8'), + + exists: async (path) => { + try { + await fs.access(path); + return true; + } catch { + return false; + } + }, + + mkdirp: (path) => fs.mkdir(path, { recursive: true }), + + rm: (path, opts = {}) => { + const { recursive = false, force = false } = opts; + return fs.rm(path, { recursive, force }); + }, + + readdir: (path) => fs.readdir(path), + + stat: async (path) => { + const stats = await fs.stat(path); + return { + isFile: () => stats.isFile(), + isDirectory: () => stats.isDirectory(), + size: stats.size + }; + } +}; diff --git a/starfleet/data-host-node/src/adapters/GitPortNodeAdapter.js b/starfleet/data-host-node/src/adapters/GitPortNodeAdapter.js new file mode 100644 index 0000000..e23ee54 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/GitPortNodeAdapter.js @@ -0,0 +1,70 @@ +/** + * GitPortNodeAdapter - Node.js git command implementation of GitPort + */ +import { execFile } from 'node:child_process'; +import { promisify } from 'node:util'; + +const exec = promisify(execFile); + +export class GitPortNodeAdapter { + async status() { + const [statusResult, branchResult, remoteResult] = await Promise.all([ + exec('git', ['status', '--porcelain']), + exec('git', ['rev-parse', '--abbrev-ref', 'HEAD']), + exec('git', ['rev-list', '--left-right', '--count', 'HEAD...@{u}']).catch(() => ({ + stdout: '0\t0' + })) + ]); + + const statusLines = statusResult.stdout.trim().split('\n').filter(Boolean); + const modified = []; + const untracked = []; + + for (const line of statusLines) { + const status = line.substring(0, 2); + const file = line.substring(3); + if (status === '??') { + untracked.push(file); + } else { + modified.push(file); + } + } + + const [behind, ahead] = remoteResult.stdout.trim().split('\t').map(Number); + + return { + clean: statusLines.length === 0, + branch: branchResult.stdout.trim(), + behind, + ahead, + modified, + untracked + }; + } + + async tag(name, message) { + const args = ['tag', '-a', name, '-m', message || name]; + await exec('git', args); + } + + async latestTag(prefix) { + try { + const { stdout } = await exec('git', [ + 'tag', + '--list', + `${prefix}*`, + '--sort', + '-version:refname' + ]); + const tags = stdout.trim().split('\n').filter(Boolean); + return tags[0] || null; + } catch { + return null; + } + } + + async revParse(ref) { + const { stdout } = await exec('git', ['rev-parse', ref]); + return stdout.trim(); + } +} diff --git a/starfleet/data-host-node/src/adapters/GlobAdapter.js b/starfleet/data-host-node/src/adapters/GlobAdapter.js new file mode 100644 index 0000000..bd5b939 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/GlobAdapter.js @@ -0,0 +1,11 @@ +/** + * GlobAdapter - Node.js implementation of GlobPort using globby + */ +import { globby } from 'globby'; + +export const GlobAdapter = { + find: (patterns, opts = {}) => { + const { cwd, ignore, dot = false } = opts; + return globby(patterns, { cwd, ignore, dot }); + } +}; diff --git a/starfleet/data-host-node/src/adapters/LoggerConsoleAdapter.js b/starfleet/data-host-node/src/adapters/LoggerConsoleAdapter.js new file mode 100644 index 0000000..1bba097 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/LoggerConsoleAdapter.js @@ -0,0 +1,44 @@ +/** + * LoggerConsoleAdapter - Console-based implementation of LoggerPort + */ +export class LoggerConsoleAdapter { + constructor(bindings = {}) { + this.bindings = bindings; + } + + info(obj, msg) { + const output = this._format('INFO', obj, msg); + console.log(output); + } + + warn(obj, msg) { + const output = this._format('WARN', obj, msg); + console.warn(output); + } + + error(obj, msg) { + const output = this._format('ERROR', obj, msg); + console.error(output); + } + + debug(obj, msg) { + if (process.env.DEBUG) { + const output = this._format('DEBUG', obj, msg); + console.debug(output); + } + } + + child(bindings) { + return new LoggerConsoleAdapter({ ...this.bindings, ...bindings }); + } + + _format(level, obj, msg) { + const parts = []; + if (Object.keys(this.bindings).length > 0) { + parts.push(JSON.stringify(this.bindings)); + } + if (msg) parts.push(msg); + if (obj) parts.push(JSON.stringify(obj)); + return parts.join(' '); + } +} diff --git a/starfleet/data-host-node/src/adapters/ProcessPortNodeAdapter.js b/starfleet/data-host-node/src/adapters/ProcessPortNodeAdapter.js new file mode 100644 index 0000000..ade77b1 --- /dev/null +++ b/starfleet/data-host-node/src/adapters/ProcessPortNodeAdapter.js @@ -0,0 +1,88 @@ +/** + * ProcessPortNodeAdapter - Node.js implementation of ProcessPort + */ +import { spawn, exec as execCallback } from 'node:child_process'; +import { promisify } from 'node:util'; +import process from 'node:process'; + +const execPromise = promisify(execCallback); + +export class ProcessPortNodeAdapter { + async spawn(command, args = [], options = {}) { + return new Promise((resolve, _reject) => { + const { cwd, env, shell, timeout } = options; + + const child = spawn(command, args, { + cwd, + env: env || process.env, + shell, + timeout + }); + + let stdout = ''; + let stderr = ''; + + child.stdout.on('data', (data) => { + stdout += data.toString(); + }); + + child.stderr.on('data', (data) => { + stderr += data.toString(); + }); + + child.on('error', (error) => { + reject(error); + }); + + child.on('close', (code, signal) => { + resolve({ stdout, stderr, code, signal }); + }); + }); + } + + async exec(command, options = {}) { + const { cwd, env, timeout } = options; + + try { + const { stdout, stderr } = await execPromise(command, { + cwd, + env: env || process.env, + timeout + }); + + return { stdout, stderr, code: 0, signal: null }; + } catch (error) { + return { + stdout: error.stdout || '', + stderr: error.stderr || '', + code: error.code || 1, + signal: error.signal || null + }; + } + } + + exit(code = 0) { + process.exit(code); + } + + cwd() { + return process.cwd(); + } + + chdir(dir) { + process.chdir(dir); + } + + async which(command) { + const isWindows = process.platform === 'win32'; + const checkCommand = isWindows ? `where ${command}` : `command -v ${command}`; + + try { + const { stdout } = await execPromise(checkCommand, { shell: true }); + const paths = stdout.trim().split(/\r?\n/); + return paths[0] || null; + } catch { + return null; + } + } +} diff --git a/starfleet/data-host-node/src/adapters/index.js b/starfleet/data-host-node/src/adapters/index.js new file mode 100644 index 0000000..31b7dae --- /dev/null +++ b/starfleet/data-host-node/src/adapters/index.js @@ -0,0 +1,14 @@ +/** + * Adapters index - Export all Node.js adapter implementations + */ + +export { FileSystemAdapter } from './FileSystemAdapter.js'; +export { GlobAdapter } from './GlobAdapter.js'; +export { ClockAdapter } from './ClockAdapter.js'; +export { EnvironmentAdapter } from './EnvironmentAdapter.js'; +export { LoggerConsoleAdapter } from './LoggerConsoleAdapter.js'; +export { EventBusNodeAdapter } from './EventBusNodeAdapter.js'; +export { GitPortNodeAdapter } from './GitPortNodeAdapter.js'; +export { DbPortNodeAdapter } from './DbPortNodeAdapter.js'; +export { ProcessPortNodeAdapter } from './ProcessPortNodeAdapter.js'; +export { CryptoPortNodeAdapter } from './CryptoPortNodeAdapter.js'; diff --git a/src/lib/ChildProcessWrapper.js b/starfleet/data-host-node/src/lib/ChildProcessWrapper.js similarity index 94% rename from src/lib/ChildProcessWrapper.js rename to starfleet/data-host-node/src/lib/ChildProcessWrapper.js index f83d21e..6244e0f 100644 --- a/src/lib/ChildProcessWrapper.js +++ b/starfleet/data-host-node/src/lib/ChildProcessWrapper.js @@ -1,6 +1,6 @@ /** * ChildProcessWrapper - Safe child process management with proper cleanup - * + * * Features: * - Automatic process cleanup on timeout * - Command injection prevention via whitelist validation @@ -9,15 +9,15 @@ * - Safe argument sanitization */ -const { spawn } = require('child_process'); -const EventEmitter = require('events'); +import { spawn } from 'child_process'; +import EventEmitter from 'events'; class ChildProcessWrapper extends EventEmitter { constructor(logger = console) { super(); this.logger = logger; this.activeProcesses = new Map(); - + // Whitelist of allowed commands this.allowedCommands = new Set([ 'node', @@ -33,55 +33,55 @@ class ChildProcessWrapper extends EventEmitter { 'git', 'deno' ]); - + // Setup cleanup on process exit process.on('exit', () => this.cleanupAll()); process.on('SIGINT', () => this.cleanupAll()); process.on('SIGTERM', () => this.cleanupAll()); } - + /** * Validate command against whitelist */ validateCommand(command) { const baseCommand = command.split(' ')[0].split('/').pop(); - + if (!this.allowedCommands.has(baseCommand)) { throw new Error(`Command '${baseCommand}' is not in the allowed command whitelist`); } - + return true; } - + /** * Sanitize arguments to prevent injection */ sanitizeArgs(args) { - return args.map(arg => { + return args.map((arg) => { // Remove dangerous characters that could break out of arguments const sanitized = String(arg) .replace(/[;&|`$(){}[\]<>]/g, '') // Remove shell metacharacters .replace(/\n|\r/g, ' '); // Replace newlines with spaces - + // Warn if sanitization changed the argument if (sanitized !== String(arg)) { this.logger.warn(`Argument sanitized: "${arg}" -> "${sanitized}"`); } - + return sanitized; }); } - + /** * Execute a command with proper timeout and cleanup */ execute(command, args = [], options = {}) { // Validate command this.validateCommand(command); - + // Sanitize arguments const safeArgs = this.sanitizeArgs(args); - + // Default options const execOptions = { timeout: 30000, // 30 seconds default @@ -90,32 +90,32 @@ class ChildProcessWrapper extends EventEmitter { // Force some security options windowsHide: true }; - - return new Promise((resolve, reject) => { + + return new Promise((resolve, _reject) => { const startTime = Date.now(); let stdout = ''; let stderr = ''; let timedOut = false; let timeoutHandle = null; - + // Spawn the process const child = spawn(command, safeArgs, execOptions); const pid = child.pid; - + // Track the process this.activeProcesses.set(pid, { process: child, command: `${command} ${safeArgs.join(' ')}`, startTime }); - + // Setup timeout if (execOptions.timeout > 0) { timeoutHandle = setTimeout(() => { timedOut = true; this.logger.warn(`Process ${pid} timed out after ${execOptions.timeout}ms`); this.killProcess(pid, 'SIGTERM'); - + // Give it 5 seconds to die gracefully, then force kill setTimeout(() => { if (this.activeProcesses.has(pid)) { @@ -125,33 +125,33 @@ class ChildProcessWrapper extends EventEmitter { }, 5000); }, execOptions.timeout); } - + // Capture stdout if (child.stdout) { child.stdout.on('data', (data) => { stdout += data.toString(); }); } - + // Capture stderr if (child.stderr) { child.stderr.on('data', (data) => { stderr += data.toString(); }); } - + // Handle process completion child.on('close', (code, signal) => { // Clear timeout if (timeoutHandle) { clearTimeout(timeoutHandle); } - + // Remove from active processes this.activeProcesses.delete(pid); - + const duration = Date.now() - startTime; - + if (timedOut) { reject(new Error(`Process timed out after ${execOptions.timeout}ms`)); } else if (code !== 0) { @@ -172,32 +172,32 @@ class ChildProcessWrapper extends EventEmitter { }); } }); - + // Handle process errors child.on('error', (error) => { // Clear timeout if (timeoutHandle) { clearTimeout(timeoutHandle); } - + // Remove from active processes this.activeProcesses.delete(pid); - + reject(error); }); }); } - + /** * Execute a command and stream output in real-time */ stream(command, args = [], options = {}) { // Validate command this.validateCommand(command); - + // Sanitize arguments const safeArgs = this.sanitizeArgs(args); - + // Default options const execOptions = { timeout: 0, // No timeout for streaming by default @@ -205,25 +205,25 @@ class ChildProcessWrapper extends EventEmitter { stdio: 'pipe', ...options }; - + const startTime = Date.now(); const child = spawn(command, safeArgs, execOptions); const pid = child.pid; - + // Track the process this.activeProcesses.set(pid, { process: child, command: `${command} ${safeArgs.join(' ')}`, startTime }); - + // Setup timeout if specified let timeoutHandle = null; if (execOptions.timeout > 0) { timeoutHandle = setTimeout(() => { this.logger.warn(`Streaming process ${pid} timed out after ${execOptions.timeout}ms`); this.killProcess(pid, 'SIGTERM'); - + setTimeout(() => { if (this.activeProcesses.has(pid)) { this.killProcess(pid, 'SIGKILL'); @@ -231,20 +231,20 @@ class ChildProcessWrapper extends EventEmitter { }, 5000); }, execOptions.timeout); } - + // Emit events for streaming if (child.stdout) { child.stdout.on('data', (data) => { this.emit('stdout', data.toString()); }); } - + if (child.stderr) { child.stderr.on('data', (data) => { this.emit('stderr', data.toString()); }); } - + // Cleanup on completion child.on('close', (code, signal) => { if (timeoutHandle) { @@ -253,7 +253,7 @@ class ChildProcessWrapper extends EventEmitter { this.activeProcesses.delete(pid); this.emit('close', { code, signal, duration: Date.now() - startTime }); }); - + child.on('error', (error) => { if (timeoutHandle) { clearTimeout(timeoutHandle); @@ -261,10 +261,10 @@ class ChildProcessWrapper extends EventEmitter { this.activeProcesses.delete(pid); this.emit('error', error); }); - + return child; } - + /** * Kill a specific process */ @@ -273,12 +273,12 @@ class ChildProcessWrapper extends EventEmitter { if (processInfo && processInfo.process) { try { processInfo.process.kill(signal); - + // On Windows, we need to use taskkill for proper cleanup if (process.platform === 'win32' && signal === 'SIGKILL') { - spawn('taskkill', ['/F', '/T', '/PID', pid.toString()], { + spawn('taskkill', ['/F', '/T', '/PID', pid.toString()], { detached: true, - stdio: 'ignore' + stdio: 'ignore' }); } } catch (error) { @@ -286,7 +286,7 @@ class ChildProcessWrapper extends EventEmitter { } } } - + /** * Clean up all active processes */ @@ -295,7 +295,7 @@ class ChildProcessWrapper extends EventEmitter { this.logger.warn(`Cleaning up process ${pid}: ${info.command}`); this.killProcess(pid, 'SIGTERM'); } - + // Give them a moment to die gracefully setTimeout(() => { for (const [pid] of this.activeProcesses) { @@ -304,7 +304,7 @@ class ChildProcessWrapper extends EventEmitter { } }, 1000); } - + /** * Get list of active processes */ @@ -315,14 +315,14 @@ class ChildProcessWrapper extends EventEmitter { uptime: Date.now() - info.startTime })); } - + /** * Add a command to the whitelist */ allowCommand(command) { this.allowedCommands.add(command); } - + /** * Remove a command from the whitelist */ @@ -331,4 +331,4 @@ class ChildProcessWrapper extends EventEmitter { } } -module.exports = ChildProcessWrapper; \ No newline at end of file +export default ChildProcessWrapper; diff --git a/starfleet/data-host-node/src/lib/SafetyGates.js b/starfleet/data-host-node/src/lib/SafetyGates.js new file mode 100644 index 0000000..8a47b51 --- /dev/null +++ b/starfleet/data-host-node/src/lib/SafetyGates.js @@ -0,0 +1,554 @@ +/** + * SafetyGates.js - Production Safety Gate System + * + * Implements safety checks to prevent accidental production damage during + * migrations and deployments. Like D.A.T.A.'s positronic safety protocols, + * these gates prevent harm to production systems. + */ + +import { spawn } from 'child_process'; +import { readFile } from 'fs/promises'; +import { promisify } from 'util'; +import { createInterface } from 'readline'; +import path from 'path'; +// CoverageEnforcer import removed - we'll implement basic coverage parsing inline + +/** + * Safety gate system for production operations + */ +export class SafetyGates { + constructor(logger = null, options = {}) { + this.logger = logger || console; + this.auditLog = []; + this.options = { + gitEnabled: true, + branchValidation: true, + testValidation: true, + confirmationRequired: true, + coverageThreshold: 80, + ...options + }; + } + + /** + * Run all safety gates for a production operation + * @param {Object} config - Gate configuration + * @param {boolean} force - Force bypass gates (EMERGENCY ONLY) + * @returns {Promise} True if all gates pass + */ + async runAllGates(config = {}, force = false) { + const gateConfig = { + operation: 'production-deployment', + expectedBranch: 'main', + coverageThreshold: this.options.coverageThreshold, + confirmationMessage: 'PROCEED WITH PRODUCTION OPERATION', + ...config + }; + + this.log('info', 'Starting production safety gate validation', { + operation: gateConfig.operation, + force, + timestamp: new Date().toISOString() + }); + + if (force) { + this.log('warn', 'FORCE flag detected - BYPASSING ALL SAFETY GATES!', { + operator: this.getCurrentUser(), + timestamp: new Date().toISOString(), + danger_level: 'CRITICAL' + }); + + const confirmed = await this.requireForceConfirmation(); + if (!confirmed) { + this.log('info', 'Force bypass cancelled by operator'); + return false; + } + + this.log('warn', 'All safety gates BYPASSED via force flag'); + return true; + } + + try { + // Gate 1: Git repository validation + if (this.options.gitEnabled) { + await this.validateGitClean(); + } + + // Gate 2: Branch verification + if (this.options.branchValidation && gateConfig.expectedBranch) { + await this.validateBranch(gateConfig.expectedBranch); + } + + // Gate 3: Test validation + if (this.options.testValidation) { + await this.validateTests(gateConfig.coverageThreshold); + } + + // Gate 4: Production confirmation + if (this.options.confirmationRequired) { + const confirmed = await this.requireConfirmation( + `Type "${gateConfig.confirmationMessage}" to proceed with ${gateConfig.operation}`, + gateConfig.confirmationMessage + ); + + if (!confirmed) { + this.log('info', 'Production operation cancelled by operator'); + return false; + } + } + + this.log('info', 'All safety gates PASSED', { + operation: gateConfig.operation, + gates_passed: this.getPassedGatesCount(), + timestamp: new Date().toISOString() + }); + + return true; + } catch (error) { + this.log('error', 'Safety gate FAILED', { + error: error.message, + operation: gateConfig.operation, + gate: this.getCurrentGate(), + timestamp: new Date().toISOString() + }); + + throw error; + } + } + + /** + * Validate git repository is in clean state + * @returns {Promise} + */ + async validateGitClean() { + this.setCurrentGate('git-clean-check'); + this.log('info', 'Validating git repository state...'); + + try { + // Check if we're in a git repository + await this.execGitCommand(['rev-parse', '--git-dir']); + + // Check for uncommitted changes + const statusOutput = await this.execGitCommand(['status', '--porcelain']); + + if (statusOutput.trim()) { + const files = statusOutput.split('\n').filter((line) => line.trim()); + this.log('audit', 'Git repository has uncommitted changes', { + uncommitted_files: files, + file_count: files.length + }); + + throw new Error( + `Git repository has ${files.length} uncommitted changes. Please commit or stash changes before proceeding.` + ); + } + + // Check for unpushed commits + try { + const unpushedOutput = await this.execGitCommand(['log', '@{u}..HEAD', '--oneline']); + if (unpushedOutput.trim()) { + const commits = unpushedOutput.split('\n').filter((line) => line.trim()); + this.log('warn', 'Git repository has unpushed commits', { + unpushed_commits: commits, + commit_count: commits.length + }); + + // Warning only - don't fail the gate for unpushed commits + } + } catch (error) { + // No upstream branch or other issue - continue + this.log('debug', 'Could not check for unpushed commits', { error: error.message }); + } + + this.log('audit', 'Git clean validation PASSED'); + } catch (error) { + if (error.message.includes('not a git repository')) { + this.log('warn', 'Not in a git repository - skipping git validation'); + return; + } + throw error; + } + } + + /** + * Validate current branch matches expected + * @param {string} expectedBranch - Expected branch name + * @returns {Promise} + */ + async validateBranch(expectedBranch) { + this.setCurrentGate('branch-validation'); + this.log('info', `Validating current branch is ${expectedBranch}...`); + + try { + const currentBranch = await this.execGitCommand(['rev-parse', '--abbrev-ref', 'HEAD']); + const branch = currentBranch.trim(); + + if (branch !== expectedBranch) { + this.log('audit', 'Branch validation FAILED', { + current_branch: branch, + expected_branch: expectedBranch + }); + + throw new Error( + `Current branch is "${branch}" but expected "${expectedBranch}". Please switch to the correct branch.` + ); + } + + this.log('audit', 'Branch validation PASSED', { + branch + }); + } catch (error) { + if (error.message.includes('not a git repository')) { + this.log('warn', 'Not in a git repository - skipping branch validation'); + return; + } + throw error; + } + } + + /** + * Validate tests pass with minimum coverage + * @param {number} coverageThreshold - Minimum coverage percentage + * @returns {Promise} + */ + async validateTests(coverageThreshold = 80) { + this.setCurrentGate('test-validation'); + this.log('info', `Validating tests pass with ${coverageThreshold}% coverage...`); + + try { + // Check if we have a test command available + const hasVitestConfig = + (await this.fileExists('vitest.config.js')) || (await this.fileExists('vite.config.js')); + const hasPackageJson = await this.fileExists('package.json'); + + if (!hasVitestConfig && !hasPackageJson) { + this.log('warn', 'No test configuration found - skipping test validation'); + return; + } + + // Try to run tests with coverage + let testResult; + try { + testResult = await this.runTestsWithCoverage(); + } catch (error) { + this.log('audit', 'Test execution FAILED', { + error: error.message, + coverage_threshold: coverageThreshold + }); + throw new Error(`Tests failed to run: ${error.message}`); + } + + // Validate coverage if enforcer is available + if (testResult.coverage && testResult.coverage.total < coverageThreshold) { + this.log('audit', 'Coverage threshold FAILED', { + actual_coverage: testResult.coverage.total, + required_coverage: coverageThreshold + }); + + throw new Error( + `Test coverage ${testResult.coverage.total}% is below required ${coverageThreshold}%` + ); + } + + // Check for test failures + if (testResult.failed > 0) { + this.log('audit', 'Test validation FAILED', { + tests_passed: testResult.passed, + tests_failed: testResult.failed, + coverage: testResult.coverage?.total + }); + + throw new Error( + `${testResult.failed} tests failed. All tests must pass before production deployment.` + ); + } + + this.log('audit', 'Test validation PASSED', { + tests_passed: testResult.passed, + tests_failed: testResult.failed, + coverage: testResult.coverage?.total + }); + } catch (error) { + // Re-throw with context + throw error; + } + } + + /** + * Require typed confirmation for production operations + * @param {string} message - Confirmation prompt message + * @param {string} expectedInput - Expected confirmation text + * @returns {Promise} True if confirmation matches + */ + async requireConfirmation(message, expectedInput) { + this.setCurrentGate('production-confirmation'); + this.log('info', 'Requesting production operation confirmation...'); + + const rl = createInterface({ + input: process.stdin, + output: process.stdout + }); + + try { + const userInput = await new Promise((resolve) => { + rl.question(`\nโš ๏ธ PRODUCTION SAFETY GATE โš ๏ธ\n\n${message}: `, resolve); + }); + + const confirmed = userInput.trim() === expectedInput; + + this.log('audit', 'Production confirmation attempted', { + expected: expectedInput, + provided_length: userInput.trim().length, + confirmed, + operator: this.getCurrentUser(), + timestamp: new Date().toISOString() + }); + + if (!confirmed) { + this.log('info', 'Confirmation text did not match - operation cancelled'); + } + + return confirmed; + } finally { + rl.close(); + } + } + + /** + * Require force confirmation (double safety for --force flag) + * @returns {Promise} True if force operation confirmed + */ + async requireForceConfirmation() { + const message = + 'FORCE MODE BYPASSES ALL SAFETY GATES!\n\nThis is EXTREMELY DANGEROUS and should only be used in emergencies.\nType "I UNDERSTAND THE RISKS" to continue'; + + return this.requireConfirmation(message, 'I UNDERSTAND THE RISKS'); + } + + /** + * Execute git command + * @param {string[]} args - Git command arguments + * @returns {Promise} Command output + */ + async execGitCommand(args) { + return new Promise((resolve, _reject) => { + const git = spawn('git', args, { + stdio: ['ignore', 'pipe', 'pipe'], + cwd: process.cwd() + }); + + let stdout = ''; + let stderr = ''; + + git.stdout.on('data', (data) => { + stdout += data.toString(); + }); + + git.stderr.on('data', (data) => { + stderr += data.toString(); + }); + + git.on('close', (code) => { + if (code === 0) { + resolve(stdout); + } else { + reject( + new Error(`Git command failed (exit ${code}): ${stderr.trim() || 'Unknown error'}`) + ); + } + }); + + git.on('error', (error) => { + reject(new Error(`Failed to execute git: ${error.message}`)); + }); + }); + } + + /** + * Run tests with coverage + * @returns {Promise} Test results + */ + async runTestsWithCoverage() { + // Try npm test first (most common) + try { + const result = await this.execCommand('npm', ['test', '--', '--coverage']); + return this.parseTestOutput(result); + } catch (error) { + // Try vitest directly + try { + const result = await this.execCommand('npx', ['vitest', 'run', '--coverage']); + return this.parseTestOutput(result); + } catch (vitestError) { + throw new Error(`Test execution failed: ${error.message}`); + } + } + } + + /** + * Execute system command + * @param {string} command - Command to execute + * @param {string[]} args - Command arguments + * @returns {Promise} Command output + */ + async execCommand(command, args) { + return new Promise((resolve, _reject) => { + const proc = spawn(command, args, { + stdio: ['ignore', 'pipe', 'pipe'], + cwd: process.cwd() + }); + + let stdout = ''; + let stderr = ''; + + proc.stdout.on('data', (data) => { + stdout += data.toString(); + }); + + proc.stderr.on('data', (data) => { + stderr += data.toString(); + }); + + proc.on('close', (code) => { + if (code === 0) { + resolve(stdout); + } else { + reject( + new Error( + `Command failed (exit ${code}): ${stderr.trim() || stdout.trim() || 'Unknown error'}` + ) + ); + } + }); + + proc.on('error', (error) => { + reject(new Error(`Failed to execute ${command}: ${error.message}`)); + }); + }); + } + + /** + * Parse test output for results + * @param {string} output - Test command output + * @returns {Object} Parsed test results + */ + parseTestOutput(output) { + const result = { + passed: 0, + failed: 0, + coverage: null + }; + + // Parse test counts (vitest format) + const testSummaryMatch = output.match(/Tests\s+(\d+)\s+passed[^|]*\|\s*(\d+)\s+failed/i); + if (testSummaryMatch) { + result.passed = parseInt(testSummaryMatch[1], 10); + result.failed = parseInt(testSummaryMatch[2], 10); + } + + // Parse coverage (look for percentage) + const coverageMatch = output.match(/All files[^|]*\|\s*([0-9.]+)/); + if (coverageMatch) { + result.coverage = { + total: parseFloat(coverageMatch[1]) + }; + } + + return result; + } + + /** + * Check if file exists + * @param {string} filename - File to check + * @returns {Promise} True if file exists + */ + async fileExists(filename) { + try { + await readFile(filename); + return true; + } catch { + return false; + } + } + + /** + * Get current system user + * @returns {string} Current user name + */ + getCurrentUser() { + return process.env.USER || process.env.USERNAME || 'unknown'; + } + + /** + * Set current gate for audit logging + * @param {string} gate - Gate name + */ + setCurrentGate(gate) { + this.currentGate = gate; + } + + /** + * Get current gate + * @returns {string} Current gate name + */ + getCurrentGate() { + return this.currentGate || 'unknown'; + } + + /** + * Get count of passed gates + * @returns {number} Number of gates passed + */ + getPassedGatesCount() { + return this.auditLog.filter( + (entry) => entry.level === 'audit' && entry.message.includes('PASSED') + ).length; + } + + /** + * Log message with audit trail + * @param {string} level - Log level + * @param {string} message - Log message + * @param {Object} data - Additional data + */ + log(level, message, data = {}) { + const logEntry = { + level, + message, + gate: this.currentGate, + timestamp: new Date().toISOString(), + ...data + }; + + this.auditLog.push(logEntry); + + // Log to provided logger + if (this.logger && typeof this.logger[level] === 'function') { + this.logger[level](message, data); + } else if (this.logger && typeof this.logger.log === 'function') { + this.logger.log(`[${level.toUpperCase()}] ${message}`, data); + } else { + // Fallback to console + console.log( + `[${level.toUpperCase()}] [${this.currentGate || 'SafetyGates'}] ${message}`, + data + ); + } + } + + /** + * Get complete audit log + * @returns {Array} Audit log entries + */ + getAuditLog() { + return [...this.auditLog]; + } + + /** + * Clear audit log + */ + clearAuditLog() { + this.auditLog = []; + } +} + +export default SafetyGates; diff --git a/src/lib/db-utils.js b/starfleet/data-host-node/src/lib/db-utils.js similarity index 86% rename from src/lib/db-utils.js rename to starfleet/data-host-node/src/lib/db-utils.js index 9152e01..acf838f 100644 --- a/src/lib/db-utils.js +++ b/starfleet/data-host-node/src/lib/db-utils.js @@ -1,4 +1,4 @@ -const { Client } = require('pg'); +import { Client } from 'pg'; /** * Database utility functions for temp database management @@ -55,15 +55,14 @@ class DatabaseUtils { */ async databaseExists(databaseName) { const client = this.createAdminClient(); - + try { await client.connect(); - - const result = await client.query( - 'SELECT 1 FROM pg_database WHERE datname = $1', - [databaseName] - ); - + + const result = await client.query('SELECT 1 FROM pg_database WHERE datname = $1', [ + databaseName + ]); + return result.rows.length > 0; } finally { await client.end(); @@ -91,9 +90,9 @@ class DatabaseUtils { const results = []; const queryPromises = statements - .filter(statement => statement.trim()) - .map(statement => client.query(statement)); - + .filter((statement) => statement.trim()) + .map((statement) => client.query(statement)); + const queryResults = await Promise.all(queryPromises); results.push(...queryResults); @@ -115,10 +114,10 @@ class DatabaseUtils { // More sophisticated parsing could be added if needed return sql .split(/;\s*\n/) - .map(stmt => stmt.trim()) - .filter(stmt => stmt.length > 0) - .map(stmt => stmt.endsWith(';') ? stmt : stmt + ';'); + .map((stmt) => stmt.trim()) + .filter((stmt) => stmt.length > 0) + .map((stmt) => (stmt.endsWith(';') ? stmt : stmt + ';')); } } -module.exports = DatabaseUtils; \ No newline at end of file +export default DatabaseUtils; diff --git a/starfleet/data-host-node/src/lib/events/CommandEvent.js b/starfleet/data-host-node/src/lib/events/CommandEvent.js new file mode 100644 index 0000000..1cf1d21 --- /dev/null +++ b/starfleet/data-host-node/src/lib/events/CommandEvent.js @@ -0,0 +1,108 @@ +/** + * Base Command Event Class for D.A.T.A. CLI + * + * This module provides the foundational CommandEvent class for the event-driven + * architecture used throughout the D.A.T.A. (Database Automation, Testing, and + * Alignment) CLI tool. All events support instanceof checks for runtime type safety. + * + * @fileoverview Base event class for robust event-driven command architecture + * @author Supa Base 12 Engineering Team + * @version 1.0.0 + */ + +/** + * @typedef {Object} EventDetails + * @property {string} [directoryName] - Name of directory being processed + * @property {number} [filesProcessed] - Count of files processed + * @property {number} [totalFiles] - Total number of files to process + * @property {string} [filePath] - Path to file being processed + * @property {string} [operation] - Type of operation being performed + * @property {string} [stage] - Current stage of operation + * @property {Error} [error] - Error object if applicable + * @property {string} [code] - Error code for categorization + * @property {boolean} [isProd] - Whether operation is in production mode + * @property {Object} [metadata] - Additional metadata for the event + */ + +/** + * Base class for all command events in the D.A.T.A. system + * + * Provides the foundational structure for all events emitted by commands. + * All events include a timestamp and support structured data through the + * details property. + * + * @class + */ +class CommandEvent { + /** + * Create a new command event + * + * @param {string} type - Event type identifier (e.g., 'progress', 'error') + * @param {string} message - Human-readable message describing the event + * @param {EventDetails} [details={}] - Additional structured data + */ + constructor(type, message, details = {}) { + /** + * @type {string} Event type identifier + */ + this.type = type; + + /** + * @type {string} Human-readable message + */ + this.message = message; + + /** + * @type {EventDetails} Additional structured event data + */ + this.details = details; + + /** + * @type {Date} Timestamp when event was created + */ + this.timestamp = new Date(); + } + + /** + * Convert event to JSON-serializable object + * + * @returns {Object} JSON representation of the event + */ + toJSON() { + return { + type: this.type, + message: this.message, + details: this.details, + timestamp: this.timestamp.toISOString() + }; + } + + /** + * Get a string representation of the event + * + * @returns {string} String representation + */ + toString() { + return `[${this.type.toUpperCase()}] ${this.message}`; + } + + /** + * Convert to event data format expected by emit() + * + * This method provides backward compatibility with the existing event system + * by converting event instances to the object format expected by listeners. + * + * @returns {Object} Event data in the format expected by emit() + */ + toEventData() { + return { + message: this.message, + data: this.details, + timestamp: this.timestamp, + type: this.type + }; + } +} + +export { CommandEvent }; +export default CommandEvent; diff --git a/src/lib/events/CommandEvents.js b/starfleet/data-host-node/src/lib/events/CommandEvents.js similarity index 94% rename from src/lib/events/CommandEvents.js rename to starfleet/data-host-node/src/lib/events/CommandEvents.js index 03deee9..3737ab1 100644 --- a/src/lib/events/CommandEvents.js +++ b/starfleet/data-host-node/src/lib/events/CommandEvents.js @@ -1,10 +1,10 @@ /** * Command Event System for D.A.T.A. CLI - * + * * This module provides a comprehensive event class hierarchy for the event-driven - * architecture used throughout the D.A.T.A. (Database Automation, Testing, and + * architecture used throughout the D.A.T.A. (Database Automation, Testing, and * Alignment) CLI tool. All events support instanceof checks for runtime type safety. - * + * * @fileoverview Event classes for robust event-driven command architecture * @author Supa Base 12 Engineering Team * @version 1.0.0 @@ -26,17 +26,17 @@ /** * Base class for all command events in the D.A.T.A. system - * + * * Provides the foundational structure for all events emitted by commands. * All events include a timestamp and support structured data through the * details property. - * + * * @class */ class CommandEvent { /** * Create a new command event - * + * * @param {string} type - Event type identifier (e.g., 'progress', 'error') * @param {string} message - Human-readable message describing the event * @param {EventDetails} [details={}] - Additional structured data @@ -46,17 +46,17 @@ class CommandEvent { * @type {string} Event type identifier */ this.type = type; - + /** * @type {string} Human-readable message */ this.message = message; - + /** * @type {EventDetails} Additional structured event data */ this.details = details; - + /** * @type {Date} Timestamp when event was created */ @@ -65,7 +65,7 @@ class CommandEvent { /** * Convert event to JSON-serializable object - * + * * @returns {Object} JSON representation of the event */ toJSON() { @@ -79,7 +79,7 @@ class CommandEvent { /** * Get a string representation of the event - * + * * @returns {string} String representation */ toString() { @@ -89,37 +89,40 @@ class CommandEvent { /** * Progress event for long-running operations - * + * * Used to indicate progress during operations that may take significant time, * such as database migrations, file processing, or compilation tasks. - * + * * @extends CommandEvent */ class ProgressEvent extends CommandEvent { /** * Create a new progress event - * + * * @param {string} message - Progress message describing current operation * @param {number|null} [percentage=null] - Completion percentage (0-100), null if unknown * @param {EventDetails} [details={}] - Additional progress details */ constructor(message, percentage = null, details = {}) { super('progress', message, details); - + /** * @type {number|null} Completion percentage (0-100) or null if indeterminate */ this.percentage = percentage; - + // Validate percentage if provided - if (percentage !== null && (typeof percentage !== 'number' || percentage < 0 || percentage > 100)) { + if ( + percentage !== null && + (typeof percentage !== 'number' || percentage < 0 || percentage > 100) + ) { throw new Error('Percentage must be a number between 0 and 100, or null'); } } /** * Create a progress event with percentage - * + * * @param {string} message - Progress message * @param {number} completed - Number of items completed * @param {number} total - Total number of items @@ -137,7 +140,7 @@ class ProgressEvent extends CommandEvent { /** * Create an indeterminate progress event - * + * * @param {string} message - Progress message * @param {EventDetails} [details={}] - Additional details * @returns {ProgressEvent} New indeterminate progress event @@ -149,16 +152,16 @@ class ProgressEvent extends CommandEvent { /** * Error event for operation failures - * + * * Represents errors, failures, or exceptions that occur during command execution. * Includes the original error object and optional error categorization. - * + * * @extends CommandEvent */ class ErrorEvent extends CommandEvent { /** * Create a new error event - * + * * @param {string} message - Error message describing what went wrong * @param {Error} error - The actual error object that was thrown * @param {string|null} [code=null] - Error code for categorization @@ -166,12 +169,12 @@ class ErrorEvent extends CommandEvent { */ constructor(message, error, code = null, details = {}) { super('error', message, { ...details, error, code }); - + /** * @type {Error} The original error object */ this.error = error; - + /** * @type {string|null} Error code for categorization */ @@ -180,24 +183,19 @@ class ErrorEvent extends CommandEvent { /** * Create an error event from an exception - * + * * @param {Error} error - The error object * @param {string} [context='Operation failed'] - Context message * @param {EventDetails} [details={}] - Additional details * @returns {ErrorEvent} New error event */ static fromError(error, context = 'Operation failed', details = {}) { - return new ErrorEvent( - `${context}: ${error.message}`, - error, - error.code || null, - details - ); + return new ErrorEvent(`${context}: ${error.message}`, error, error.code || null, details); } /** * Get the full error stack trace - * + * * @returns {string} Stack trace string */ getStackTrace() { @@ -207,16 +205,16 @@ class ErrorEvent extends CommandEvent { /** * Directory operation event for filesystem operations - * + * * Represents events related to directory processing, creation, scanning, * or other filesystem operations on directories. - * + * * @extends CommandEvent */ class DirectoryEvent extends CommandEvent { /** * Create a new directory event - * + * * @param {string} message - Message describing the directory operation * @param {string} directoryPath - Path to the directory being processed * @param {string} [operation='process'] - Type of operation (process, create, scan, etc.) @@ -224,12 +222,12 @@ class DirectoryEvent extends CommandEvent { */ constructor(message, directoryPath, operation = 'process', details = {}) { super('directory', message, { ...details, directoryPath, operation }); - + /** * @type {string} Path to the directory */ this.directoryPath = directoryPath; - + /** * @type {string} Type of directory operation */ @@ -238,24 +236,22 @@ class DirectoryEvent extends CommandEvent { /** * Create a directory scanning event - * + * * @param {string} directoryPath - Directory being scanned * @param {number} [fileCount=0] - Number of files found * @param {EventDetails} [details={}] - Additional details * @returns {DirectoryEvent} New directory scan event */ static scan(directoryPath, fileCount = 0, details = {}) { - return new DirectoryEvent( - `Scanning directory: ${directoryPath}`, - directoryPath, - 'scan', - { ...details, fileCount } - ); + return new DirectoryEvent(`Scanning directory: ${directoryPath}`, directoryPath, 'scan', { + ...details, + fileCount + }); } /** * Create a directory creation event - * + * * @param {string} directoryPath - Directory being created * @param {EventDetails} [details={}] - Additional details * @returns {DirectoryEvent} New directory creation event @@ -272,23 +268,23 @@ class DirectoryEvent extends CommandEvent { /** * Success event for successful operations - * + * * Indicates successful completion of operations, commands, or tasks. * Often the final event emitted by a command. - * + * * @extends CommandEvent */ class SuccessEvent extends CommandEvent { /** * Create a new success event - * + * * @param {string} message - Success message describing what was accomplished * @param {EventDetails} [details={}] - Additional success details * @param {number|null} [duration=null] - Operation duration in milliseconds */ constructor(message, details = {}, duration = null) { super('success', message, { ...details, duration }); - + /** * @type {number|null} Duration of the operation in milliseconds */ @@ -297,7 +293,7 @@ class SuccessEvent extends CommandEvent { /** * Create a success event with timing information - * + * * @param {string} message - Success message * @param {Date} startTime - When the operation started * @param {EventDetails} [details={}] - Additional details @@ -310,40 +306,40 @@ class SuccessEvent extends CommandEvent { /** * Get formatted duration string - * + * * @returns {string|null} Formatted duration or null if no duration set */ getFormattedDuration() { if (this.duration === null) return null; - + if (this.duration < 1000) { return `${this.duration}ms`; } - - const seconds = Math.round(this.duration / 1000 * 100) / 100; + + const seconds = Math.round((this.duration / 1000) * 100) / 100; return `${seconds}s`; } } /** * Warning event for non-fatal issues - * + * * Represents warnings, non-critical issues, or situations that require * attention but don't prevent operation completion. - * + * * @extends CommandEvent */ class WarningEvent extends CommandEvent { /** * Create a new warning event - * + * * @param {string} message - Warning message * @param {EventDetails} [details={}] - Additional warning details * @param {string|null} [code=null] - Warning code for categorization */ constructor(message, details = {}, code = null) { super('warning', message, { ...details, code }); - + /** * @type {string|null} Warning code for categorization */ @@ -353,16 +349,16 @@ class WarningEvent extends CommandEvent { /** * Start event for operation initiation - * + * * Indicates the beginning of a command or operation. Often includes * configuration or context information. - * + * * @extends CommandEvent */ class StartEvent extends CommandEvent { /** * Create a new start event - * + * * @param {string} message - Start message describing what's beginning * @param {EventDetails} [details={}] - Additional start details */ @@ -372,7 +368,7 @@ class StartEvent extends CommandEvent { /** * Create a start event for production operations - * + * * @param {string} message - Start message * @param {EventDetails} [details={}] - Additional details * @returns {StartEvent} New production start event @@ -384,23 +380,23 @@ class StartEvent extends CommandEvent { /** * Status event for system state information - * + * * Represents status checks, health reports, or system state information * that doesn't fit into other event categories. - * + * * @extends CommandEvent */ class StatusEvent extends CommandEvent { /** * Create a new status event - * + * * @param {string} message - Status message * @param {string} status - Status value (healthy, degraded, error, etc.) * @param {EventDetails} [details={}] - Additional status details */ constructor(message, status, details = {}) { super('status', message, { ...details, status }); - + /** * @type {string} Current status value */ @@ -409,7 +405,7 @@ class StatusEvent extends CommandEvent { /** * Check if status indicates a healthy state - * + * * @returns {boolean} True if status is healthy */ isHealthy() { @@ -420,23 +416,23 @@ class StatusEvent extends CommandEvent { /** * Complete event for successful operation completion - * + * * Indicates that an operation has completed successfully with optional result data. * Similar to SuccessEvent but specifically for completion of multi-step operations. - * + * * @extends CommandEvent */ class CompleteEvent extends CommandEvent { /** * Create a new complete event - * + * * @param {string} message - Completion message * @param {*} [result=null] - Operation result data * @param {EventDetails} [details={}] - Additional completion details */ constructor(message, result = null, details = {}) { super('complete', message, { ...details, result }); - + /** * @type {*} The result of the completed operation */ @@ -446,22 +442,22 @@ class CompleteEvent extends CommandEvent { /** * Cancelled event for operations that were cancelled - * + * * Indicates that an operation was cancelled by the user or system before completion. - * + * * @extends CommandEvent */ class CancelledEvent extends CommandEvent { /** * Create a new cancelled event - * + * * @param {string} [message='Operation cancelled'] - Cancellation message * @param {string|null} [reason=null] - Reason for cancellation * @param {EventDetails} [details={}] - Additional cancellation details */ constructor(message = 'Operation cancelled', reason = null, details = {}) { super('cancelled', message, { ...details, reason }); - + /** * @type {string|null} Reason for the cancellation */ @@ -627,11 +623,11 @@ class BuildFailedEvent extends CommandEvent { /** * Utility function to validate event types at runtime - * + * * Provides runtime type checking for events, ensuring they are instances * of the expected event class. This is the runtime equivalent of TypeScript * type checking, using JavaScript's native instanceof operator. - * + * * @param {*} event - The event to validate * @param {Function} expectedClass - The expected event class constructor * @throws {TypeError} If event is not an instance of expectedClass @@ -641,19 +637,17 @@ function validateCommandEvent(event, expectedClass) { if (!(event instanceof expectedClass)) { const actualType = event?.constructor?.name || typeof event; const expectedType = expectedClass.name; - throw new TypeError( - `Invalid event type: expected ${expectedType}, got ${actualType}` - ); + throw new TypeError(`Invalid event type: expected ${expectedType}, got ${actualType}`); } return true; } /** * Factory function to create typed events with validation - * + * * Creates events using a type string, providing a convenient way to * instantiate events while maintaining type safety through the class system. - * + * * @param {string} type - Event type string * @param {...*} args - Arguments to pass to the event constructor * @returns {CommandEvent} New event instance of the appropriate type @@ -678,17 +672,19 @@ function createCommandEvent(type, ...args) { const EventClass = eventClasses[type]; if (!EventClass) { - throw new Error(`Unknown event type: ${type}. Available types: ${Object.keys(eventClasses).join(', ')}`); + throw new Error( + `Unknown event type: ${type}. Available types: ${Object.keys(eventClasses).join(', ')}` + ); } return new EventClass(...args); } // Export all event classes and utilities -module.exports = { +export { // Base class CommandEvent, - + // Core event classes ProgressEvent, ErrorEvent, @@ -699,14 +695,14 @@ module.exports = { StatusEvent, CompleteEvent, CancelledEvent, - + // Build-specific event classes BuildProgressEvent, BuildStartEvent, BuildCompleteEvent, BuildFailedEvent, - + // Utilities validateCommandEvent, createCommandEvent -}; \ No newline at end of file +}; diff --git a/starfleet/data-host-node/src/lib/events/ErrorEvent.js b/starfleet/data-host-node/src/lib/events/ErrorEvent.js new file mode 100644 index 0000000..ee8aea7 --- /dev/null +++ b/starfleet/data-host-node/src/lib/events/ErrorEvent.js @@ -0,0 +1,208 @@ +/** + * Error Event Class for D.A.T.A. CLI + * + * This module provides the ErrorEvent class for representing errors, failures, + * and exceptions that occur during command execution. Includes the original + * error object and optional error categorization. + * + * @fileoverview Error event class with error context and categorization + * @author Supa Base 12 Engineering Team + * @version 1.0.0 + */ + +import CommandEvent from './CommandEvent.js'; + +/** + * Error event for operation failures + * + * Represents errors, failures, or exceptions that occur during command execution. + * Includes the original error object and optional error categorization for better + * error handling and reporting. + * + * @extends CommandEvent + */ +class ErrorEvent extends CommandEvent { + /** + * Create a new error event + * + * @param {string} message - Error message describing what went wrong + * @param {Error|null} error - The actual error object that was thrown + * @param {string|null} [code=null] - Error code for categorization + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional error context + */ + constructor(message, error = null, code = null, details = {}) { + super('error', message, { ...details, error, code }); + + /** + * @type {Error|null} The original error object + */ + this.error = error; + + /** + * @type {string|null} Error code for categorization + */ + this.code = code || error?.code || null; + } + + /** + * Create an error event from an exception + * + * Factory method that creates an ErrorEvent from a caught exception. + * Automatically extracts error information and constructs a meaningful message. + * + * @param {Error} error - The error object + * @param {string} [context='Operation failed'] - Context message + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {ErrorEvent} New error event + * + * @example + * try { + * // some operation + * } catch (error) { + * const errorEvent = ErrorEvent.fromError(error, 'Database connection failed'); + * command.emit('error', errorEvent.toEventData()); + * } + */ + static fromError(error, context = 'Operation failed', details = {}) { + return new ErrorEvent(`${context}: ${error.message}`, error, error.code || null, details); + } + + /** + * Create an error event for validation failures + * + * Factory method for creating validation-specific error events with + * standardized error codes and categorization. + * + * @param {string} message - Validation error message + * @param {string} field - Field that failed validation + * @param {*} value - The invalid value + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {ErrorEvent} New validation error event + */ + static validation(message, field, value, details = {}) { + return new ErrorEvent( + message, + new Error(`Validation failed for field: ${field}`), + 'VALIDATION_ERROR', + { + ...details, + field, + value, + category: 'validation' + } + ); + } + + /** + * Create an error event for system/infrastructure failures + * + * Factory method for system-level errors like database connections, + * file system operations, or external service failures. + * + * @param {string} message - System error message + * @param {Error} error - The underlying system error + * @param {string} [system='unknown'] - The system component that failed + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {ErrorEvent} New system error event + */ + static system(message, error, system = 'unknown', details = {}) { + return new ErrorEvent(message, error, 'SYSTEM_ERROR', { + ...details, + system, + category: 'system' + }); + } + + /** + * Get the full error stack trace + * + * @returns {string} Stack trace string or fallback message + */ + getStackTrace() { + return this.error?.stack || 'No stack trace available'; + } + + /** + * Check if this is a validation error + * + * @returns {boolean} True if this is a validation error + */ + isValidationError() { + return this.code === 'VALIDATION_ERROR' || this.details.category === 'validation'; + } + + /** + * Check if this is a system error + * + * @returns {boolean} True if this is a system error + */ + isSystemError() { + return this.code === 'SYSTEM_ERROR' || this.details.category === 'system'; + } + + /** + * Get error severity level + * + * Determines error severity based on error type and context. + * + * @returns {string} Severity level: 'critical', 'high', 'medium', 'low' + */ + getSeverity() { + if (this.isSystemError()) { + return 'critical'; + } + + if (this.isValidationError()) { + return 'medium'; + } + + // Check for specific error types + if (this.error instanceof TypeError || this.error instanceof ReferenceError) { + return 'high'; + } + + return 'medium'; + } + + /** + * Convert to event data format expected by emit() + * + * Extends the base toEventData method to include error information + * for backward compatibility with existing error event listeners. + * + * @returns {Object} Event data in the format expected by emit() + */ + toEventData() { + return { + ...super.toEventData(), + error: this.error, + code: this.code, + severity: this.getSeverity(), + stackTrace: this.getStackTrace() + }; + } + + /** + * Get a sanitized version of the error for logging + * + * Returns error information safe for logging, excluding sensitive data. + * + * @returns {Object} Sanitized error information + */ + toLogSafeObject() { + return { + type: this.type, + message: this.message, + code: this.code, + severity: this.getSeverity(), + timestamp: this.timestamp.toISOString(), + errorName: this.error?.name, + errorMessage: this.error?.message, + // Exclude full stack trace and details for security + hasStackTrace: !!this.error?.stack + }; + } +} + +export { ErrorEvent }; +export default ErrorEvent; diff --git a/starfleet/data-host-node/src/lib/events/ProgressEvent.js b/starfleet/data-host-node/src/lib/events/ProgressEvent.js new file mode 100644 index 0000000..0db8ffa --- /dev/null +++ b/starfleet/data-host-node/src/lib/events/ProgressEvent.js @@ -0,0 +1,142 @@ +/** + * Progress Event Class for D.A.T.A. CLI + * + * This module provides the ProgressEvent class for tracking progress during + * long-running operations such as database migrations, file processing, + * or compilation tasks. + * + * @fileoverview Progress event class with percentage tracking and factory methods + * @author Supa Base 12 Engineering Team + * @version 1.0.0 + */ + +import CommandEvent from './CommandEvent.js'; + +/** + * Progress event for long-running operations + * + * Used to indicate progress during operations that may take significant time, + * such as database migrations, file processing, or compilation tasks. + * Supports both determinate progress (with percentage) and indeterminate progress. + * + * @extends CommandEvent + */ +class ProgressEvent extends CommandEvent { + /** + * Create a new progress event + * + * @param {string} message - Progress message describing current operation + * @param {number|null} [percentage=null] - Completion percentage (0-100), null if unknown + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional progress details + * @throws {Error} If percentage is not null and not a valid number between 0-100 + */ + constructor(message, percentage = null, details = {}) { + super('progress', message, details); + + // Validate percentage if provided + if ( + percentage !== null && + (typeof percentage !== 'number' || percentage < 0 || percentage > 100) + ) { + throw new Error('Percentage must be a number between 0 and 100, or null'); + } + + /** + * @type {number|null} Completion percentage (0-100) or null if indeterminate + */ + this.percentage = percentage; + } + + /** + * Create a progress event with percentage + * + * Factory method that automatically calculates percentage based on completed/total counts. + * Ensures percentage is properly rounded and includes the counts in event details. + * + * @param {string} message - Progress message + * @param {number} completed - Number of items completed + * @param {number} total - Total number of items + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {ProgressEvent} New progress event with calculated percentage + * + * @example + * const event = ProgressEvent.withPercentage('Processing files', 25, 100); + * console.log(event.percentage); // 25 + * console.log(event.details.completed); // 25 + * console.log(event.details.total); // 100 + */ + static withPercentage(message, completed, total, details = {}) { + const percentage = total > 0 ? Math.round((completed / total) * 100) : 0; + return new ProgressEvent(message, percentage, { + ...details, + completed, + total + }); + } + + /** + * Create an indeterminate progress event + * + * Factory method for creating progress events where the completion percentage + * cannot be determined. Useful for operations where the total work is unknown. + * + * @param {string} message - Progress message + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {ProgressEvent} New indeterminate progress event + * + * @example + * const event = ProgressEvent.indeterminate('Scanning directory structure'); + * console.log(event.percentage); // null + */ + static indeterminate(message, details = {}) { + return new ProgressEvent(message, null, details); + } + + /** + * Check if this progress event is determinate (has percentage) + * + * @returns {boolean} True if progress has a specific percentage value + */ + isDeterminate() { + return this.percentage !== null; + } + + /** + * Check if the operation is complete (100%) + * + * @returns {boolean} True if percentage is 100 + */ + isComplete() { + return this.percentage === 100; + } + + /** + * Convert to event data format expected by emit() + * + * Extends the base toEventData method to include percentage information + * for backward compatibility with existing progress event listeners. + * + * @returns {Object} Event data in the format expected by emit() + */ + toEventData() { + return { + ...super.toEventData(), + percentage: this.percentage + }; + } + + /** + * Get formatted progress string + * + * @returns {string} Formatted progress representation + */ + getFormattedProgress() { + if (this.percentage === null) { + return 'In progress...'; + } + return `${this.percentage}%`; + } +} + +export { ProgressEvent }; +export default ProgressEvent; diff --git a/starfleet/data-host-node/src/lib/events/SuccessEvent.js b/starfleet/data-host-node/src/lib/events/SuccessEvent.js new file mode 100644 index 0000000..377d942 --- /dev/null +++ b/starfleet/data-host-node/src/lib/events/SuccessEvent.js @@ -0,0 +1,240 @@ +/** + * Success Event Class for D.A.T.A. CLI + * + * This module provides the SuccessEvent class for indicating successful + * completion of operations, commands, or tasks. Often the final event + * emitted by a command. + * + * @fileoverview Success event class with timing and result tracking + * @author Supa Base 12 Engineering Team + * @version 1.0.0 + */ + +import CommandEvent from './CommandEvent.js'; + +/** + * Success event for successful operations + * + * Indicates successful completion of operations, commands, or tasks. + * Supports timing information and result data for comprehensive success reporting. + * Often the final event emitted by a command. + * + * @extends CommandEvent + */ +class SuccessEvent extends CommandEvent { + /** + * Create a new success event + * + * @param {string} message - Success message describing what was accomplished + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional success details + * @param {number|null} [duration=null] - Operation duration in milliseconds + */ + constructor(message, details = {}, duration = null) { + super('success', message, { ...details, duration }); + + /** + * @type {number|null} Duration of the operation in milliseconds + */ + this.duration = duration; + } + + /** + * Create a success event with timing information + * + * Factory method that automatically calculates operation duration based on + * start time. Useful for measuring and reporting operation performance. + * + * @param {string} message - Success message + * @param {Date} startTime - When the operation started + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {SuccessEvent} New success event with calculated duration + * + * @example + * const startTime = new Date(); + * // ... perform operation ... + * const successEvent = SuccessEvent.withTiming('Operation completed', startTime); + * console.log(successEvent.getFormattedDuration()); // "1.23s" + */ + static withTiming(message, startTime, details = {}) { + const duration = Date.now() - startTime.getTime(); + return new SuccessEvent(message, details, duration); + } + + /** + * Create a success event with result data + * + * Factory method for operations that produce significant result data. + * Automatically includes result information in the event details. + * + * @param {string} message - Success message + * @param {*} result - The result data from the operation + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {SuccessEvent} New success event with result data + * + * @example + * const result = { filesProcessed: 42, migrations: 3 }; + * const successEvent = SuccessEvent.withResult('Build completed', result); + */ + static withResult(message, result, details = {}) { + return new SuccessEvent(message, { ...details, result }); + } + + /** + * Create a success event for database operations + * + * Factory method for database-specific success events with standardized + * database operation metrics and information. + * + * @param {string} operation - Database operation performed + * @param {number} [rowsAffected=0] - Number of database rows affected + * @param {number} [duration=null] - Query duration in milliseconds + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {SuccessEvent} New database success event + */ + static database(operation, rowsAffected = 0, duration = null, details = {}) { + return new SuccessEvent( + `Database ${operation} completed successfully`, + { + ...details, + operation, + rowsAffected, + category: 'database' + }, + duration + ); + } + + /** + * Create a success event for file operations + * + * Factory method for file system operation success events with + * standardized file operation metrics. + * + * @param {string} operation - File operation performed + * @param {string} filePath - Path of the file involved + * @param {number} [fileSize=null] - Size of file in bytes + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {SuccessEvent} New file operation success event + */ + static fileOperation(operation, filePath, fileSize = null, details = {}) { + return new SuccessEvent(`File ${operation} completed: ${filePath}`, { + ...details, + operation, + filePath, + fileSize, + category: 'file' + }); + } + + /** + * Get formatted duration string + * + * Converts duration from milliseconds to a human-readable format. + * Returns null if no duration is available. + * + * @returns {string|null} Formatted duration or null if no duration set + */ + getFormattedDuration() { + if (this.duration === null) return null; + + if (this.duration < 1000) { + return `${this.duration}ms`; + } + + const seconds = Math.round((this.duration / 1000) * 100) / 100; + return `${seconds}s`; + } + + /** + * Check if the operation was fast (under 1 second) + * + * @returns {boolean} True if duration is less than 1000ms + */ + isFastOperation() { + return this.duration !== null && this.duration < 1000; + } + + /** + * Check if the operation was slow (over 10 seconds) + * + * @returns {boolean} True if duration is greater than 10000ms + */ + isSlowOperation() { + return this.duration !== null && this.duration > 10000; + } + + /** + * Check if this success event has result data + * + * @returns {boolean} True if event contains result information + */ + hasResult() { + return this.details.result !== undefined; + } + + /** + * Get the result data from this success event + * + * @returns {*} Result data or null if no result available + */ + getResult() { + return this.details.result || null; + } + + /** + * Check if this is a database operation success + * + * @returns {boolean} True if this is a database success event + */ + isDatabaseSuccess() { + return this.details.category === 'database'; + } + + /** + * Check if this is a file operation success + * + * @returns {boolean} True if this is a file operation success event + */ + isFileOperationSuccess() { + return this.details.category === 'file'; + } + + /** + * Convert to event data format expected by emit() + * + * Extends the base toEventData method to include success-specific information + * for backward compatibility with existing success event listeners. + * + * @returns {Object} Event data in the format expected by emit() + */ + toEventData() { + return { + ...super.toEventData(), + duration: this.duration, + formattedDuration: this.getFormattedDuration(), + result: this.getResult(), + category: this.details.category + }; + } + + /** + * Get a comprehensive success summary + * + * @returns {Object} Summary object with key success metrics + */ + getSummary() { + return { + message: this.message, + timestamp: this.timestamp.toISOString(), + duration: this.duration, + formattedDuration: this.getFormattedDuration(), + hasResult: this.hasResult(), + category: this.details.category || 'general', + isFast: this.isFastOperation(), + isSlow: this.isSlowOperation() + }; + } +} + +export { SuccessEvent }; +export default SuccessEvent; diff --git a/starfleet/data-host-node/src/lib/events/WarningEvent.js b/starfleet/data-host-node/src/lib/events/WarningEvent.js new file mode 100644 index 0000000..9dd4f4c --- /dev/null +++ b/starfleet/data-host-node/src/lib/events/WarningEvent.js @@ -0,0 +1,260 @@ +/** + * Warning Event Class for D.A.T.A. CLI + * + * This module provides the WarningEvent class for representing warnings, + * non-critical issues, and situations that require attention but don't + * prevent operation completion. + * + * @fileoverview Warning event class with severity levels and categorization + * @author Supa Base 12 Engineering Team + * @version 1.0.0 + */ + +import CommandEvent from './CommandEvent.js'; + +/** + * Warning event for non-fatal issues + * + * Represents warnings, non-critical issues, or situations that require + * attention but don't prevent operation completion. Supports categorization + * and severity levels for better warning management. + * + * @extends CommandEvent + */ +class WarningEvent extends CommandEvent { + /** + * Create a new warning event + * + * @param {string} message - Warning message + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional warning details + * @param {string|null} [code=null] - Warning code for categorization + */ + constructor(message, details = {}, code = null) { + super('warning', message, { ...details, code }); + + /** + * @type {string|null} Warning code for categorization + */ + this.code = code; + } + + /** + * Create a deprecation warning + * + * Factory method for creating standardized deprecation warnings with + * consistent messaging and categorization. + * + * @param {string} feature - The deprecated feature + * @param {string} replacement - The recommended replacement + * @param {string} [version='next major version'] - When feature will be removed + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {WarningEvent} New deprecation warning event + * + * @example + * const warning = WarningEvent.deprecation( + * 'legacyConfig.get()', + * 'config.getValue()', + * 'v2.0.0' + * ); + */ + static deprecation(feature, replacement, version = 'next major version', details = {}) { + return new WarningEvent( + `${feature} is deprecated and will be removed in ${version}. Use ${replacement} instead.`, + { + ...details, + feature, + replacement, + version, + category: 'deprecation' + }, + 'DEPRECATION_WARNING' + ); + } + + /** + * Create a configuration warning + * + * Factory method for configuration-related warnings such as missing + * optional settings or suboptimal configurations. + * + * @param {string} message - Configuration warning message + * @param {string} setting - The configuration setting involved + * @param {*} [currentValue=null] - Current value of the setting + * @param {*} [recommendedValue=null] - Recommended value + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {WarningEvent} New configuration warning event + */ + static configuration( + message, + setting, + currentValue = null, + recommendedValue = null, + details = {} + ) { + return new WarningEvent( + message, + { + ...details, + setting, + currentValue, + recommendedValue, + category: 'configuration' + }, + 'CONFIG_WARNING' + ); + } + + /** + * Create a performance warning + * + * Factory method for performance-related warnings such as slow operations + * or resource usage concerns. + * + * @param {string} message - Performance warning message + * @param {string} operation - The operation with performance concerns + * @param {number} [duration=null] - Operation duration in milliseconds + * @param {string} [recommendation=null] - Performance improvement suggestion + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {WarningEvent} New performance warning event + */ + static performance(message, operation, duration = null, recommendation = null, details = {}) { + return new WarningEvent( + message, + { + ...details, + operation, + duration, + recommendation, + category: 'performance' + }, + 'PERFORMANCE_WARNING' + ); + } + + /** + * Create a security warning + * + * Factory method for security-related warnings that don't rise to the level + * of errors but indicate potential security concerns. + * + * @param {string} message - Security warning message + * @param {string} concern - The specific security concern + * @param {string} [mitigation=null] - Suggested mitigation + * @param {import('./CommandEvent').EventDetails} [details={}] - Additional details + * @returns {WarningEvent} New security warning event + */ + static security(message, concern, mitigation = null, details = {}) { + return new WarningEvent( + message, + { + ...details, + concern, + mitigation, + category: 'security' + }, + 'SECURITY_WARNING' + ); + } + + /** + * Get warning severity level + * + * Determines warning severity based on warning type and category. + * + * @returns {string} Severity level: 'high', 'medium', 'low' + */ + getSeverity() { + if (this.code === 'SECURITY_WARNING') { + return 'high'; + } + + if (this.code === 'PERFORMANCE_WARNING') { + return 'medium'; + } + + if (this.code === 'DEPRECATION_WARNING') { + return 'medium'; + } + + if (this.code === 'CONFIG_WARNING') { + return 'low'; + } + + return 'medium'; + } + + /** + * Check if this is a deprecation warning + * + * @returns {boolean} True if this is a deprecation warning + */ + isDeprecationWarning() { + return this.code === 'DEPRECATION_WARNING' || this.details.category === 'deprecation'; + } + + /** + * Check if this is a configuration warning + * + * @returns {boolean} True if this is a configuration warning + */ + isConfigurationWarning() { + return this.code === 'CONFIG_WARNING' || this.details.category === 'configuration'; + } + + /** + * Check if this is a performance warning + * + * @returns {boolean} True if this is a performance warning + */ + isPerformanceWarning() { + return this.code === 'PERFORMANCE_WARNING' || this.details.category === 'performance'; + } + + /** + * Check if this is a security warning + * + * @returns {boolean} True if this is a security warning + */ + isSecurityWarning() { + return this.code === 'SECURITY_WARNING' || this.details.category === 'security'; + } + + /** + * Check if this warning requires immediate attention + * + * @returns {boolean} True if warning is high severity + */ + requiresImmediateAttention() { + return this.getSeverity() === 'high'; + } + + /** + * Convert to event data format expected by emit() + * + * Extends the base toEventData method to include warning-specific information + * for backward compatibility with existing warning event listeners. + * + * @returns {Object} Event data in the format expected by emit() + */ + toEventData() { + return { + ...super.toEventData(), + code: this.code, + severity: this.getSeverity(), + category: this.details.category + }; + } + + /** + * Get formatted warning message with severity indicator + * + * @returns {string} Formatted warning message + */ + getFormattedMessage() { + const severity = this.getSeverity().toUpperCase(); + return `[${severity} WARNING] ${this.message}`; + } +} + +export { WarningEvent }; +export default WarningEvent; diff --git a/starfleet/data-host-node/src/lib/events/index.js b/starfleet/data-host-node/src/lib/events/index.js new file mode 100644 index 0000000..1a8e59c --- /dev/null +++ b/starfleet/data-host-node/src/lib/events/index.js @@ -0,0 +1,292 @@ +/** + * Event System Index - Main Exports for D.A.T.A. CLI + * + * This module provides the main exports for the event system, including all + * event classes, utility functions, and backward compatibility with the existing + * CommandEvents.js implementation. + * + * @fileoverview Main exports and utilities for event-driven command architecture + * @author Supa Base 12 Engineering Team + * @version 1.0.0 + */ + +// Import individual event classes +import CommandEvent from './CommandEvent.js'; +import ProgressEvent from './ProgressEvent.js'; +import ErrorEvent from './ErrorEvent.js'; +import WarningEvent from './WarningEvent.js'; +import SuccessEvent from './SuccessEvent.js'; + +// Import additional event classes from the original CommandEvents.js for backward compatibility +import { + DirectoryEvent, + StartEvent, + StatusEvent, + CompleteEvent, + CancelledEvent, + BuildProgressEvent, + BuildStartEvent, + BuildCompleteEvent, + BuildFailedEvent +} from './CommandEvents.js'; + +/** + * Utility function to validate event types at runtime + * + * Provides runtime type checking for events, ensuring they are instances + * of the expected event class. This is the runtime equivalent of TypeScript + * type checking, using JavaScript's native instanceof operator. + * + * @param {*} event - The event to validate + * @param {Function} expectedClass - The expected event class constructor + * @throws {TypeError} If event is not an instance of expectedClass + * @returns {boolean} True if validation passes + * + * @example + * // Runtime validation in event handlers + * command.on('progress', (event) => { + * if (validateCommandEvent(event, ProgressEvent)) { + * console.log(`Progress: ${event.percentage}%`); + * } + * }); + */ +function validateCommandEvent(event, expectedClass) { + if (!(event instanceof expectedClass)) { + const actualType = event?.constructor?.name || typeof event; + const expectedType = expectedClass.name; + throw new TypeError(`Invalid event type: expected ${expectedType}, got ${actualType}`); + } + return true; +} + +/** + * Advanced runtime validation with detailed error reporting + * + * Extended validation that provides more detailed error information + * and handles edge cases for better debugging. + * + * @param {*} event - The event to validate + * @param {Function} expectedClass - The expected event class constructor + * @returns {Object} Validation result with success/error properties + * + * @example + * const validation = validateEventSafely(event, ProgressEvent); + * if (!validation.success) { + * console.warn('Event validation failed:', validation.error); + * } + */ +function validateEventSafely(event, expectedClass) { + try { + validateCommandEvent(event, expectedClass); + return { success: true, error: null }; + } catch (error) { + return { + success: false, + error: error.message, + actualType: event?.constructor?.name || typeof event, + expectedType: expectedClass.name + }; + } +} + +/** + * Factory function to create typed events with validation + * + * Creates events using a type string, providing a convenient way to + * instantiate events while maintaining type safety through the class system. + * + * @param {string} type - Event type string + * @param {...*} args - Arguments to pass to the event constructor + * @returns {CommandEvent} New event instance of the appropriate type + * @throws {Error} If event type is unknown + * + * @example + * // Create events using factory function + * const progressEvent = createCommandEvent('progress', 'Processing files', 50); + * const errorEvent = createCommandEvent('error', 'Connection failed', new Error('ECONNREFUSED')); + */ +function createCommandEvent(type, ...args) { + const eventClasses = { + // Core event classes (from separate files) + progress: ProgressEvent, + error: ErrorEvent, + warning: WarningEvent, + success: SuccessEvent, + + // Additional event classes (from CommandEvents.js) + directory: DirectoryEvent, + start: StartEvent, + status: StatusEvent, + complete: CompleteEvent, + cancelled: CancelledEvent, + 'build:progress': BuildProgressEvent, + 'build:start': BuildStartEvent, + 'build:complete': BuildCompleteEvent, + 'build:failed': BuildFailedEvent + }; + + const EventClass = eventClasses[type]; + if (!EventClass) { + throw new Error( + `Unknown event type: ${type}. Available types: ${Object.keys(eventClasses).join(', ')}` + ); + } + + return new EventClass(...args); +} + +/** + * Type guard functions for runtime event type checking + * + * Provides convenient type checking functions that can be used in + * event handlers to ensure proper event types. + */ +const EventTypeGuards = { + /** + * Check if event is a ProgressEvent + * @param {*} event - Event to check + * @returns {boolean} True if event is ProgressEvent + */ + isProgressEvent: (event) => event instanceof ProgressEvent, + + /** + * Check if event is an ErrorEvent + * @param {*} event - Event to check + * @returns {boolean} True if event is ErrorEvent + */ + isErrorEvent: (event) => event instanceof ErrorEvent, + + /** + * Check if event is a WarningEvent + * @param {*} event - Event to check + * @returns {boolean} True if event is WarningEvent + */ + isWarningEvent: (event) => event instanceof WarningEvent, + + /** + * Check if event is a SuccessEvent + * @param {*} event - Event to check + * @returns {boolean} True if event is SuccessEvent + */ + isSuccessEvent: (event) => event instanceof SuccessEvent, + + /** + * Check if event is any CommandEvent + * @param {*} event - Event to check + * @returns {boolean} True if event is CommandEvent or subclass + */ + isCommandEvent: (event) => event instanceof CommandEvent +}; + +/** + * Event listener wrapper that validates event types + * + * Creates a wrapper function that validates events before calling + * the actual listener, providing runtime type safety. + * + * @param {Function} listener - The actual event listener function + * @param {Function} expectedClass - Expected event class + * @param {boolean} [strict=true] - Whether to throw on validation failure + * @returns {Function} Wrapped listener with validation + * + * @example + * // Wrap listener with validation + * const safeListener = createValidatedListener( + * (event) => console.log(event.percentage), + * ProgressEvent + * ); + * command.on('progress', safeListener); + */ +function createValidatedListener(listener, expectedClass, strict = true) { + return function validatedListener(eventData) { + try { + // If eventData is already an instance of the expected class, use it directly + if (eventData instanceof expectedClass) { + return listener(eventData); + } + + // If it's a plain object (backward compatibility), validate structure + if (typeof eventData === 'object' && eventData.message && eventData.type) { + return listener(eventData); + } + + if (strict) { + throw new TypeError(`Expected ${expectedClass.name}, got ${typeof eventData}`); + } else { + console.warn(`Event validation failed: expected ${expectedClass.name}`); + return listener(eventData); + } + } catch (error) { + if (strict) { + throw error; + } else { + console.error('Event listener error:', error.message); + } + } + }; +} + +// Export all event classes and utilities +export { + // Base class + CommandEvent, + + // Core event classes (from separate files) + ProgressEvent, + ErrorEvent, + WarningEvent, + SuccessEvent, + + // Additional event classes (from CommandEvents.js for backward compatibility) + DirectoryEvent, + StartEvent, + StatusEvent, + CompleteEvent, + CancelledEvent, + BuildProgressEvent, + BuildStartEvent, + BuildCompleteEvent, + BuildFailedEvent, + + // Utilities + validateCommandEvent, + validateEventSafely, + createCommandEvent, + createValidatedListener, + EventTypeGuards +}; + +// Export type guard aliases for backward compatibility +export const isProgressEvent = EventTypeGuards.isProgressEvent; +export const isErrorEvent = EventTypeGuards.isErrorEvent; +export const isWarningEvent = EventTypeGuards.isWarningEvent; +export const isSuccessEvent = EventTypeGuards.isSuccessEvent; +export const isCommandEvent = EventTypeGuards.isCommandEvent; + +// Default export +export default { + CommandEvent, + ProgressEvent, + ErrorEvent, + WarningEvent, + SuccessEvent, + DirectoryEvent, + StartEvent, + StatusEvent, + CompleteEvent, + CancelledEvent, + BuildProgressEvent, + BuildStartEvent, + BuildCompleteEvent, + BuildFailedEvent, + validateCommandEvent, + validateEventSafely, + createCommandEvent, + createValidatedListener, + EventTypeGuards, + isProgressEvent, + isErrorEvent, + isWarningEvent, + isSuccessEvent, + isCommandEvent +}; diff --git a/starfleet/data-host-node/src/lib/events/runtime-validation-example.js b/starfleet/data-host-node/src/lib/events/runtime-validation-example.js new file mode 100644 index 0000000..f3bf258 --- /dev/null +++ b/starfleet/data-host-node/src/lib/events/runtime-validation-example.js @@ -0,0 +1,228 @@ +#!/usr/bin/env node + +/** + * Runtime Validation Example for D.A.T.A. Event System + * + * This example demonstrates the runtime validation capabilities of the + * JavaScript Event Classes and how they integrate with the existing + * Command class architecture. + * + * Run with: node src/lib/events/runtime-validation-example.js + */ + +import { EventEmitter } from 'events'; +import { + CommandEvent, + ProgressEvent, + ErrorEvent, + WarningEvent, + SuccessEvent, + validateCommandEvent, + validateEventSafely, + createCommandEvent, + createValidatedListener, + EventTypeGuards +} from './index.js'; + +/** + * Example Command class that demonstrates event system usage + */ +class ExampleCommand extends EventEmitter { + constructor() { + super(); + this.setupEventListeners(); + } + + setupEventListeners() { + // Example 1: Runtime validation using instanceof checks + this.on('progress', (eventData) => { + // Check if we received an actual ProgressEvent instance + if (eventData instanceof ProgressEvent) { + console.log(`โœ… Valid ProgressEvent: ${eventData.getFormattedProgress()}`); + console.log(` Message: ${eventData.message}`); + console.log(` Timestamp: ${eventData.timestamp.toISOString()}`); + } else { + console.log('โŒ Received non-ProgressEvent data:', typeof eventData); + } + }); + + // Example 2: Using type guard functions + this.on('error', (eventData) => { + if (EventTypeGuards.isErrorEvent(eventData)) { + console.log(`โœ… Valid ErrorEvent: ${eventData.message}`); + console.log(` Severity: ${eventData.getSeverity()}`); + console.log(` Code: ${eventData.code || 'No code'}`); + } else { + console.log('โŒ Received non-ErrorEvent data'); + } + }); + + // Example 3: Using validated listener wrapper + const safeWarningListener = createValidatedListener( + (event) => { + console.log(`โœ… Validated WarningEvent: ${event.getFormattedMessage()}`); + console.log(` Severity: ${event.getSeverity()}`); + console.log(` Requires attention: ${event.requiresImmediateAttention()}`); + }, + WarningEvent, + false // Non-strict mode for demonstration + ); + this.on('warning', safeWarningListener); + + // Example 4: Manual validation with error handling + this.on('success', (eventData) => { + try { + validateCommandEvent(eventData, SuccessEvent); + console.log(`โœ… Valid SuccessEvent: ${eventData.message}`); + console.log(` Duration: ${eventData.getFormattedDuration() || 'Unknown'}`); + console.log(` Has result: ${eventData.hasResult()}`); + } catch (error) { + console.log(`โŒ Validation failed: ${error.message}`); + } + }); + + // Example 5: Safe validation that doesn't throw + this.on('generic', (eventData) => { + const validation = validateEventSafely(eventData, CommandEvent); + if (validation.success) { + console.log(`โœ… Valid CommandEvent: ${eventData.toString()}`); + } else { + console.log(`โŒ Validation failed: ${validation.error}`); + console.log(` Expected: ${validation.expectedType}, Got: ${validation.actualType}`); + } + }); + } + + /** + * Demonstrate proper event emission with typed events + */ + async runDemonstration() { + console.log('\n=== D.A.T.A. Event System Runtime Validation Demo ===\n'); + + // 1. Emit a proper ProgressEvent + console.log('1. Emitting ProgressEvent:'); + const progressEvent = ProgressEvent.withPercentage('Processing files', 50, 100, { + operation: 'file-processing', + stage: 'validation' + }); + this.emit('progress', progressEvent); + + // 2. Emit a proper ErrorEvent + console.log('\n2. Emitting ErrorEvent:'); + const errorEvent = ErrorEvent.fromError( + new Error('Database connection timeout'), + 'Connection failed', + { database: 'postgresql', timeout: 5000 } + ); + this.emit('error', errorEvent); + + // 3. Emit a proper WarningEvent + console.log('\n3. Emitting WarningEvent:'); + const warningEvent = WarningEvent.deprecation('legacyMethod()', 'newMethod()', 'v2.0.0', { + component: 'DataProcessor' + }); + this.emit('warning', warningEvent); + + // 4. Emit a proper SuccessEvent + console.log('\n4. Emitting SuccessEvent:'); + const startTime = new Date(Date.now() - 1500); // Simulate 1.5s operation + const successEvent = SuccessEvent.withTiming('Operation completed successfully', startTime, { + filesProcessed: 42, + migrationsApplied: 3 + }); + this.emit('success', successEvent); + + // 5. Emit using factory function + console.log('\n5. Emitting event created with factory:'); + const factoryEvent = createCommandEvent('progress', 'Factory-created progress', 75, { + source: 'factory-method' + }); + this.emit('progress', factoryEvent); + + // 6. Demonstrate validation failure with wrong type + console.log('\n6. Demonstrating validation failure:'); + this.emit('progress', { message: 'Not a real ProgressEvent', percentage: 50 }); + + // 7. Demonstrate validation with plain objects (backward compatibility) + console.log('\n7. Testing backward compatibility:'); + this.emit('generic', new CommandEvent('test', 'Valid CommandEvent instance')); + this.emit('generic', { message: 'Plain object', type: 'test' }); // Should fail validation + + console.log('\n=== Demo Complete ===\n'); + } + + /** + * Demonstrate Command class integration + */ + demonstrateCommandIntegration() { + console.log('\n=== Command Class Integration Example ===\n'); + + // Show how the event system integrates with existing Command patterns + import Command from '../Command.js'; + + // Create a mock command to show integration + class MockCommand extends Command { + constructor() { + super(); + console.log('MockCommand created - events will be typed!'); + } + + async performExecute() { + // The Command class already uses typed events internally + this.progress('Starting mock operation', { step: 1 }); + + // Simulate some work + await new Promise((resolve) => setTimeout(resolve, 100)); + + this.warn('This is a test warning', { level: 'info' }); + this.success('Mock operation completed', { result: 'success' }); + + return { status: 'completed' }; + } + } + + // Set up listeners that use runtime validation + const mockCommand = new MockCommand(); + + mockCommand.on('progress', (eventData) => { + // eventData will be in the format emitted by Command.js + console.log(`Command progress: ${eventData.message}`); + console.log(` Type: ${eventData.type}`); + console.log(` Timestamp: ${eventData.timestamp}`); + }); + + mockCommand.on('warning', (eventData) => { + console.log(`Command warning: ${eventData.message}`); + console.log(` Data: ${JSON.stringify(eventData.data)}`); + }); + + mockCommand.on('success', (eventData) => { + console.log(`Command success: ${eventData.message}`); + console.log(` Data: ${JSON.stringify(eventData.data)}`); + }); + + // Execute the command + return mockCommand.execute(); + } +} + +/** + * Run the demonstration + */ +async function runDemo() { + try { + const example = new ExampleCommand(); + await example.runDemonstration(); + await example.demonstrateCommandIntegration(); + } catch (error) { + console.error('Demo failed:', error); + process.exit(1); + } +} + +// Run if this file is executed directly +if (require.main === module) { + runDemo().catch(console.error); +} + +export default { ExampleCommand, runDemo }; diff --git a/src/lib/migration/GitDeploymentTracker.js b/starfleet/data-host-node/src/lib/migration/GitDeploymentTracker.js similarity index 98% rename from src/lib/migration/GitDeploymentTracker.js rename to starfleet/data-host-node/src/lib/migration/GitDeploymentTracker.js index 2e8ea69..53a724a 100644 --- a/src/lib/migration/GitDeploymentTracker.js +++ b/starfleet/data-host-node/src/lib/migration/GitDeploymentTracker.js @@ -7,10 +7,10 @@ * @module GitDeploymentTracker */ -const { EventEmitter } = require('events'); -const ChildProcessWrapper = require('../ChildProcessWrapper'); -const path = require('path'); -const fs = require('fs').promises; +import { EventEmitter } from 'events'; +import ChildProcessWrapper from '../ChildProcessWrapper.js'; +import path from 'path'; +import fs from 'fs'.promises; /** * Git deployment tag prefix for D.A.T.A. deployments @@ -602,4 +602,4 @@ class GitDeploymentTracker extends EventEmitter { } } -module.exports = GitDeploymentTracker; \ No newline at end of file +export default GitDeploymentTracker; \ No newline at end of file diff --git a/src/lib/migration/MigrationOrchestrator.js b/starfleet/data-host-node/src/lib/migration/MigrationOrchestrator.js similarity index 97% rename from src/lib/migration/MigrationOrchestrator.js rename to starfleet/data-host-node/src/lib/migration/MigrationOrchestrator.js index 2007476..06d1f77 100644 --- a/src/lib/migration/MigrationOrchestrator.js +++ b/starfleet/data-host-node/src/lib/migration/MigrationOrchestrator.js @@ -14,15 +14,15 @@ * @module MigrationOrchestrator */ -const { EventEmitter } = require('events'); -const SupabaseCommand = require('../SupabaseCommand'); -const ASTMigrationEngine = require('./ASTMigrationEngine'); -const GitDeploymentTracker = require('./GitDeploymentTracker'); -const SchemaDiffAnalyzer = require('./SchemaDiffAnalyzer'); -const ChildProcessWrapper = require('../ChildProcessWrapper'); -const TestCoverageOrchestrator = require('../testing/TestCoverageOrchestrator'); -const path = require('path'); -const fs = require('fs').promises; +import { EventEmitter } from 'events'; +import SupabaseCommand from '../../../data-cli/src/lib/SupabaseCommand.js'; +import ASTMigrationEngine from '../../../data-core/src/migration/ASTMigrationEngine.js'; +import GitDeploymentTracker from './GitDeploymentTracker'; +import SchemaDiffAnalyzer from '../../../data-core/src/migration/SchemaDiffAnalyzer.js'; +import ChildProcessWrapper from '../ChildProcessWrapper.js'; +import TestCoverageOrchestrator from '../testing/TestCoverageOrchestrator.js'; +import path from 'path'; +import fs from 'fs'.promises; /** * Orchestrator workflow phases @@ -713,7 +713,7 @@ class MigrationOrchestrator extends SupabaseCommand { } // Export classes and constants -module.exports = { +export { MigrationOrchestrator, PHASES, OPERATIONS diff --git a/src/lib/testing/BatchProcessor.js b/starfleet/data-host-node/src/lib/testing/BatchProcessor.js similarity index 97% rename from src/lib/testing/BatchProcessor.js rename to starfleet/data-host-node/src/lib/testing/BatchProcessor.js index db31fe0..018d0f2 100644 --- a/src/lib/testing/BatchProcessor.js +++ b/starfleet/data-host-node/src/lib/testing/BatchProcessor.js @@ -1,9 +1,9 @@ /** * Memory-aware batch processor for D.A.T.A. CLI - * + * * Processes large datasets in batches with memory monitoring * and cleanup to prevent OOM errors. - * + * * @class BatchProcessor * @author D.A.T.A. Engineering Team */ @@ -27,7 +27,7 @@ class BatchProcessor { enableGC: options.enableGC || true, ...options }; - + this.processedBatches = 0; this.totalItems = 0; } @@ -44,10 +44,10 @@ class BatchProcessor { for (let i = 0; i < batches.length; i++) { const batch = batches[i]; - + // Check memory before processing batch const memBefore = MemoryMonitor.getMemoryUsage(); - + if (MemoryMonitor.shouldTriggerCleanup(memBefore.heapUsed, this.options.maxMemoryMB)) { await this.performCleanup(); } @@ -55,7 +55,7 @@ class BatchProcessor { // Process batch const batchResults = await processor(batch, i); results = results.concat(batchResults); - + this.processedBatches++; this.totalItems += batch.length; @@ -130,7 +130,7 @@ class BatchProcessor { * @returns {Promise} */ async yieldToEventLoop() { - return new Promise(resolve => setImmediate(resolve)); + return new Promise((resolve) => setImmediate(resolve)); } /** @@ -156,4 +156,4 @@ class BatchProcessor { } } -export default BatchProcessor; \ No newline at end of file +export default BatchProcessor; diff --git a/src/lib/testing/CoverageEnforcer.js b/starfleet/data-host-node/src/lib/testing/CoverageEnforcer.js similarity index 79% rename from src/lib/testing/CoverageEnforcer.js rename to starfleet/data-host-node/src/lib/testing/CoverageEnforcer.js index 7cdbfee..87ba3c0 100644 --- a/src/lib/testing/CoverageEnforcer.js +++ b/starfleet/data-host-node/src/lib/testing/CoverageEnforcer.js @@ -1,13 +1,13 @@ /** * Coverage Enforcer for D.A.T.A. - * - * Main enforcement engine that compares required vs actual coverage and + * + * Main enforcement engine that compares required vs actual coverage and * enforces coverage policies to prevent deployment of untested database changes. - * + * * @module CoverageEnforcer */ -const { EventEmitter } = require('events'); +import { EventEmitter } from 'events'; /** * Coverage enforcement levels @@ -15,9 +15,9 @@ const { EventEmitter } = require('events'); * @enum {string} */ const ENFORCEMENT_LEVELS = { - STRICT: 'STRICT', // Block any missing coverage - NORMAL: 'NORMAL', // Block critical missing coverage - LENIENT: 'LENIENT' // Warn but allow deployment + STRICT: 'STRICT', // Block any missing coverage + NORMAL: 'NORMAL', // Block critical missing coverage + LENIENT: 'LENIENT' // Warn but allow deployment }; /** @@ -27,9 +27,9 @@ const ENFORCEMENT_LEVELS = { */ const GAP_SEVERITY = { CRITICAL: 'CRITICAL', // Destructive operations without tests - HIGH: 'HIGH', // New tables/functions without tests - MEDIUM: 'MEDIUM', // Column/index changes without tests - LOW: 'LOW' // Minor changes without tests + HIGH: 'HIGH', // New tables/functions without tests + MEDIUM: 'MEDIUM', // Column/index changes without tests + LOW: 'LOW' // Minor changes without tests }; /** @@ -91,7 +91,7 @@ const GAP_SEVERITY = { class CoverageEnforcer extends EventEmitter { constructor(options = {}) { super(); - + // Default enforcement configuration this.config = { level: options.level || ENFORCEMENT_LEVELS.NORMAL, @@ -108,22 +108,22 @@ class CoverageEnforcer extends EventEmitter { bypassReason: options.bypassReason || null, ...options }; - + // Severity mapping for different operations this.operationSeverity = { - 'DROP_TABLE': GAP_SEVERITY.CRITICAL, - 'DROP_COLUMN': GAP_SEVERITY.CRITICAL, - 'TRUNCATE_TABLE': GAP_SEVERITY.CRITICAL, - 'CREATE_TABLE': GAP_SEVERITY.HIGH, - 'CREATE_FUNCTION': GAP_SEVERITY.HIGH, - 'ALTER_TABLE': GAP_SEVERITY.MEDIUM, - 'ALTER_COLUMN': GAP_SEVERITY.MEDIUM, - 'CREATE_INDEX': GAP_SEVERITY.MEDIUM, - 'CREATE_POLICY': GAP_SEVERITY.HIGH, - 'DROP_POLICY': GAP_SEVERITY.CRITICAL, - 'DEFAULT': GAP_SEVERITY.LOW + DROP_TABLE: GAP_SEVERITY.CRITICAL, + DROP_COLUMN: GAP_SEVERITY.CRITICAL, + TRUNCATE_TABLE: GAP_SEVERITY.CRITICAL, + CREATE_TABLE: GAP_SEVERITY.HIGH, + CREATE_FUNCTION: GAP_SEVERITY.HIGH, + ALTER_TABLE: GAP_SEVERITY.MEDIUM, + ALTER_COLUMN: GAP_SEVERITY.MEDIUM, + CREATE_INDEX: GAP_SEVERITY.MEDIUM, + CREATE_POLICY: GAP_SEVERITY.HIGH, + DROP_POLICY: GAP_SEVERITY.CRITICAL, + DEFAULT: GAP_SEVERITY.LOW }; - + // Test suggestions by object type this.testSuggestions = { table: ['has_table', 'table_privs_are', 'tables_are'], @@ -134,7 +134,7 @@ class CoverageEnforcer extends EventEmitter { trigger: ['has_trigger', 'trigger_is'] }; } - + /** * Main enforcement method - compares requirements vs coverage * @param {Array} requirements - Test requirements from analyzer @@ -144,45 +144,46 @@ class CoverageEnforcer extends EventEmitter { */ async enforce(requirements, coverage, options = {}) { this.emit('progress', { message: 'Starting coverage enforcement analysis...' }); - + // Merge options with config const config = { ...this.config, ...options }; - + // Filter ignored items const filteredRequirements = this.filterRequirements(requirements, config); const filteredCoverage = this.filterCoverage(coverage, config); - - this.emit('progress', { - message: `Analyzing ${filteredRequirements.length} requirements against ${filteredCoverage.length} coverage items` + + this.emit('progress', { + message: `Analyzing ${filteredRequirements.length} requirements against ${filteredCoverage.length} coverage items` }); - + // Compare coverage const comparison = await this.compareCoverage(filteredRequirements, filteredCoverage); - + // Analyze gaps const gaps = this.analyzeGaps(comparison.unmetRequirements, config); - + // Determine if deployment should be blocked const shouldBlock = this.shouldBlock(gaps, config); - + // Generate recommendations const recommendations = this.generateRecommendations(gaps, comparison, config); - + // Calculate statistics const statistics = this.calculateStatistics(filteredRequirements, filteredCoverage, gaps); - + const report = { enforcementLevel: config.level, totalRequirements: filteredRequirements.length, metRequirements: comparison.metRequirements.length, - coveragePercentage: Math.round((comparison.metRequirements.length / filteredRequirements.length) * 100) || 0, - gaps: gaps, - shouldBlock: shouldBlock, - recommendations: recommendations, - statistics: statistics, + coveragePercentage: + Math.round((comparison.metRequirements.length / filteredRequirements.length) * 100) || 0, + gaps, + shouldBlock, + recommendations, + statistics, bypassReason: config.bypassReason || null }; - + // Emit appropriate events if (shouldBlock) { this.emit('enforcement_failed', { @@ -197,17 +198,17 @@ class CoverageEnforcer extends EventEmitter { gaps: gaps.length }); } - + this.emit('complete', { message: 'Coverage enforcement analysis complete', - shouldBlock: shouldBlock, + shouldBlock, gaps: gaps.length, coverage: report.coveragePercentage }); - + return report; } - + /** * Generate normalized coverage key for consistent lookups * @param {Object} item - Item with schema, name, and type @@ -217,27 +218,27 @@ class CoverageEnforcer extends EventEmitter { _generateCoverageKey(item) { // Normalize schema (default to 'public' per PostgreSQL convention) const schema = (item.schema || 'public').toLowerCase().trim(); - + // Normalize name and type const name = (item.name || '').toLowerCase().trim(); const type = (item.type || '').toLowerCase().trim(); - + // Validate components if (!name) { - throw new Error(`Invalid coverage item: missing name property`); + throw new Error('Invalid coverage item: missing name property'); } if (!type) { - throw new Error(`Invalid coverage item: missing type property`); + throw new Error('Invalid coverage item: missing type property'); } - + // Use separator that won't appear in PostgreSQL identifiers const separator = '::'; - + // Escape any separator sequences in the components (shouldn't happen in valid identifiers) const escapedSchema = schema.replace(/::/g, '\\:\\:'); const escapedName = name.replace(/::/g, '\\:\\:'); const escapedType = type.replace(/::/g, '\\:\\:'); - + return `${escapedSchema}${separator}${escapedName}${separator}${escapedType}`; } @@ -249,10 +250,10 @@ class CoverageEnforcer extends EventEmitter { */ compareCoverage(requirements, coverage) { this.emit('progress', { message: 'Comparing requirements against actual coverage...' }); - + // Build coverage lookup for efficient matching const coverageLookup = new Map(); - coverage.forEach(item => { + coverage.forEach((item) => { try { const key = this._generateCoverageKey(item); if (!coverageLookup.has(key)) { @@ -260,53 +261,53 @@ class CoverageEnforcer extends EventEmitter { } coverageLookup.get(key).push(item); } catch (error) { - this.emit('warning', { + this.emit('warning', { message: `Skipping invalid coverage item: ${error.message}`, - item: item + item }); } }); - + const metRequirements = []; const unmetRequirements = []; - + for (const requirement of requirements) { try { const key = this._generateCoverageKey(requirement); const matchingCoverage = coverageLookup.get(key) || []; - + if (this.isRequirementMet(requirement, matchingCoverage)) { metRequirements.push({ - requirement: requirement, + requirement, coverage: matchingCoverage }); } else { unmetRequirements.push({ - requirement: requirement, + requirement, coverage: matchingCoverage }); } } catch (error) { this.emit('warning', { message: `Error processing requirement: ${error.message}`, - requirement: requirement + requirement }); // Treat as unmet if we can't process it unmetRequirements.push({ - requirement: requirement, + requirement, coverage: [], error: error.message }); } } - + return { - metRequirements: metRequirements, - unmetRequirements: unmetRequirements, - coverageLookup: coverageLookup + metRequirements, + unmetRequirements, + coverageLookup }; } - + /** * Check if a requirement is met by available coverage * @param {TestRequirement} requirement - The requirement to check @@ -317,26 +318,24 @@ class CoverageEnforcer extends EventEmitter { if (!coverage || coverage.length === 0) { return false; } - + // For basic requirements, any coverage is sufficient if (!requirement.requiredTests || requirement.requiredTests.length === 0) { return true; } - + // Check for specific required tests const availableTests = new Set(); - coverage.forEach(item => { + coverage.forEach((item) => { if (item.tests) { - item.tests.forEach(test => availableTests.add(test)); + item.tests.forEach((test) => availableTests.add(test)); } }); - + // All required tests must be present - return requirement.requiredTests.every(requiredTest => - availableTests.has(requiredTest) - ); + return requirement.requiredTests.every((requiredTest) => availableTests.has(requiredTest)); } - + /** * Analyze coverage gaps for severity and blocking status * @param {Array} unmetRequirements - Requirements without coverage @@ -345,32 +344,32 @@ class CoverageEnforcer extends EventEmitter { */ analyzeGaps(unmetRequirements, config) { this.emit('progress', { message: 'Analyzing coverage gaps...' }); - + const gaps = []; - + for (const unmet of unmetRequirements) { const requirement = unmet.requirement; const severity = this.assessGapSeverity(requirement); const isBlocking = this.isGapBlocking(severity, config); - + const gap = { - requirement: requirement, - severity: severity, + requirement, + severity, message: this.generateGapMessage(requirement), suggestions: this.generateTestSuggestions(requirement), - isBlocking: isBlocking, + isBlocking, availableCoverage: unmet.coverage || [] }; - + gaps.push(gap); } - + // Sort gaps by severity (most severe first) gaps.sort((a, b) => this.compareSeverity(b.severity, a.severity)); - + return gaps; } - + /** * Assess the severity of a coverage gap * @param {TestRequirement} requirement - The requirement @@ -382,11 +381,11 @@ class CoverageEnforcer extends EventEmitter { if (operationSeverity) { return operationSeverity; } - + // Fall back to requirement severity or default return requirement.severity || this.operationSeverity.DEFAULT; } - + /** * Determine if a gap should block deployment * @param {string} severity - Gap severity @@ -395,20 +394,20 @@ class CoverageEnforcer extends EventEmitter { */ isGapBlocking(severity, config) { switch (config.level) { - case ENFORCEMENT_LEVELS.STRICT: - return true; // Block all gaps - - case ENFORCEMENT_LEVELS.NORMAL: - return severity === GAP_SEVERITY.CRITICAL || severity === GAP_SEVERITY.HIGH; - - case ENFORCEMENT_LEVELS.LENIENT: - return severity === GAP_SEVERITY.CRITICAL; - - default: - return false; + case ENFORCEMENT_LEVELS.STRICT: + return true; // Block all gaps + + case ENFORCEMENT_LEVELS.NORMAL: + return severity === GAP_SEVERITY.CRITICAL || severity === GAP_SEVERITY.HIGH; + + case ENFORCEMENT_LEVELS.LENIENT: + return severity === GAP_SEVERITY.CRITICAL; + + default: + return false; } } - + /** * Determine if deployment should be blocked based on gaps * @param {Array} gaps - Coverage gaps @@ -425,11 +424,11 @@ class CoverageEnforcer extends EventEmitter { }); return false; } - + // Check if any gaps are blocking - return gaps.some(gap => gap.isBlocking); + return gaps.some((gap) => gap.isBlocking); } - + /** * Generate coverage gap report * @param {Array} gaps - Coverage gaps @@ -439,41 +438,48 @@ class CoverageEnforcer extends EventEmitter { if (!gaps || gaps.length === 0) { return 'โœ… No coverage gaps found - all requirements satisfied!'; } - + const lines = []; lines.push(`๐Ÿ“Š Coverage Gap Report (${gaps.length} gaps found)\n`); - + // Group by severity const bySeverity = gaps.reduce((acc, gap) => { if (!acc[gap.severity]) acc[gap.severity] = []; acc[gap.severity].push(gap); return acc; }, {}); - + // Report each severity level - for (const severity of [GAP_SEVERITY.CRITICAL, GAP_SEVERITY.HIGH, GAP_SEVERITY.MEDIUM, GAP_SEVERITY.LOW]) { + for (const severity of [ + GAP_SEVERITY.CRITICAL, + GAP_SEVERITY.HIGH, + GAP_SEVERITY.MEDIUM, + GAP_SEVERITY.LOW + ]) { const severityGaps = bySeverity[severity]; if (!severityGaps || severityGaps.length === 0) continue; - + const icon = this.getSeverityIcon(severity); - const blockingCount = severityGaps.filter(g => g.isBlocking).length; - - lines.push(`${icon} ${severity} (${severityGaps.length} gaps${blockingCount > 0 ? `, ${blockingCount} blocking` : ''})`); - - severityGaps.forEach(gap => { + const blockingCount = severityGaps.filter((g) => g.isBlocking).length; + + lines.push( + `${icon} ${severity} (${severityGaps.length} gaps${blockingCount > 0 ? `, ${blockingCount} blocking` : ''})` + ); + + severityGaps.forEach((gap) => { const blocking = gap.isBlocking ? ' ๐Ÿšซ' : ''; lines.push(` โ€ข ${gap.message}${blocking}`); - + if (gap.suggestions && gap.suggestions.length > 0) { lines.push(` Suggested tests: ${gap.suggestions.join(', ')}`); } }); lines.push(''); } - + return lines.join('\n'); } - + /** * Generate human-readable message for a coverage gap * @param {TestRequirement} requirement - The requirement @@ -482,25 +488,25 @@ class CoverageEnforcer extends EventEmitter { generateGapMessage(requirement) { const objectDesc = `${requirement.schema}.${requirement.name}`; const operation = requirement.operation?.toLowerCase() || 'change'; - + switch (requirement.type) { - case 'table': - return `Table ${objectDesc} (${operation}) lacks test coverage`; - case 'column': - return `Column ${objectDesc} (${operation}) lacks test coverage`; - case 'function': - return `Function ${objectDesc} (${operation}) lacks test coverage`; - case 'policy': - return `RLS Policy ${objectDesc} (${operation}) lacks test coverage`; - case 'index': - return `Index ${objectDesc} (${operation}) lacks test coverage`; - case 'trigger': - return `Trigger ${objectDesc} (${operation}) lacks test coverage`; - default: - return `${requirement.type} ${objectDesc} (${operation}) lacks test coverage`; + case 'table': + return `Table ${objectDesc} (${operation}) lacks test coverage`; + case 'column': + return `Column ${objectDesc} (${operation}) lacks test coverage`; + case 'function': + return `Function ${objectDesc} (${operation}) lacks test coverage`; + case 'policy': + return `RLS Policy ${objectDesc} (${operation}) lacks test coverage`; + case 'index': + return `Index ${objectDesc} (${operation}) lacks test coverage`; + case 'trigger': + return `Trigger ${objectDesc} (${operation}) lacks test coverage`; + default: + return `${requirement.type} ${objectDesc} (${operation}) lacks test coverage`; } } - + /** * Generate test suggestions for a requirement * @param {TestRequirement} requirement - The requirement @@ -508,7 +514,7 @@ class CoverageEnforcer extends EventEmitter { */ generateTestSuggestions(requirement) { const suggestions = this.testSuggestions[requirement.type] || []; - + // Add operation-specific suggestions if (requirement.operation === 'CREATE') { if (requirement.type === 'table') { @@ -517,10 +523,10 @@ class CoverageEnforcer extends EventEmitter { suggestions.unshift('has_function'); } } - + return [...new Set(suggestions)]; // Remove duplicates } - + /** * Generate recommendations for improving coverage * @param {Array} gaps - Coverage gaps @@ -530,9 +536,9 @@ class CoverageEnforcer extends EventEmitter { */ generateRecommendations(gaps, comparison, config) { const recommendations = []; - + // Critical gaps recommendation - const criticalGaps = gaps.filter(g => g.severity === GAP_SEVERITY.CRITICAL); + const criticalGaps = gaps.filter((g) => g.severity === GAP_SEVERITY.CRITICAL); if (criticalGaps.length > 0) { recommendations.push({ type: 'CRITICAL_COVERAGE', @@ -541,9 +547,9 @@ class CoverageEnforcer extends EventEmitter { gaps: criticalGaps.length }); } - + // High-priority gaps - const highGaps = gaps.filter(g => g.severity === GAP_SEVERITY.HIGH); + const highGaps = gaps.filter((g) => g.severity === GAP_SEVERITY.HIGH); if (highGaps.length > 0) { recommendations.push({ type: 'HIGH_PRIORITY_COVERAGE', @@ -552,9 +558,14 @@ class CoverageEnforcer extends EventEmitter { gaps: highGaps.length }); } - + // Coverage threshold recommendations - const coveragePercentage = Math.round((comparison.metRequirements.length / (comparison.metRequirements.length + comparison.unmetRequirements.length)) * 100) || 0; + const coveragePercentage = + Math.round( + (comparison.metRequirements.length / + (comparison.metRequirements.length + comparison.unmetRequirements.length)) * + 100 + ) || 0; if (coveragePercentage < config.thresholds.overall) { recommendations.push({ type: 'COVERAGE_THRESHOLD', @@ -564,7 +575,7 @@ class CoverageEnforcer extends EventEmitter { required: config.thresholds.overall }); } - + // Test organization recommendations if (gaps.length > 10) { recommendations.push({ @@ -574,7 +585,7 @@ class CoverageEnforcer extends EventEmitter { gaps: gaps.length }); } - + // Enforcement level recommendations if (config.level === ENFORCEMENT_LEVELS.LENIENT && criticalGaps.length > 0) { recommendations.push({ @@ -584,10 +595,10 @@ class CoverageEnforcer extends EventEmitter { currentLevel: config.level }); } - + return recommendations.sort((a, b) => this.comparePriority(a.priority, b.priority)); } - + /** * Calculate detailed coverage statistics * @param {Array} requirements - All requirements @@ -611,24 +622,25 @@ class CoverageEnforcer extends EventEmitter { gaps: { total: gaps.length, bySeverity: this.groupBy(gaps, 'severity'), - blocking: gaps.filter(g => g.isBlocking).length + blocking: gaps.filter((g) => g.isBlocking).length }, percentages: { overall: Math.round(((requirements.length - gaps.length) / requirements.length) * 100) || 0, byType: {} } }; - + // Calculate coverage percentages by type - Object.keys(stats.requirements.byType).forEach(type => { + Object.keys(stats.requirements.byType).forEach((type) => { const totalByType = stats.requirements.byType[type]; - const gapsByType = gaps.filter(g => g.requirement.type === type).length; - stats.percentages.byType[type] = Math.round(((totalByType - gapsByType) / totalByType) * 100) || 0; + const gapsByType = gaps.filter((g) => g.requirement.type === type).length; + stats.percentages.byType[type] = + Math.round(((totalByType - gapsByType) / totalByType) * 100) || 0; }); - + return stats; } - + /** * Filter requirements based on configuration * @param {Array} requirements - Requirements to filter @@ -636,21 +648,21 @@ class CoverageEnforcer extends EventEmitter { * @returns {Array} Filtered requirements */ filterRequirements(requirements, config) { - return requirements.filter(req => { + return requirements.filter((req) => { // Filter ignored schemas if (config.ignoredSchemas.includes(req.schema)) { return false; } - + // Filter ignored tables if (req.type === 'table' && config.ignoredTables.includes(req.name)) { return false; } - + return true; }); } - + /** * Filter coverage based on configuration * @param {Array} coverage - Coverage to filter @@ -658,20 +670,20 @@ class CoverageEnforcer extends EventEmitter { * @returns {Array} Filtered coverage */ filterCoverage(coverage, config) { - return coverage.filter(cov => { + return coverage.filter((cov) => { // Filter ignored schemas if (config.ignoredSchemas.includes(cov.schema)) { return false; } - + return true; }); } - + /** * Helper methods */ - + groupBy(array, property) { return array.reduce((acc, item) => { const key = item[property] || 'unknown'; @@ -679,30 +691,36 @@ class CoverageEnforcer extends EventEmitter { return acc; }, {}); } - + getSeverityIcon(severity) { switch (severity) { - case GAP_SEVERITY.CRITICAL: return '๐Ÿ”ด'; - case GAP_SEVERITY.HIGH: return '๐ŸŸ '; - case GAP_SEVERITY.MEDIUM: return '๐ŸŸก'; - case GAP_SEVERITY.LOW: return '๐ŸŸข'; - default: return 'โšช'; + case GAP_SEVERITY.CRITICAL: + return '๐Ÿ”ด'; + case GAP_SEVERITY.HIGH: + return '๐ŸŸ '; + case GAP_SEVERITY.MEDIUM: + return '๐ŸŸก'; + case GAP_SEVERITY.LOW: + return '๐ŸŸข'; + default: + return 'โšช'; } } - + compareSeverity(severity1, severity2) { - const levels = [GAP_SEVERITY.LOW, GAP_SEVERITY.MEDIUM, GAP_SEVERITY.HIGH, GAP_SEVERITY.CRITICAL]; + const levels = [ + GAP_SEVERITY.LOW, + GAP_SEVERITY.MEDIUM, + GAP_SEVERITY.HIGH, + GAP_SEVERITY.CRITICAL + ]; return levels.indexOf(severity1) - levels.indexOf(severity2); } - + comparePriority(priority1, priority2) { const priorities = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']; return priorities.indexOf(priority2) - priorities.indexOf(priority1); // Reverse order (highest first) } } -module.exports = { - CoverageEnforcer, - ENFORCEMENT_LEVELS, - GAP_SEVERITY -}; \ No newline at end of file +export { CoverageEnforcer, ENFORCEMENT_LEVELS, GAP_SEVERITY }; diff --git a/src/lib/testing/CoverageVisualizer.js b/starfleet/data-host-node/src/lib/testing/CoverageVisualizer.js similarity index 71% rename from src/lib/testing/CoverageVisualizer.js rename to starfleet/data-host-node/src/lib/testing/CoverageVisualizer.js index 791b536..3e83285 100644 --- a/src/lib/testing/CoverageVisualizer.js +++ b/starfleet/data-host-node/src/lib/testing/CoverageVisualizer.js @@ -1,11 +1,11 @@ /** * CoverageVisualizer - CLI visualization for test coverage status - * + * * Creates ASCII-based visualizations with Star Trek LCARS-style theming * for terminal output of coverage data, gaps, and progress indicators. */ -const chalk = require('chalk'); +import chalk from 'chalk'; /** * @typedef {Object} CoverageData @@ -38,23 +38,23 @@ class CoverageVisualizer { // LCARS color scheme this.colors = { // Primary LCARS colors - orange: chalk.rgb(255, 153, 0), // LCARS Orange - blue: chalk.rgb(153, 204, 255), // LCARS Light Blue - purple: chalk.rgb(204, 153, 255), // LCARS Purple - red: chalk.rgb(255, 102, 102), // LCARS Red - + orange: chalk.rgb(255, 153, 0), // LCARS Orange + blue: chalk.rgb(153, 204, 255), // LCARS Light Blue + purple: chalk.rgb(204, 153, 255), // LCARS Purple + red: chalk.rgb(255, 102, 102), // LCARS Red + // Coverage status colors covered: chalk.green, uncovered: chalk.red, warning: chalk.yellow, - + // UI elements - frame: chalk.rgb(0, 153, 255), // Frame blue - accent: chalk.rgb(255, 204, 0), // Accent yellow + frame: chalk.rgb(0, 153, 255), // Frame blue + accent: chalk.rgb(255, 204, 0), // Accent yellow text: chalk.white, dim: chalk.gray }; - + // LCARS-style box drawing characters this.chars = { horizontal: 'โ•', @@ -68,19 +68,19 @@ class CoverageVisualizer { teeUp: 'โ•ฉ', teeLeft: 'โ•ฃ', teeRight: 'โ• ', - + // Progress bar characters filled: 'โ–ˆ', empty: 'โ–‘', partial: 'โ–“', - + // Matrix characters covered: 'โ—', uncovered: 'โ—‹', partial: 'โ—' }; } - + /** * Display comprehensive coverage status * @param {CoverageData} coverage - Coverage data @@ -90,64 +90,79 @@ class CoverageVisualizer { this._displayHeader(); this._displayOverallStatus(coverage); this._displayCategoryBreakdown(coverage.categories); - + if (gaps && gaps.length > 0) { this._displayGaps(gaps); } - + this._displaySummary(coverage, gaps); this._displayFooter(); } - + /** * Create and display a coverage matrix visualization * @param {MatrixData} data - Matrix data structure */ formatMatrix(data) { console.log(this.colors.frame('\nโ•”โ•โ• COVERAGE MATRIX โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•—')); - + if (!data.rows || !data.columns || !data.matrix) { console.log(this.colors.red(' Invalid matrix data provided')); - console.log(this.colors.frame('โ•šโ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n')); + console.log( + this.colors.frame('โ•šโ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n') + ); return; } - + // Calculate column widths - const maxRowNameLength = Math.max(...data.rows.map(r => r.length), 8); - const colWidth = Math.max(3, Math.max(...data.columns.map(c => c.length))); - + const maxRowNameLength = Math.max(...data.rows.map((r) => r.length), 8); + const colWidth = Math.max(3, Math.max(...data.columns.map((c) => c.length))); + // Header row with column names const headerSpacing = ' '.repeat(maxRowNameLength + 2); - const headerRow = headerSpacing + data.columns - .map(col => this.colors.blue(col.padEnd(colWidth))) - .join(' '); + const headerRow = + headerSpacing + data.columns.map((col) => this.colors.blue(col.padEnd(colWidth))).join(' '); console.log('โ•‘ ' + headerRow + ' โ•‘'); - + // Separator line - const separatorLine = 'โ•‘ ' + 'โ”€'.repeat(maxRowNameLength) + 'โ”€โ”ผโ”€' + - data.columns.map(() => 'โ”€'.repeat(colWidth)).join('โ”€โ”ผโ”€') + ' โ•‘'; + const separatorLine = + 'โ•‘ ' + + 'โ”€'.repeat(maxRowNameLength) + + 'โ”€โ”ผโ”€' + + data.columns.map(() => 'โ”€'.repeat(colWidth)).join('โ”€โ”ผโ”€') + + ' โ•‘'; console.log(this.colors.frame(separatorLine)); - + // Data rows data.matrix.forEach((row, rowIndex) => { const rowName = data.rows[rowIndex].padEnd(maxRowNameLength); - const cells = row.map((covered, colIndex) => { - const char = covered ? this.chars.covered : this.chars.uncovered; - const color = covered ? this.colors.covered : this.colors.uncovered; - return color(char.padEnd(colWidth)); - }).join(' '); - + const cells = row + .map((covered, colIndex) => { + const char = covered ? this.chars.covered : this.chars.uncovered; + const color = covered ? this.colors.covered : this.colors.uncovered; + return color(char.padEnd(colWidth)); + }) + .join(' '); + console.log('โ•‘ ' + this.colors.text(rowName) + ' โ”‚ ' + cells + ' โ•‘'); }); - + // Legend console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); - console.log('โ•‘ ' + this.colors.covered(this.chars.covered) + ' Covered ' + - this.colors.uncovered(this.chars.uncovered) + ' Not Covered' + - ' '.repeat(39) + ' โ•‘'); - console.log(this.colors.frame('โ•šโ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n')); + console.log( + 'โ•‘ ' + + this.colors.covered(this.chars.covered) + + ' Covered ' + + this.colors.uncovered(this.chars.uncovered) + + ' Not Covered' + + ' '.repeat(39) + + ' โ•‘' + ); + console.log( + this.colors.frame('โ•šโ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•\n') + ); } - + /** * Display progress indicator during analysis * @param {number} current - Current progress @@ -158,40 +173,51 @@ class CoverageVisualizer { const percentage = Math.round((current / total) * 100); const barWidth = 30; const filledWidth = Math.round((current / total) * barWidth); - + // Create progress bar const filled = this.chars.filled.repeat(filledWidth); const empty = this.chars.empty.repeat(barWidth - filledWidth); const bar = this.colors.blue(filled) + this.colors.dim(empty); - + // Progress line with LCARS styling - const progressLine = - this.colors.orange('โ–ˆ ') + - this.colors.text(operation) + ': [' + bar + '] ' + - this.colors.accent(`${percentage}%`) + + const progressLine = + this.colors.orange('โ–ˆ ') + + this.colors.text(operation) + + ': [' + + bar + + '] ' + + this.colors.accent(`${percentage}%`) + this.colors.dim(` (${current}/${total})`); - + // Use carriage return to overwrite previous line process.stdout.write('\r' + progressLine + ' '.repeat(10)); - + // New line when complete if (current === total) { console.log(''); } } - + /** * Display LCARS-style header * @private */ _displayHeader() { - console.log(this.colors.frame('\nโ•”โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•—')); - console.log('โ•‘ ' + this.colors.orange('โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ') + ' ' + - this.colors.text('DATABASE COVERAGE ANALYSIS') + ' ' + - this.colors.orange('โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ') + ' โ•‘'); + console.log( + this.colors.frame('\nโ•”โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•—') + ); + console.log( + 'โ•‘ ' + + this.colors.orange('โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ') + + ' ' + + this.colors.text('DATABASE COVERAGE ANALYSIS') + + ' ' + + this.colors.orange('โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ') + + ' โ•‘' + ); console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); } - + /** * Display overall coverage status with progress bar * @private @@ -200,11 +226,11 @@ class CoverageVisualizer { const percentage = Math.round(coverage.percentage); const barWidth = 40; const filledWidth = Math.round((percentage / 100) * barWidth); - + // Color based on coverage level let statusColor = this.colors.covered; let statusText = 'OPTIMAL'; - + if (percentage < 50) { statusColor = this.colors.red; statusText = 'CRITICAL'; @@ -215,18 +241,29 @@ class CoverageVisualizer { statusColor = this.colors.blue; statusText = 'ACCEPTABLE'; } - + // Create visual progress bar const filled = this.chars.filled.repeat(filledWidth); const empty = this.chars.empty.repeat(barWidth - filledWidth); const bar = statusColor(filled) + this.colors.dim(empty); - - console.log('โ•‘ Overall Coverage: [' + bar + '] ' + - statusColor(`${percentage}%`) + ' ' + statusColor(statusText) + ' โ•‘'); - console.log('โ•‘ ' + this.colors.dim(`Items: ${coverage.covered}/${coverage.total} covered`) + - ' '.repeat(35) + ' โ•‘'); + + console.log( + 'โ•‘ Overall Coverage: [' + + bar + + '] ' + + statusColor(`${percentage}%`) + + ' ' + + statusColor(statusText) + + ' โ•‘' + ); + console.log( + 'โ•‘ ' + + this.colors.dim(`Items: ${coverage.covered}/${coverage.total} covered`) + + ' '.repeat(35) + + ' โ•‘' + ); } - + /** * Display coverage breakdown by category * @private @@ -235,44 +272,52 @@ class CoverageVisualizer { if (!categories || Object.keys(categories).length === 0) { return; } - + console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); - console.log('โ•‘ ' + this.colors.blue('COVERAGE BY CATEGORY') + - ' '.repeat(37) + ' โ•‘'); + console.log('โ•‘ ' + this.colors.blue('COVERAGE BY CATEGORY') + ' '.repeat(37) + ' โ•‘'); console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); - + Object.entries(categories).forEach(([category, percentage]) => { const barWidth = 20; const filledWidth = Math.round((percentage / 100) * barWidth); - + // Color based on percentage - const color = percentage >= 90 ? this.colors.covered : - percentage >= 75 ? this.colors.warning : - this.colors.uncovered; - + const color = + percentage >= 90 + ? this.colors.covered + : percentage >= 75 + ? this.colors.warning + : this.colors.uncovered; + const filled = this.chars.filled.repeat(filledWidth); const empty = this.chars.empty.repeat(barWidth - filledWidth); const bar = color(filled) + this.colors.dim(empty); - + const categoryName = category.padEnd(12); const percentageText = `${Math.round(percentage)}%`.padStart(4); - - console.log('โ•‘ ' + this.colors.text(categoryName) + - ' [' + bar + '] ' + - color(percentageText) + ' '.repeat(19) + ' โ•‘'); + + console.log( + 'โ•‘ ' + + this.colors.text(categoryName) + + ' [' + + bar + + '] ' + + color(percentageText) + + ' '.repeat(19) + + ' โ•‘' + ); }); } - + /** * Display coverage gaps with highlighting * @private */ _displayGaps(gaps) { console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); - console.log('โ•‘ ' + this.colors.red('COVERAGE GAPS DETECTED') + - ' '.repeat(35) + ' โ•‘'); + console.log('โ•‘ ' + this.colors.red('COVERAGE GAPS DETECTED') + ' '.repeat(35) + ' โ•‘'); console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); - + // Group gaps by category const groupedGaps = gaps.reduce((acc, gap) => { if (!acc[gap.category]) { @@ -281,47 +326,62 @@ class CoverageVisualizer { acc[gap.category].push(gap); return acc; }, {}); - + Object.entries(groupedGaps).forEach(([category, categoryGaps]) => { - console.log('โ•‘ ' + this.colors.warning(`${category.toUpperCase()}:`) + - ' '.repeat(55 - category.length) + ' โ•‘'); - - categoryGaps.slice(0, 5).forEach(gap => { // Limit to first 5 per category + console.log( + 'โ•‘ ' + + this.colors.warning(`${category.toUpperCase()}:`) + + ' '.repeat(55 - category.length) + + ' โ•‘' + ); + + categoryGaps.slice(0, 5).forEach((gap) => { + // Limit to first 5 per category const indicator = this.colors.red('โ—'); const name = gap.name.length > 40 ? gap.name.substring(0, 37) + '...' : gap.name; const reason = gap.reason ? ` (${gap.reason})` : ''; const maxReasonLength = Math.max(0, 54 - name.length - reason.length); - const truncatedReason = reason.length > maxReasonLength ? - reason.substring(0, maxReasonLength - 3) + '...' : reason; - - console.log('โ•‘ ' + indicator + ' ' + - this.colors.text(name) + - this.colors.dim(truncatedReason) + - ' '.repeat(Math.max(0, 54 - name.length - truncatedReason.length)) + ' โ•‘'); + const truncatedReason = + reason.length > maxReasonLength + ? reason.substring(0, maxReasonLength - 3) + '...' + : reason; + + console.log( + 'โ•‘ ' + + indicator + + ' ' + + this.colors.text(name) + + this.colors.dim(truncatedReason) + + ' '.repeat(Math.max(0, 54 - name.length - truncatedReason.length)) + + ' โ•‘' + ); }); - + if (categoryGaps.length > 5) { - console.log('โ•‘ ' + this.colors.dim(`... and ${categoryGaps.length - 5} more`) + - ' '.repeat(45) + ' โ•‘'); + console.log( + 'โ•‘ ' + + this.colors.dim(`... and ${categoryGaps.length - 5} more`) + + ' '.repeat(45) + + ' โ•‘' + ); } }); } - + /** * Display summary and recommendations * @private */ _displaySummary(coverage, gaps) { console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); - console.log('โ•‘ ' + this.colors.blue('ANALYSIS SUMMARY') + - ' '.repeat(41) + ' โ•‘'); + console.log('โ•‘ ' + this.colors.blue('ANALYSIS SUMMARY') + ' '.repeat(41) + ' โ•‘'); console.log(this.colors.frame('โ• โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•โ•ฃ')); - + // Status assessment const percentage = Math.round(coverage.percentage); let recommendation = ''; let priorityColor = this.colors.text; - + if (percentage >= 90) { recommendation = 'Coverage is excellent. Maintain current test standards.'; priorityColor = this.colors.covered; @@ -335,14 +395,14 @@ class CoverageVisualizer { recommendation = 'Low coverage detected. Immediate attention required.'; priorityColor = this.colors.red; } - + // Split long recommendations into multiple lines const maxLineLength = 55; const words = recommendation.split(' '); const lines = []; let currentLine = ''; - - words.forEach(word => { + + words.forEach((word) => { if ((currentLine + word).length <= maxLineLength) { currentLine = currentLine ? `${currentLine} ${word}` : word; } else { @@ -351,18 +411,21 @@ class CoverageVisualizer { } }); if (currentLine) lines.push(currentLine); - - lines.forEach(line => { - console.log('โ•‘ ' + priorityColor(line) + - ' '.repeat(Math.max(0, 57 - line.length)) + ' โ•‘'); + + lines.forEach((line) => { + console.log('โ•‘ ' + priorityColor(line) + ' '.repeat(Math.max(0, 57 - line.length)) + ' โ•‘'); }); - + if (gaps && gaps.length > 0) { - console.log('โ•‘ ' + this.colors.dim(`Priority: Address ${gaps.length} identified gaps`) + - ' '.repeat(25) + ' โ•‘'); + console.log( + 'โ•‘ ' + + this.colors.dim(`Priority: Address ${gaps.length} identified gaps`) + + ' '.repeat(25) + + ' โ•‘' + ); } } - + /** * Display LCARS-style footer * @private @@ -373,4 +436,4 @@ class CoverageVisualizer { } } -module.exports = CoverageVisualizer; \ No newline at end of file +export default CoverageVisualizer; diff --git a/src/lib/testing/MemoryMonitor.js b/starfleet/data-host-node/src/lib/testing/MemoryMonitor.js similarity index 92% rename from src/lib/testing/MemoryMonitor.js rename to starfleet/data-host-node/src/lib/testing/MemoryMonitor.js index 588efd5..2fe8e73 100644 --- a/src/lib/testing/MemoryMonitor.js +++ b/starfleet/data-host-node/src/lib/testing/MemoryMonitor.js @@ -1,9 +1,9 @@ /** * Memory monitoring utilities for D.A.T.A. CLI - * + * * Provides static methods for monitoring and managing memory usage * to prevent OOM errors when processing large datasets. - * + * * @class MemoryMonitor * @author D.A.T.A. Engineering Team */ @@ -19,7 +19,7 @@ class MemoryMonitor { rss: Math.round(usage.rss / 1024 / 1024), // MB heapUsed: Math.round(usage.heapUsed / 1024 / 1024), // MB heapTotal: Math.round(usage.heapTotal / 1024 / 1024), // MB - external: Math.round(usage.external / 1024 / 1024), // MB + external: Math.round(usage.external / 1024 / 1024) // MB }; } @@ -45,7 +45,7 @@ class MemoryMonitor { * @static */ static shouldTriggerCleanup(currentMB, maxMB) { - return currentMB > (maxMB * 0.8); // Trigger at 80% of max + return currentMB > maxMB * 0.8; // Trigger at 80% of max } /** @@ -72,4 +72,4 @@ class MemoryMonitor { } } -export default MemoryMonitor; \ No newline at end of file +export default MemoryMonitor; diff --git a/src/lib/testing/StreamingCoverageDatabase.js b/starfleet/data-host-node/src/lib/testing/StreamingCoverageDatabase.js similarity index 98% rename from src/lib/testing/StreamingCoverageDatabase.js rename to starfleet/data-host-node/src/lib/testing/StreamingCoverageDatabase.js index f8e20d6..f8ff59a 100644 --- a/src/lib/testing/StreamingCoverageDatabase.js +++ b/starfleet/data-host-node/src/lib/testing/StreamingCoverageDatabase.js @@ -1,9 +1,9 @@ /** * Streaming coverage database implementation for D.A.T.A. CLI - * + * * Provides memory-efficient storage for large coverage datasets with * overflow protection and optional compression. - * + * * @class StreamingCoverageDatabase * @author D.A.T.A. Engineering Team */ @@ -22,7 +22,7 @@ class StreamingCoverageDatabase { batchSize: options.batchSize || 100, ...options }; - + this.objectCounts = new Map(); this.compressed = new Map(); this.overflow = new Set(); // Track overflowed object types @@ -38,7 +38,7 @@ class StreamingCoverageDatabase { */ addObject(objectType, objectName, data) { const count = this.objectCounts.get(objectType) || 0; - + if (count >= this.options.maxObjectsPerType) { this.overflow.add(objectType); return false; // Reject to prevent memory overflow @@ -49,14 +49,14 @@ class StreamingCoverageDatabase { this.data.set(objectType, new Map()); } this.data.get(objectType).set(objectName, data); - + this.objectCounts.set(objectType, count + 1); - + // Auto-compress if enabled and threshold reached if (this.options.enableCompression && count > this.options.maxObjectsPerType * 0.7) { this.compress(objectType); } - + return true; } @@ -88,11 +88,11 @@ class StreamingCoverageDatabase { */ compress(objectType) { if (this.compressed.has(objectType)) return; - + // TODO: Implement actual compression logic // For now, just mark as compressed this.compressed.set(objectType, Date.now()); - + // In production, you might: // 1. Convert Map to more compact structure // 2. Remove redundant data @@ -150,4 +150,4 @@ class StreamingCoverageDatabase { } } -export default StreamingCoverageDatabase; \ No newline at end of file +export default StreamingCoverageDatabase; diff --git a/src/lib/testing/TestCoverageOrchestrator.js b/starfleet/data-host-node/src/lib/testing/TestCoverageOrchestrator.js similarity index 96% rename from src/lib/testing/TestCoverageOrchestrator.js rename to starfleet/data-host-node/src/lib/testing/TestCoverageOrchestrator.js index d911319..1e9fa61 100644 --- a/src/lib/testing/TestCoverageOrchestrator.js +++ b/starfleet/data-host-node/src/lib/testing/TestCoverageOrchestrator.js @@ -8,13 +8,13 @@ * @module TestCoverageOrchestrator */ -const { EventEmitter } = require('events'); -const TestRequirementAnalyzer = require('./TestRequirementAnalyzer'); -const pgTAPTestScanner = require('./pgTAPTestScanner'); -const CoverageEnforcer = require('./CoverageEnforcer'); -const TestTemplateGenerator = require('./TestTemplateGenerator'); -const path = require('path'); -const fs = require('fs').promises; +import { EventEmitter } from 'events'; +import TestRequirementAnalyzer from './TestRequirementAnalyzer'; +import pgTAPTestScanner from './pgTAPTestScanner'; +import CoverageEnforcer from './CoverageEnforcer'; +import TestTemplateGenerator from './TestTemplateGenerator'; +import path from 'path'; +import fs from 'fs'.promises; /** * @typedef {Object} CoverageCheckResult @@ -331,4 +331,4 @@ class TestCoverageOrchestrator extends EventEmitter { } } -module.exports = TestCoverageOrchestrator; \ No newline at end of file +export default TestCoverageOrchestrator; \ No newline at end of file diff --git a/src/lib/testing/TestTemplateGenerator.js b/starfleet/data-host-node/src/lib/testing/TestTemplateGenerator.js similarity index 91% rename from src/lib/testing/TestTemplateGenerator.js rename to starfleet/data-host-node/src/lib/testing/TestTemplateGenerator.js index 767e787..e69682f 100644 --- a/src/lib/testing/TestTemplateGenerator.js +++ b/starfleet/data-host-node/src/lib/testing/TestTemplateGenerator.js @@ -1,12 +1,12 @@ /** * TestTemplateGenerator with Pattern Library - * + * * Generates pgTAP test templates for missing coverage based on requirements. * Creates properly structured and formatted test SQL files following project conventions. * Includes a comprehensive pattern library for consistent test generation. */ -const TestPatternLibrary = require('./TestPatternLibrary'); +import TestPatternLibrary from './TestPatternLibrary'; /** * @typedef {Object} TestRequirement @@ -181,7 +181,6 @@ class TestTemplateGenerator { summary[requirement.type] = 0; } summary[requirement.type]++; - } catch (error) { errors.push({ index, @@ -245,29 +244,29 @@ class TestTemplateGenerator { generateEnhancedTemplate(requirement, additionalPatterns = []) { const errors = []; const warnings = []; - + // Create checkpoint for rollback const checkpoint = { requirement: JSON.parse(JSON.stringify(requirement)), timestamp: Date.now() }; - + try { // Start with base template const baseTemplate = this.generateTemplate(requirement); if (!baseTemplate || !baseTemplate.content) { throw new Error('Failed to generate base template'); } - + // Get recommended patterns for this test type const recommendedPatterns = this.getRecommendedPatterns(requirement.type); const allPatterns = [...recommendedPatterns]; - + // Add any additional patterns requested with error handling for (const patternName of additionalPatterns) { try { const pattern = this.getPattern(patternName); - if (pattern && !allPatterns.find(p => p.name === patternName)) { + if (pattern && !allPatterns.find((p) => p.name === patternName)) { allPatterns.push(pattern); } else if (!pattern) { warnings.push(`Pattern '${patternName}' not found in library`); @@ -280,23 +279,29 @@ class TestTemplateGenerator { // Extract variables from requirement for pattern rendering const variables = this.extractPatternVariables(requirement); - + // Generate enhanced content by incorporating relevant patterns let enhancedContent = baseTemplate.content; - + try { // Add pattern-based enhancements with error recovery - const patternEnhancements = this.generatePatternEnhancements(requirement, allPatterns, variables); + const patternEnhancements = this.generatePatternEnhancements( + requirement, + allPatterns, + variables + ); if (patternEnhancements.trim()) { - enhancedContent += '\n\n-- =========================================================================\n'; + enhancedContent += + '\n\n-- =========================================================================\n'; enhancedContent += '-- ENHANCED PATTERNS FROM LIBRARY\n'; - enhancedContent += '-- =========================================================================\n\n'; + enhancedContent += + '-- =========================================================================\n\n'; enhancedContent += patternEnhancements; } } catch (patternError) { - errors.push({ - phase: 'pattern_enhancement', - error: patternError.message + errors.push({ + phase: 'pattern_enhancement', + error: patternError.message }); // Continue with base template content if pattern enhancement fails enhancedContent = baseTemplate.content; @@ -308,7 +313,7 @@ class TestTemplateGenerator { content: this.formatTest(enhancedContent), metadata: { ...baseTemplate.metadata, - patternsUsed: allPatterns.map(p => p.name), + patternsUsed: allPatterns.map((p) => p.name), enhancementLevel: 'advanced', generationMethod: 'pattern-enhanced', errors: errors.length > 0 ? errors : undefined, @@ -322,15 +327,16 @@ class TestTemplateGenerator { } return enhancedTemplate; - } catch (enhancementError) { // Rollback to basic template if enhancement completely fails - console.warn(`Enhancement failed for ${requirement.type} test '${requirement.name}': ${enhancementError.message}`); + console.warn( + `Enhancement failed for ${requirement.type} test '${requirement.name}': ${enhancementError.message}` + ); console.warn('Falling back to basic template generation'); - + try { const basicTemplate = this.generateTemplate(checkpoint.requirement); - + // Validate basic template before returning if (!this._validateTemplate(basicTemplate)) { throw new Error('Basic template fallback also failed validation'); @@ -347,7 +353,9 @@ class TestTemplateGenerator { } }; } catch (fallbackError) { - throw new Error(`Both enhanced and basic template generation failed: Enhancement: ${enhancementError.message}, Fallback: ${fallbackError.message}`); + throw new Error( + `Both enhanced and basic template generation failed: Enhancement: ${enhancementError.message}, Fallback: ${fallbackError.message}` + ); } } } @@ -386,11 +394,12 @@ class TestTemplateGenerator { } // Check for pgTAP plan statement (could be SELECT plan() or RETURN NEXT tap.plan()) - const hasPlan = content.includes('SELECT plan(') || - content.includes('select plan(') || - content.includes('tap.plan(') || - content.includes('TAP.PLAN('); - + const hasPlan = + content.includes('SELECT plan(') || + content.includes('select plan(') || + content.includes('tap.plan(') || + content.includes('TAP.PLAN('); + if (!hasPlan) { console.error('Template validation failed: Missing pgTAP plan() statement'); return false; @@ -400,15 +409,18 @@ class TestTemplateGenerator { const hasEnd = content.includes('END;') || content.includes('end;'); const hasRollback = content.includes('ROLLBACK;') || content.includes('rollback;'); const hasCommit = content.includes('COMMIT;') || content.includes('commit;'); - + if (!hasEnd && !hasRollback && !hasCommit) { - console.error('Template validation failed: Missing proper ending statement (END, ROLLBACK, or COMMIT)'); + console.error( + 'Template validation failed: Missing proper ending statement (END, ROLLBACK, or COMMIT)' + ); return false; } // Validate that content has at least one actual test function call - const testFunctionPattern = /(tap\.|^|\s)(ok|is|isnt|like|unlike|pass|fail|throws_ok|lives_ok|cmp_ok|is_empty|isnt_empty|has_table|has_column|has_function|has_view|has_trigger|has_index)\s*\(/i; - + const testFunctionPattern = + /(tap\.|^|\s)(ok|is|isnt|like|unlike|pass|fail|throws_ok|lives_ok|cmp_ok|is_empty|isnt_empty|has_table|has_column|has_function|has_view|has_trigger|has_index)\s*\(/i; + if (!testFunctionPattern.test(content)) { console.error('Template validation failed: No pgTAP test functions found in content'); return false; @@ -420,7 +432,7 @@ class TestTemplateGenerator { /;\s*DELETE\s+FROM\s+(?!.*WHERE)/i, /;\s*UPDATE\s+.*SET\s+.*(?!WHERE)/i, /UNION\s+SELECT/i, - /--\s*'[^']*'[^;]*;/ // SQL comments with quotes followed by statements (more specific injection pattern) + /--\s*'[^']*'[^;]*;/ // SQL comments with quotes followed by statements (more specific injection pattern) ]; for (const pattern of suspiciousPatterns) { @@ -432,27 +444,31 @@ class TestTemplateGenerator { // Validate metadata structure const metadata = template.metadata; - + // Check for name (required in all templates) if (!metadata.name || typeof metadata.name !== 'string') { console.error('Template validation failed: Metadata missing name'); return false; } - // Check for schema (required in all templates) + // Check for schema (required in all templates) if (!metadata.schema || typeof metadata.schema !== 'string') { console.error('Template validation failed: Metadata missing schema'); return false; } // Check for reasonable plan count - if (metadata.planCount && (typeof metadata.planCount !== 'number' || metadata.planCount < 1 || metadata.planCount > 1000)) { + if ( + metadata.planCount && + (typeof metadata.planCount !== 'number' || + metadata.planCount < 1 || + metadata.planCount > 1000) + ) { console.error('Template validation failed: Invalid planCount in metadata'); return false; } return true; - } catch (validationError) { console.error(`Template validation failed with exception: ${validationError.message}`); return false; @@ -467,35 +483,35 @@ class TestTemplateGenerator { generateBestPracticesDoc(testType) { const practices = this.patternLibrary.getBestPractices(testType); const examples = this.patternLibrary.getUsageExamples(testType); - - let doc = `-- =========================================================================\n`; + + let doc = '-- =========================================================================\n'; doc += `-- BEST PRACTICES FOR ${testType.toUpperCase()} TESTS\n`; - doc += `-- =========================================================================\n\n`; - + doc += '-- =========================================================================\n\n'; + if (practices.length > 0) { - doc += `-- Best Practices:\n`; - practices.forEach(practice => { + doc += '-- Best Practices:\n'; + practices.forEach((practice) => { doc += `-- โ€ข ${practice}\n`; }); - doc += `\n`; + doc += '\n'; } - + if (examples.length > 0) { - doc += `-- Usage Examples:\n`; - examples.forEach(example => { + doc += '-- Usage Examples:\n'; + examples.forEach((example) => { doc += `-- โ€ข ${example}\n`; }); - doc += `\n`; + doc += '\n'; } - + const recommendedPatterns = this.getRecommendedPatterns(testType); if (recommendedPatterns.length > 0) { - doc += `-- Recommended Patterns:\n`; - recommendedPatterns.forEach(pattern => { + doc += '-- Recommended Patterns:\n'; + recommendedPatterns.forEach((pattern) => { doc += `-- โ€ข ${pattern.name}: ${pattern.description}\n`; }); } - + return doc; } @@ -523,7 +539,7 @@ const requirement = { }; const template = generator.generateTemplate(requirement);` }, - + enhancedUsage: { description: 'Enhanced template generation with patterns', code: `const generator = new TestTemplateGenerator(); @@ -543,7 +559,7 @@ const enhancedTemplate = generator.generateEnhancedTemplate( ['privilege_escalation_test'] // Additional patterns );` }, - + patternAccess: { description: 'Direct pattern access and customization', code: `const generator = new TestTemplateGenerator(); @@ -558,7 +574,7 @@ const securityPatterns = generator.getPatternsByCategory('security_testing'); const variables = { schema: 'public', tableName: 'posts' }; const rendered = generator.renderPattern('table_exists_basic', variables);` }, - + documentationGeneration: { description: 'Generate documentation and best practices', code: `const generator = new TestTemplateGenerator(); @@ -569,7 +585,7 @@ const bestPractices = generator.generateBestPracticesDoc('rls'); // Generate complete pattern library documentation const libraryDoc = generator.generatePatternLibraryDoc();` }, - + batchGeneration: { description: 'Batch generation with pattern enhancement', code: `const generator = new TestTemplateGenerator(); @@ -602,9 +618,9 @@ const batchResult = generator.generateBatch(requirements);` // Remove excessive blank lines and normalize line endings let formatted = template - .replace(/\r\n/g, '\n') // Normalize line endings - .replace(/\n{3,}/g, '\n\n') // Reduce multiple blank lines to max 2 - .trim(); // Remove leading/trailing whitespace + .replace(/\r\n/g, '\n') // Normalize line endings + .replace(/\n{3,}/g, '\n\n') // Reduce multiple blank lines to max 2 + .trim(); // Remove leading/trailing whitespace // Ensure proper pgTAP structure formatting formatted = this.formatPgTapStructure(formatted); @@ -674,12 +690,12 @@ const batchResult = generator.generateBatch(requirements);` const functionName = requirement.name; const testFunctionName = `run_${functionName}_tests`; const planCount = this.calculatePlanCount(requirement, 'rpc'); - + // Build parameter placeholders if parameters are specified const hasParams = requirement.parameters && requirement.parameters.length > 0; - const paramPlaceholder = hasParams ? - `(${requirement.parameters.map(() => 'TODO: param').join(', ')})` : - '()'; + const paramPlaceholder = hasParams + ? `(${requirement.parameters.map(() => 'TODO: param').join(', ')})` + : '()'; return `-- ========================================================================= -- RPC FUNCTION TESTS: ${functionName} @@ -722,7 +738,7 @@ BEGIN RETURN NEXT tap.has_function( '${schema}', '${functionName}', - ${hasParams ? `ARRAY[${requirement.parameters.map(p => `'${p}'`).join(', ')}]` : 'ARRAY[]::text[]'}, + ${hasParams ? `ARRAY[${requirement.parameters.map((p) => `'${p}'`).join(', ')}]` : 'ARRAY[]::text[]'}, 'Function ${functionName} has correct signature' ); @@ -774,11 +790,11 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${functionName} RPC const tableName = requirement.name; const testFunctionName = `run_${tableName}_rls_tests`; const planCount = this.calculatePlanCount(requirement, 'rls'); - + // Extract policy metadata if available const policies = requirement.metadata?.policies || []; const testScenarios = requirement.metadata?.testScenarios || []; - + // Generate core RLS tests let rlsTests = this.generateRlsEnablementTests(schema, tableName); rlsTests += this.generatePolicyExistenceTests(schema, tableName, policies); @@ -981,7 +997,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${constraintName} c const schema = requirement.schema || 'public'; const functionName = requirement.name; const testFunctionName = `run_${functionName}_function_tests`; - + // Extract metadata with defaults const metadata = requirement.metadata || {}; const parameterTypes = metadata.parameterTypes || []; @@ -991,16 +1007,16 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${constraintName} c const requiresSecurityTesting = metadata.requiresSecurityTesting || false; const testCases = metadata.testCases || []; const isVolatile = metadata.isVolatile || false; - + // Calculate plan count based on test complexity - let planCount = this.calculateFunctionPlanCount(requirement, metadata); - + const planCount = this.calculateFunctionPlanCount(requirement, metadata); + // Build parameter signature for testing const hasParams = parameterTypes.length > 0; - const parameterSignature = hasParams ? - `ARRAY[${parameterTypes.map(type => `'${type}'`).join(', ')}]` : - 'ARRAY[]::text[]'; - + const parameterSignature = hasParams + ? `ARRAY[${parameterTypes.map((type) => `'${type}'`).join(', ')}]` + : 'ARRAY[]::text[]'; + // Generate sample test parameters based on types const sampleParams = this.generateSampleParameters(parameterTypes); const invalidParams = this.generateInvalidParameters(parameterTypes); @@ -1036,10 +1052,14 @@ BEGIN -- Plan our tests (adjust count as needed based on metadata) RETURN NEXT tap.plan(${planCount}); - ${requiresSecurityTesting ? `-- Setup: Create test users for security testing + ${ + requiresSecurityTesting + ? `-- Setup: Create test users for security testing v_admin_id := test.create_test_admin(); v_user_id := test.create_test_user(); - ` : ''} + ` + : '' +} -- =================================================================== -- BASIC FUNCTION EXISTENCE AND SIGNATURE TESTS -- =================================================================== @@ -1051,21 +1071,25 @@ BEGIN 'Function ${functionName} exists' ); - ${hasParams ? `-- Test 2: Function has correct parameter signature + ${ + hasParams + ? `-- Test 2: Function has correct parameter signature RETURN NEXT tap.has_function( '${schema}', '${functionName}', ${parameterSignature}, 'Function ${functionName} has correct parameter types: ${parameterTypes.join(', ')}' ); - ` : `-- Test 2: Function has no parameters + ` + : `-- Test 2: Function has no parameters RETURN NEXT tap.has_function( '${schema}', '${functionName}', ARRAY[]::text[], 'Function ${functionName} takes no parameters' ); - `} + ` +} -- Test 3: Function returns correct type RETURN NEXT tap.function_returns( '${schema}', @@ -1075,7 +1099,9 @@ BEGIN 'Function ${functionName} returns ${returnType}' ); - ${language !== 'sql' ? `-- Test 4: Function uses correct language + ${ + language !== 'sql' + ? `-- Test 4: Function uses correct language RETURN NEXT tap.function_lang_is( '${schema}', '${functionName}', @@ -1083,23 +1109,29 @@ BEGIN '${language}', 'Function ${functionName} is written in ${language}' ); - ` : ''} + ` + : '' +} - ${metadata.securityDefiner ? `-- Test 5: Function is security definer + ${ + metadata.securityDefiner + ? `-- Test 5: Function is security definer RETURN NEXT tap.is_definer( '${schema}', '${functionName}', ${hasParams ? parameterSignature + ',' : ''} 'Function ${functionName} is security definer' ); - ` : `-- Test 5: Function is NOT security definer (security invoker) + ` + : `-- Test 5: Function is NOT security definer (security invoker) RETURN NEXT tap.isnt_definer( '${schema}', '${functionName}', ${hasParams ? parameterSignature + ',' : ''} 'Function ${functionName} is security invoker' ); - `} + ` +} -- =================================================================== -- BEHAVIORAL TESTS WITH SAMPLE INPUTS @@ -1120,36 +1152,50 @@ BEGIN ); END; - ${testCases.length > 0 ? testCases.map((testCase, index) => ` + ${ + testCases.length > 0 + ? testCases + .map( + (testCase, index) => ` -- Test ${7 + index}: Custom test case - ${testCase.description || `Test case ${index + 1}`} BEGIN ${testCase.input ? `SELECT ${schema}.${functionName}(${testCase.input}) INTO v_result;` : `SELECT ${schema}.${functionName}() INTO v_result;`} - ${testCase.expectedOutput !== undefined ? `RETURN NEXT tap.is( + ${ + testCase.expectedOutput !== undefined + ? `RETURN NEXT tap.is( v_result, ${typeof testCase.expectedOutput === 'string' ? `'${testCase.expectedOutput}'` : testCase.expectedOutput}::${returnType}, 'Function ${functionName} returns expected result: ${testCase.description || `test case ${index + 1}`}' - );` : `RETURN NEXT tap.ok( + );` + : `RETURN NEXT tap.ok( v_result IS NOT NULL, 'Function ${functionName} executes successfully: ${testCase.description || `test case ${index + 1}`}' - );`} + );` +} EXCEPTION WHEN OTHERS THEN RETURN NEXT tap.fail( 'Function ${functionName} test case failed: ${testCase.description || `test case ${index + 1}`} - ' || SQLERRM ); END; - `).join('') : ''} + ` + ) + .join('') + : '' +} -- =================================================================== -- ERROR CONDITION AND VALIDATION TESTS -- =================================================================== - ${hasParams ? `-- Test: Function handles invalid input appropriately + ${ + hasParams + ? `-- Test: Function handles invalid input appropriately BEGIN v_error_caught := false; BEGIN - ${invalidParams ? `SELECT ${schema}.${functionName}(${invalidParams}) INTO v_result;` : `-- TODO: Add invalid parameter test`} + ${invalidParams ? `SELECT ${schema}.${functionName}(${invalidParams}) INTO v_result;` : '-- TODO: Add invalid parameter test'} EXCEPTION WHEN OTHERS THEN v_error_caught := true; @@ -1161,9 +1207,13 @@ BEGIN 'Function ${functionName} handles invalid input appropriately (either raises exception or returns null)' ); END; - ` : ''} + ` + : '' +} - ${requiresSecurityTesting ? `-- =================================================================== + ${ + requiresSecurityTesting + ? `-- =================================================================== -- AUTHORIZATION AND SECURITY TESTS -- =================================================================== @@ -1204,16 +1254,21 @@ BEGIN 'Function ${functionName} should work with admin context: ' || SQLERRM ); END; - ` : ''} + ` + : '' +} - ${isVolatile ? `-- =================================================================== + ${ + isVolatile + ? `-- =================================================================== -- SIDE EFFECTS AND STATE TESTS (for volatile functions) -- =================================================================== -- Test: Function maintains data consistency -- TODO: Add specific tests for function side effects RETURN NEXT tap.pass('TODO: Test function side effects and data consistency'); - ` : `-- =================================================================== + ` + : `-- =================================================================== -- IMMUTABILITY TESTS (for stable/immutable functions) -- =================================================================== @@ -1222,9 +1277,13 @@ BEGIN v_result1 ${returnType}; v_result2 ${returnType}; BEGIN - ${sampleParams ? `SELECT ${schema}.${functionName}(${sampleParams}) INTO v_result1; - SELECT ${schema}.${functionName}(${sampleParams}) INTO v_result2;` : `SELECT ${schema}.${functionName}() INTO v_result1; - SELECT ${schema}.${functionName}() INTO v_result2;`} + ${ + sampleParams + ? `SELECT ${schema}.${functionName}(${sampleParams}) INTO v_result1; + SELECT ${schema}.${functionName}(${sampleParams}) INTO v_result2;` + : `SELECT ${schema}.${functionName}() INTO v_result1; + SELECT ${schema}.${functionName}() INTO v_result2;` +} RETURN NEXT tap.is( v_result1, @@ -1237,7 +1296,8 @@ BEGIN 'Function ${functionName} consistency test failed: ' || SQLERRM ); END; - `} + ` +} -- =================================================================== -- PERFORMANCE AND RESOURCE TESTS (optional) @@ -1308,9 +1368,9 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun -- ===================================================== `; - + if (policies && policies.length > 0) { - policies.forEach(policy => { + policies.forEach((policy) => { tests += ` -- Test: Policy '${policy.name}' exists RETURN NEXT tap.ok( (SELECT COUNT(*) > 0 FROM pg_policies @@ -1335,7 +1395,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun `; } - + return tests; } @@ -1353,11 +1413,11 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun -- ===================================================== `; - + if (policies && policies.length > 0) { - policies.forEach(policy => { + policies.forEach((policy) => { if (policy.commands && policy.commands.length > 0) { - policy.commands.forEach(cmd => { + policy.commands.forEach((cmd) => { tests += ` -- Test: Policy '${policy.name}' applies to ${cmd} command RETURN NEXT tap.ok( (SELECT COUNT(*) > 0 FROM pg_policies @@ -1384,7 +1444,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun `; } - + return tests; } @@ -1402,18 +1462,18 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun -- ===================================================== `; - + if (policies && policies.length > 0) { - policies.forEach(policy => { + policies.forEach((policy) => { if (policy.roles && policy.roles.length > 0) { - const _roleList = policy.roles.map(role => `'${role}'`).join(', '); + const _roleList = policy.roles.map((role) => `'${role}'`).join(', '); tests += ` -- Test: Policy '${policy.name}' applies to correct roles RETURN NEXT tap.set_eq( $$SELECT unnest(roles) FROM pg_policies WHERE schemaname = '${schema}' AND tablename = '${tableName}' AND policyname = '${policy.name}'$$, - $$VALUES (${policy.roles.map(role => `'${role}'`).join('), (')})$$, + $$VALUES (${policy.roles.map((role) => `'${role}'`).join('), (')})$$, 'Policy "${policy.name}" applies to correct roles: ${policy.roles.join(', ')}' ); @@ -1432,7 +1492,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun `; } - + return tests; } @@ -1450,7 +1510,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun -- ===================================================== `; - + // Anonymous user tests tests += ` -- Test: Anonymous access PERFORM test.set_auth_context(NULL, 'anon'); @@ -1461,7 +1521,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun ); `; - + // Authenticated user tests tests += ` -- Test: Authenticated user can access own data PERFORM test.set_auth_context(v_user1_id, 'authenticated'); @@ -1472,7 +1532,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun RETURN NEXT tap.pass('TODO: Test authenticated user can access own data in ${tableName}'); `; - + // Cross-user access restriction tests tests += ` -- Test: Users cannot access other users' data PERFORM test.set_auth_context(v_user2_id, 'authenticated'); @@ -1481,7 +1541,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun RETURN NEXT tap.pass('TODO: Test user cannot access other users data in ${tableName}'); `; - + // Admin access tests tests += ` -- Test: Admin users have elevated access PERFORM test.set_auth_context(v_admin_id, 'authenticated'); @@ -1489,7 +1549,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun RETURN NEXT tap.pass('TODO: Test admin user has appropriate access to ${tableName}'); `; - + if (testScenarios && testScenarios.length > 0) { testScenarios.forEach((scenario, index) => { tests += ` -- Custom Test Scenario ${index + 1}: ${scenario.description || 'Custom scenario'} @@ -1503,7 +1563,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun `; }); } - + return tests; } @@ -1562,26 +1622,31 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${fun const tableName = requirement.targetName || requirement.name; const testFunctionName = `run_${tableName}_table_tests`; const planCount = this.calculatePlanCount(requirement, 'table'); - + // Extract metadata for comprehensive testing const metadata = requirement.metadata || {}; const columns = metadata.columns || []; const expectedConstraints = metadata.expectedConstraints || []; const requiresRowLevelSecurity = metadata.requiresRowLevelSecurity || false; const indexes = metadata.indexes || []; - + // Generate column test assertions const columnTests = this.generateColumnTestAssertions(schema, tableName, columns); - - // Generate constraint test assertions - const constraintTests = this.generateConstraintTestAssertions(schema, tableName, expectedConstraints); - + + // Generate constraint test assertions + const constraintTests = this.generateConstraintTestAssertions( + schema, + tableName, + expectedConstraints + ); + // Generate index test assertions const indexTests = this.generateIndexTestAssertions(schema, tableName, indexes); - + // Generate RLS test assertions if required - const rlsTests = requiresRowLevelSecurity ? - this.generateRlsTestAssertions(schema, tableName) : ''; + const rlsTests = requiresRowLevelSecurity + ? this.generateRlsTestAssertions(schema, tableName) + : ''; return `-- ========================================================================= -- TABLE TESTS: ${tableName} @@ -1706,15 +1771,15 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Comprehensive tests for ${tab const tableName = requirement.tableName || 'TODO_TABLE_NAME'; const testFunctionName = `run_${indexName}_index_tests`; const planCount = this.calculatePlanCount(requirement, 'index'); - + const isUnique = requirement.isUnique || false; const indexType = requirement.indexType || 'btree'; const isPartial = requirement.isPartial || false; const indexedColumns = requirement.indexedColumns || ['TODO_COLUMN']; const whereClause = requirement.whereClause || ''; - + // Build column array string for pgTAP - const columnsArrayStr = indexedColumns.map(col => `'${col}'`).join(', '); + const columnsArrayStr = indexedColumns.map((col) => `'${col}'`).join(', '); return `-- ========================================================================= -- INDEX TESTS: ${indexName} @@ -1767,7 +1832,9 @@ BEGIN 'Index ${indexName} is of type ${indexType}' ); -${isUnique ? ` -- Test 4: Index enforces uniqueness +${ + isUnique + ? ` -- Test 4: Index enforces uniqueness RETURN NEXT tap.index_is_unique( '${schema}', '${tableName}', @@ -1794,21 +1861,27 @@ ${isUnique ? ` -- Test 4: Index enforces uniqueness -- If setup fails, mark as TODO RETURN NEXT tap.pass('TODO: Set up unique constraint validation test'); END; -` : ` -- Test 4: Non-unique index allows duplicates (if applicable) +` + : ` -- Test 4: Non-unique index allows duplicates (if applicable) -- TODO: Add test for non-unique index behavior if relevant RETURN NEXT tap.pass('TODO: Add non-unique index behavior test if applicable'); -- Test 5: Index performance characteristics -- TODO: Add performance validation tests (comments about expected usage patterns) RETURN NEXT tap.pass('TODO: Add performance validation tests'); -`} -${isPartial ? ` -- Test 6: Partial index WHERE clause validation +` +} +${ + isPartial + ? ` -- Test 6: Partial index WHERE clause validation -- TODO: Verify partial index WHERE clause: ${whereClause} RETURN NEXT tap.pass('TODO: Test partial index WHERE clause behavior'); -` : ` -- Test 6: Full index coverage (not partial) +` + : ` -- Test 6: Full index coverage (not partial) -- TODO: Verify index covers all table rows (no WHERE clause) RETURN NEXT tap.pass('TODO: Verify full index coverage'); -`} +` +} -- Test 7: Index usage in query plans (performance validation) -- NOTE: This is a comment-based test for manual verification -- Query patterns that should use this index: @@ -1865,7 +1938,7 @@ ${isPartial ? `-- Partial: Yes (WHERE ${whereClause})` : '-- Partial: No'} columns.forEach((column, _index) => { const columnName = column.targetName || column.name; const metadata = column.metadata || {}; - + assertions += ` -- Column: ${columnName} RETURN NEXT tap.has_column( @@ -1987,7 +2060,7 @@ ${isPartial ? `-- Partial: Yes (WHERE ${whereClause})` : '-- Partial: No'} -- ========================================================================= `; - expectedConstraints.forEach(constraintName => { + expectedConstraints.forEach((constraintName) => { assertions += ` -- Constraint: ${constraintName} RETURN NEXT tap.has_check( @@ -2005,7 +2078,7 @@ ${isPartial ? `-- Partial: Yes (WHERE ${whereClause})` : '-- Partial: No'} } /** - * Generate index test assertions + * Generate index test assertions * @param {string} schema - Schema name * @param {string} tableName - Table name * @param {IndexTestRequirement[]} indexes - Index requirements @@ -2031,10 +2104,10 @@ ${isPartial ? `-- Partial: Yes (WHERE ${whereClause})` : '-- Partial: No'} -- ========================================================================= `; - indexes.forEach(index => { + indexes.forEach((index) => { const indexName = index.targetName || index.name; const metadata = index.metadata || {}; - + assertions += ` -- Index: ${indexName} RETURN NEXT tap.has_index( @@ -2222,11 +2295,12 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum '${columnName}', 'Column ${columnName} has a default value' );`); - + if (requirement.expectedDefaultValue !== undefined) { - const defaultValue = typeof requirement.expectedDefaultValue === 'string' - ? `'${requirement.expectedDefaultValue}'` - : requirement.expectedDefaultValue; + const defaultValue = + typeof requirement.expectedDefaultValue === 'string' + ? `'${requirement.expectedDefaultValue}'` + : requirement.expectedDefaultValue; assertions.push(` -- Test ${testNumber++}: Column has correct default value RETURN NEXT tap.col_default_is( '${schema}', @@ -2250,7 +2324,11 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum } // Test 6: Foreign key - if (requirement.isForeignKey === true && requirement.referencedTable && requirement.referencedColumn) { + if ( + requirement.isForeignKey === true && + requirement.referencedTable && + requirement.referencedColumn + ) { assertions.push(` -- Test ${testNumber++}: Foreign key relationship RETURN NEXT tap.fk_ok( '${schema}', '${tableName}', '${columnName}', @@ -2296,10 +2374,25 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum * @private */ isNumericType(dataType) { - const numericTypes = ['integer', 'int', 'int4', 'bigint', 'int8', 'smallint', 'int2', - 'decimal', 'numeric', 'real', 'float4', 'double precision', 'float8', - 'serial', 'bigserial', 'smallserial']; - return numericTypes.some(type => dataType.toLowerCase().includes(type)); + const numericTypes = [ + 'integer', + 'int', + 'int4', + 'bigint', + 'int8', + 'smallint', + 'int2', + 'decimal', + 'numeric', + 'real', + 'float4', + 'double precision', + 'float8', + 'serial', + 'bigserial', + 'smallserial' + ]; + return numericTypes.some((type) => dataType.toLowerCase().includes(type)); } /** @@ -2331,13 +2424,13 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum // For RLS tests, adjust based on policies and test scenarios if (testType === 'rls' && requirement.metadata) { const metadata = requirement.metadata; - + // Add tests for each specific policy if (metadata.policies && metadata.policies.length > 0) { baseCount += metadata.policies.length * 2; // 2 tests per policy (existence + commands) - + // Additional tests for policies with role restrictions - metadata.policies.forEach(policy => { + metadata.policies.forEach((policy) => { if (policy.roles && policy.roles.length > 0) { baseCount += 1; // Policy role test } @@ -2346,7 +2439,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum } }); } - + // Add tests for custom test scenarios if (metadata.testScenarios && metadata.testScenarios.length > 0) { baseCount += metadata.testScenarios.length; // Custom scenario tests @@ -2360,22 +2453,22 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum // For table tests, adjust based on metadata if (testType === 'table' && requirement.metadata) { const metadata = requirement.metadata; - + // Add tests for each column if (metadata.columns && metadata.columns.length > 0) { baseCount += metadata.columns.length * 2; // 2 tests per column minimum } - + // Add tests for constraints if (metadata.expectedConstraints && metadata.expectedConstraints.length > 0) { baseCount += metadata.expectedConstraints.length * 2; } - + // Add tests for indexes if (metadata.indexes && metadata.indexes.length > 0) { baseCount += metadata.indexes.length * 2; } - + // Add tests for RLS if required if (metadata.requiresRowLevelSecurity) { baseCount += 3; @@ -2459,15 +2552,15 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum return null; } - const sampleValues = parameterTypes.map(type => { + const sampleValues = parameterTypes.map((type) => { const lowerType = type.toLowerCase(); - + // Handle array types if (lowerType.includes('[]')) { const baseType = lowerType.replace('[]', ''); return this.getSampleArrayValue(baseType); } - + return this.getSampleValue(lowerType); }); @@ -2485,7 +2578,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum return null; } - const invalidValues = parameterTypes.map(type => { + const invalidValues = parameterTypes.map((type) => { const lowerType = type.toLowerCase(); return this.getInvalidValue(lowerType); }); @@ -2502,62 +2595,62 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum getSampleValue(type) { const typeMap = { // Integer types - 'integer': '42', - 'int': '42', - 'int4': '42', - 'bigint': '123456789', - 'int8': '123456789', - 'smallint': '123', - 'int2': '123', + integer: '42', + int: '42', + int4: '42', + bigint: '123456789', + int8: '123456789', + smallint: '123', + int2: '123', // Decimal types - 'decimal': '123.45', - 'numeric': '123.45', - 'real': '123.45', - 'float4': '123.45', + decimal: '123.45', + numeric: '123.45', + real: '123.45', + float4: '123.45', 'double precision': '123.45', - 'float8': '123.45', + float8: '123.45', // String types - 'text': "'sample text'", - 'varchar': "'sample varchar'", + text: "'sample text'", + varchar: "'sample varchar'", 'character varying': "'sample varchar'", - 'char': "'S'", - 'character': "'S'", + char: "'S'", + character: "'S'", // Boolean - 'boolean': 'true', - 'bool': 'true', + boolean: 'true', + bool: 'true', // Date/Time - 'date': "'2024-01-01'", - 'time': "'12:00:00'", - 'timestamp': "'2024-01-01 12:00:00'", - 'timestamptz': "'2024-01-01 12:00:00+00'", - 'interval': "'1 hour'", + date: "'2024-01-01'", + time: "'12:00:00'", + timestamp: "'2024-01-01 12:00:00'", + timestamptz: "'2024-01-01 12:00:00+00'", + interval: "'1 hour'", // UUID - 'uuid': "'00000000-0000-0000-0000-000000000001'::uuid", + uuid: "'00000000-0000-0000-0000-000000000001'::uuid", // JSON - 'json': "'{\"key\": \"value\"}'::json", - 'jsonb': "'{\"key\": \"value\"}'::jsonb", + json: '\'{"key": "value"}\'::json', + jsonb: '\'{"key": "value"}\'::jsonb', // Binary - 'bytea': "'\\x414243'", + bytea: "'\\x414243'", // Network types - 'inet': "'192.168.1.1'", - 'cidr': "'192.168.1.0/24'", - 'macaddr': "'08:00:2b:01:02:03'", + inet: "'192.168.1.1'", + cidr: "'192.168.1.0/24'", + macaddr: "'08:00:2b:01:02:03'", // Geometric types (simplified) - 'point': "'(1,2)'", - 'polygon': "'((0,0),(1,1),(1,0))'", - 'circle': "'<(0,0),1>'", + point: "'(1,2)'", + polygon: "'((0,0),(1,1),(1,0))'", + circle: "'<(0,0),1>'", // Default fallback - 'default': "'sample_value'" + default: "'sample_value'" }; return typeMap[type] || typeMap['default']; @@ -2571,7 +2664,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum */ getSampleArrayValue(baseType) { const sampleValue = this.getSampleValue(baseType); - + // For simple types, create an array if (baseType.includes('int') || baseType.includes('numeric') || baseType.includes('decimal')) { return 'ARRAY[1, 2, 3]'; @@ -2582,7 +2675,7 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum } else if (baseType === 'uuid') { return "ARRAY['00000000-0000-0000-0000-000000000001'::uuid, '00000000-0000-0000-0000-000000000002'::uuid]"; } - + return `ARRAY[${sampleValue}, ${sampleValue}]`; } @@ -2595,40 +2688,40 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum getInvalidValue(type) { const invalidMap = { // Integer types - use string that can't be converted - 'integer': "'not_a_number'", - 'int': "'not_a_number'", - 'int4': "'not_a_number'", - 'bigint': "'not_a_number'", - 'int8': "'not_a_number'", - 'smallint': "'not_a_number'", + integer: "'not_a_number'", + int: "'not_a_number'", + int4: "'not_a_number'", + bigint: "'not_a_number'", + int8: "'not_a_number'", + smallint: "'not_a_number'", // For numeric types, use invalid string - 'decimal': "'invalid_decimal'", - 'numeric': "'invalid_numeric'", - 'real': "'invalid_real'", + decimal: "'invalid_decimal'", + numeric: "'invalid_numeric'", + real: "'invalid_real'", // For dates, use invalid format - 'date': "'invalid-date'", - 'timestamp': "'invalid-timestamp'", - 'timestamptz': "'invalid-timestamp'", + date: "'invalid-date'", + timestamp: "'invalid-timestamp'", + timestamptz: "'invalid-timestamp'", // For UUID, use invalid format - 'uuid': "'invalid-uuid-format'", + uuid: "'invalid-uuid-format'", // For JSON, use invalid syntax - 'json': "'invalid json syntax{'", - 'jsonb': "'invalid json syntax{'", + json: "'invalid json syntax{'", + jsonb: "'invalid json syntax{'", // For boolean, use invalid string - 'boolean': "'maybe'", - 'bool': "'maybe'", + boolean: "'maybe'", + bool: "'maybe'", // For network types, use invalid formats - 'inet': "'invalid.ip.address'", - 'cidr': "'invalid/cidr'", + inet: "'invalid.ip.address'", + cidr: "'invalid/cidr'", // Default: null (which might be invalid for NOT NULL columns) - 'default': 'NULL' + default: 'NULL' }; return invalidMap[type] || invalidMap['default']; @@ -2643,10 +2736,10 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum formatPgTapStructure(content) { // Ensure consistent indentation for pgTAP functions return content - .replace(/^(\s*RETURN NEXT tap\.)/gm, ' $1') // Standardize pgTAP function indentation - .replace(/^(\s*--)/gm, '$1') // Keep comment indentation as-is - .replace(/^(\s*PERFORM)/gm, ' $1') // Standardize PERFORM indentation - .replace(/^(\s*SELECT)/gm, ' $1'); // Standardize SELECT indentation + .replace(/^(\s*RETURN NEXT tap\.)/gm, ' $1') // Standardize pgTAP function indentation + .replace(/^(\s*--)/gm, '$1') // Keep comment indentation as-is + .replace(/^(\s*PERFORM)/gm, ' $1') // Standardize PERFORM indentation + .replace(/^(\s*SELECT)/gm, ' $1'); // Standardize SELECT indentation } /** @@ -2669,36 +2762,36 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum // Add metadata-based variables if (requirement.metadata) { const metadata = requirement.metadata; - + // Table-specific variables if (metadata.tableName) { variables.tableName = metadata.tableName; } - - // Column-specific variables + + // Column-specific variables if (metadata.expectedType) { variables.dataType = metadata.expectedType; } - + // Function-specific variables if (metadata.parameterTypes) { variables.parameterTypes = metadata.parameterTypes; } - + if (metadata.returnType) { variables.returnType = metadata.returnType; } - + // Index-specific variables if (metadata.indexedColumns) { variables.indexedColumns = metadata.indexedColumns; } - + // RLS-specific variables if (metadata.policies) { variables.policies = metadata.policies; } - + // Test data variables variables.testId = 'test-id-' + Math.random().toString(36).substr(2, 9); variables.validValues = this.generateSampleTestData(requirement); @@ -2718,27 +2811,26 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum */ generatePatternEnhancements(requirement, patterns, variables) { let enhancements = ''; - - patterns.forEach(pattern => { + + patterns.forEach((pattern) => { try { // Skip patterns that are already covered by the base template if (this.isPatternCoveredByBase(pattern, requirement)) { return; } - + // Render pattern with variables const renderedPattern = this.patternLibrary.renderPattern(pattern.name, variables); - + enhancements += `-- Pattern: ${pattern.name} (${pattern.category})\n`; enhancements += `-- ${pattern.description}\n`; enhancements += renderedPattern + '\n\n'; - } catch (error) { // Log pattern rendering errors but don't fail the whole generation enhancements += `-- Pattern ${pattern.name} could not be rendered: ${error.message}\n\n`; } }); - + return enhancements; } @@ -2752,21 +2844,21 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum isPatternCoveredByBase(pattern, requirement) { // Basic existence patterns are usually covered by base templates const basicPatterns = ['table_exists_basic', 'column_exists_basic']; - + if (basicPatterns.includes(pattern.name)) { return true; } - + // For table tests, column structure validation is already covered if (requirement.type === 'table' && pattern.name === 'column_structure_validation') { return true; } - + // For RLS tests, basic RLS checks are covered if (requirement.type === 'rls' && pattern.name === 'rls_enablement_check') { return true; } - + return false; } @@ -2778,15 +2870,15 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum */ generateSampleTestData(requirement) { const metadata = requirement.metadata || {}; - + if (requirement.type === 'column' && metadata.expectedType) { return this.getSampleValue(metadata.expectedType.toLowerCase()); } - + if (requirement.type === 'table') { return 'DEFAULT VALUES'; } - + return "'sample_value'"; } @@ -2798,13 +2890,13 @@ COMMENT ON FUNCTION test.${testFunctionName}() IS 'Tests for ${columnName} colum */ generateInvalidTestData(requirement) { const metadata = requirement.metadata || {}; - + if (requirement.type === 'column' && metadata.expectedType) { return this.getInvalidValue(metadata.expectedType.toLowerCase()); } - + return 'NULL'; } } -module.exports = TestTemplateGenerator; \ No newline at end of file +export default TestTemplateGenerator; diff --git a/src/lib/testing/pgTAPTestScanner.js b/starfleet/data-host-node/src/lib/testing/pgTAPTestScanner.js similarity index 74% rename from src/lib/testing/pgTAPTestScanner.js rename to starfleet/data-host-node/src/lib/testing/pgTAPTestScanner.js index 8582d87..5ebcaa2 100644 --- a/src/lib/testing/pgTAPTestScanner.js +++ b/starfleet/data-host-node/src/lib/testing/pgTAPTestScanner.js @@ -1,10 +1,10 @@ /** * pgTAP Test Scanner for D.A.T.A. CLI - * + * * This module provides functionality to scan pgTAP test files and extract test coverage * information. It identifies pgTAP assertions, builds coverage maps, and tracks what * database objects and functionality are being tested. - * + * * @fileoverview pgTAP test file scanner for coverage analysis * @author D.A.T.A. Engineering Team * @version 1.0.0 @@ -60,7 +60,7 @@ import BatchProcessor from './BatchProcessor.js'; * @property {string} filePath - Absolute path to the test file * @property {string} fileName - Name of the test file * @property {TestAssertion[]} assertions - Array of pgTAP assertions found - * @property {number} planCount - Expected number of tests from SELECT plan() + * @property {number} planCount - Expected number of tests from SELECT plan() * @property {string[]} dependencies - Any dependencies or includes found * @property {Object} metadata - Additional file metadata */ @@ -79,17 +79,17 @@ import BatchProcessor from './BatchProcessor.js'; /** * pgTAP Test Scanner Class - * + * * Scans directories of pgTAP test files (.sql) and extracts test coverage information. * Identifies pgTAP assertions, builds coverage maps, and provides insights into what * database objects are being tested. - * + * * @extends EventEmitter */ class pgTAPTestScanner extends EventEmitter { /** * Create a new pgTAP test scanner - * + * * @param {Object} [options={}] - Scanner configuration options * @param {boolean} [options.includeCommented=false] - Include commented-out tests * @param {string[]} [options.fileExtensions=['.sql']] - File extensions to scan @@ -102,7 +102,7 @@ class pgTAPTestScanner extends EventEmitter { */ constructor(options = {}) { super(); - + /** * @type {Object} Scanner configuration */ @@ -125,12 +125,12 @@ class pgTAPTestScanner extends EventEmitter { enableCompression: false, // Enable data compression (experimental) ...options }; - + /** * @type {TestFile[]} Array of scanned test files */ this.testFiles = []; - + /** * @type {CoverageMap} Coverage analysis results */ @@ -144,7 +144,7 @@ class pgTAPTestScanner extends EventEmitter { triggers: {}, filesByTarget: {} }; - + /** * @type {Object} Memory management state */ @@ -157,191 +157,353 @@ class pgTAPTestScanner extends EventEmitter { objectsProcessed: 0, streamingMode: false }; - + /** * @type {WeakMap} Weak references for cleanup */ this.weakRefs = new WeakMap(); - + /** * @type {AbortController} For cancelling operations */ this.abortController = new AbortController(); - + /** * @type {StreamingCoverageDatabase} Memory-aware coverage database */ this.streamingDB = null; - + /** * @type {BatchProcessor} Batch processing utility */ this.batchProcessor = null; - + /** * @type {Map} pgTAP assertion patterns */ this.assertionPatterns = this._initializeAssertionPatterns(); - + /** * @type {RegExp} Pattern for SELECT plan() statements */ this.planPattern = /SELECT\s+plan\s*\(\s*(\d+)\s*\)\s*;?/gi; - + /** * @type {RegExp} Pattern for SQL comments */ this.commentPattern = /--.*$/gm; - + /** * @type {number} Total files processed */ this.filesProcessed = 0; - + /** * @type {number} Total assertions found */ this.totalAssertions = 0; - + // Initialize memory monitoring this._initializeMemoryMonitoring(); } - + /** * Initialize pgTAP assertion patterns - * + * * @returns {Map} Map of assertion types to regex patterns * @private */ _initializeAssertionPatterns() { const patterns = new Map(); - + // Schema testing patterns.set('has_schema', /SELECT\s+has_schema\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/gi); patterns.set('hasnt_schema', /SELECT\s+hasnt_schema\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/gi); - + // Table testing - Enhanced patterns to handle more variations // Pattern for SELECT has_table(...) with optional schema, table name, and description - patterns.set('has_table_select', /SELECT\s+has_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('hasnt_table_select', /SELECT\s+hasnt_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'has_table_select', + /SELECT\s+has_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'hasnt_table_select', + /SELECT\s+hasnt_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // Pattern for ok(has_table(...), 'description') format - patterns.set('has_table_ok', /ok\s*\(\s*has_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)\s*(?:,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('hasnt_table_ok', /ok\s*\(\s*hasnt_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)\s*(?:,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'has_table_ok', + /ok\s*\(\s*has_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)\s*(?:,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'hasnt_table_ok', + /ok\s*\(\s*hasnt_table\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)\s*(?:,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // Table privilege testing // table_privs_are('table', 'role', ARRAY['privs']) or table_privs_are('schema', 'table', 'role', ARRAY['privs']) - patterns.set('table_privs_are', /SELECT\s+table_privs_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\s*\[\s*(.*?)\s*\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'table_privs_are', + /SELECT\s+table_privs_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\s*\[\s*(.*?)\s*\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // Table ownership testing // table_owner_is('table', 'owner') or table_owner_is('schema', 'table', 'owner') - patterns.set('table_owner_is', /SELECT\s+table_owner_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'table_owner_is', + /SELECT\s+table_owner_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // Table enumeration testing // tables_are('schema', ARRAY['table1', 'table2']) or tables_are(ARRAY['table1', 'table2']) - patterns.set('tables_are', /SELECT\s+tables_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?ARRAY\s*\[\s*(.*?)\s*\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'tables_are', + /SELECT\s+tables_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?ARRAY\s*\[\s*(.*?)\s*\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // Column testing - patterns.set('has_column', /SELECT\s+has_column\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('hasnt_column', /SELECT\s+hasnt_column\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('col_type_is', /SELECT\s+col_type_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('col_not_null', /SELECT\s+col_not_null\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('col_is_null', /SELECT\s+col_is_null\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('col_has_default', /SELECT\s+col_has_default\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('col_hasnt_default', /SELECT\s+col_hasnt_default\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('col_default_is', /SELECT\s+col_default_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*((?:[^'"`(),]|['"`][^'"`]*['"`]|\([^)]*\))+)\s*\)/gi); - patterns.set('col_is_pk', /SELECT\s+col_is_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('col_isnt_pk', /SELECT\s+col_isnt_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - + patterns.set( + 'has_column', + /SELECT\s+has_column\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'hasnt_column', + /SELECT\s+hasnt_column\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'col_type_is', + /SELECT\s+col_type_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'col_not_null', + /SELECT\s+col_not_null\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'col_is_null', + /SELECT\s+col_is_null\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'col_has_default', + /SELECT\s+col_has_default\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'col_hasnt_default', + /SELECT\s+col_hasnt_default\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'col_default_is', + /SELECT\s+col_default_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*((?:[^'"`(),]|['"`][^'"`]*['"`]|\([^)]*\))+)\s*\)/gi + ); + patterns.set( + 'col_is_pk', + /SELECT\s+col_is_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'col_isnt_pk', + /SELECT\s+col_isnt_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + // Primary key testing - patterns.set('has_pk', /SELECT\s+has_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('hasnt_pk', /SELECT\s+hasnt_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi); - + patterns.set( + 'has_pk', + /SELECT\s+has_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'hasnt_pk', + /SELECT\s+hasnt_pk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi + ); + // Foreign key testing - patterns.set('has_fk', /SELECT\s+has_fk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - patterns.set('hasnt_fk', /SELECT\s+hasnt_fk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - + patterns.set( + 'has_fk', + /SELECT\s+has_fk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + patterns.set( + 'hasnt_fk', + /SELECT\s+hasnt_fk\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + // Index testing - Enhanced patterns for comprehensive index coverage // has_index('table', 'index_name') or has_index('schema', 'table', 'index_name') - patterns.set('has_index', /SELECT\s+has_index\s*\(\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - patterns.set('hasnt_index', /SELECT\s+hasnt_index\s*\(\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - + patterns.set( + 'has_index', + /SELECT\s+has_index\s*\(\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + patterns.set( + 'hasnt_index', + /SELECT\s+hasnt_index\s*\(\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + // index_is_on('table', 'index', ARRAY['column']) - tests what columns an index covers - patterns.set('index_is_on', /SELECT\s+index_is_on\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\s*\[\s*(.*?)\s*\]\s*\)/gi); - + patterns.set( + 'index_is_on', + /SELECT\s+index_is_on\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\s*\[\s*(.*?)\s*\]\s*\)/gi + ); + // index_is_type('table', 'index', 'type') - tests index type (btree, gin, etc.) - patterns.set('index_is_type', /SELECT\s+index_is_type\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - + patterns.set( + 'index_is_type', + /SELECT\s+index_is_type\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + // has_unique('table', 'constraint_name') - tests unique constraints - patterns.set('has_unique', /SELECT\s+has_unique\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - patterns.set('hasnt_unique', /SELECT\s+hasnt_unique\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - + patterns.set( + 'has_unique', + /SELECT\s+has_unique\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + patterns.set( + 'hasnt_unique', + /SELECT\s+hasnt_unique\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + // index_is_primary('table', 'index') - tests if index is primary key - patterns.set('index_is_primary', /SELECT\s+index_is_primary\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - + patterns.set( + 'index_is_primary', + /SELECT\s+index_is_primary\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + // Function testing - patterns.set('has_function', /SELECT\s+has_function\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('hasnt_function', /SELECT\s+hasnt_function\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('function_returns', /SELECT\s+function_returns\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('function_lang_is', /SELECT\s+function_lang_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('is_definer', /SELECT\s+is_definer\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('isnt_definer', /SELECT\s+isnt_definer\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('volatility_is', /SELECT\s+volatility_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('function_privs_are', /SELECT\s+function_privs_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\[(.*?)\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'has_function', + /SELECT\s+has_function\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'hasnt_function', + /SELECT\s+hasnt_function\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'function_returns', + /SELECT\s+function_returns\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'function_lang_is', + /SELECT\s+function_lang_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'is_definer', + /SELECT\s+is_definer\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'isnt_definer', + /SELECT\s+isnt_definer\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'volatility_is', + /SELECT\s+volatility_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'function_privs_are', + /SELECT\s+function_privs_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*ARRAY\[(.*?)\])?\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\[(.*?)\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // View testing - patterns.set('has_view', /SELECT\s+has_view\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('hasnt_view', /SELECT\s+hasnt_view\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi); - + patterns.set( + 'has_view', + /SELECT\s+has_view\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'hasnt_view', + /SELECT\s+hasnt_view\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi + ); + // Type testing - patterns.set('has_type', /SELECT\s+has_type\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('hasnt_type', /SELECT\s+hasnt_type\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi); - + patterns.set( + 'has_type', + /SELECT\s+has_type\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'hasnt_type', + /SELECT\s+hasnt_type\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi + ); + // Result testing - patterns.set('results_eq', /SELECT\s+results_eq\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - patterns.set('results_ne', /SELECT\s+results_ne\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - + patterns.set( + 'results_eq', + /SELECT\s+results_eq\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + patterns.set( + 'results_ne', + /SELECT\s+results_ne\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + // RLS (Row Level Security) policy testing - patterns.set('is_rls_enabled', /SELECT\s+is_rls_enabled\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('policy_exists', /SELECT\s+policy_exists\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('policy_cmd_is', /SELECT\s+policy_cmd_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi); - patterns.set('policy_roles_are', /SELECT\s+policy_roles_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\[(.*?)\]\s*\)/gi); - patterns.set('policies_are', /SELECT\s+policies_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*ARRAY\[(.*?)\](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi); - + patterns.set( + 'is_rls_enabled', + /SELECT\s+is_rls_enabled\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'policy_exists', + /SELECT\s+policy_exists\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'policy_cmd_is', + /SELECT\s+policy_cmd_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi + ); + patterns.set( + 'policy_roles_are', + /SELECT\s+policy_roles_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*ARRAY\[(.*?)\]\s*\)/gi + ); + patterns.set( + 'policies_are', + /SELECT\s+policies_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*ARRAY\[(.*?)\](?:\s*,\s*['"`]([^'"`]+)['"`])?\s*\)/gi + ); + // Trigger testing // has_trigger('table', 'trigger_name') or has_trigger('schema', 'table', 'trigger_name') // Also supports optional description: has_trigger('table', 'trigger', 'description') - patterns.set('has_trigger', /SELECT\s+has_trigger\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - patterns.set('hasnt_trigger', /SELECT\s+hasnt_trigger\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'has_trigger', + /SELECT\s+has_trigger\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + patterns.set( + 'hasnt_trigger', + /SELECT\s+hasnt_trigger\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]+)['"`])?(?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // trigger_is('table', 'trigger', 'function') or trigger_is('schema', 'table', 'trigger', 'func_schema', 'function') - patterns.set('trigger_is', /SELECT\s+trigger_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'trigger_is', + /SELECT\s+trigger_is\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // is_trigger_on('table', 'trigger', 'events') - tests trigger events (INSERT, UPDATE, DELETE) - patterns.set('is_trigger_on', /SELECT\s+is_trigger_on\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'is_trigger_on', + /SELECT\s+is_trigger_on\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // trigger_fires_on('table', 'trigger', 'timing') - tests trigger timing (BEFORE, AFTER, INSTEAD OF) - patterns.set('trigger_fires_on', /SELECT\s+trigger_fires_on\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'trigger_fires_on', + /SELECT\s+trigger_fires_on\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // trigger_is_for('table', 'trigger', 'level') - tests trigger level (ROW, STATEMENT) - patterns.set('trigger_is_for', /SELECT\s+trigger_is_for\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'trigger_is_for', + /SELECT\s+trigger_is_for\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*,\s*['"`]([^'"`]+)['"`](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + // triggers_are('table', ARRAY['trigger_names']) - tests all triggers on a table - patterns.set('triggers_are', /SELECT\s+triggers_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*ARRAY\s*\[\s*(.*?)\s*\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi); - + patterns.set( + 'triggers_are', + /SELECT\s+triggers_are\s*\(\s*(?:['"`]([^'"`]+)['"`]\s*,\s*)?['"`]([^'"`]+)['"`]\s*,\s*ARRAY\s*\[\s*(.*?)\s*\](?:\s*,\s*['"`]([^'"`]*)['"`])?\s*\)/gi + ); + return patterns; } - + /** * Scan a directory for pgTAP test files - * + * * @param {string} testsDir - Directory to scan for test files * @returns {Promise} Array of parsed test files * @throws {Error} If directory doesn't exist or is not accessible */ async scanDirectory(testsDir) { const startTime = Date.now(); - + try { // Emit directory scanning event const dirEvent = DirectoryEvent.scan(testsDir); @@ -351,16 +513,16 @@ class pgTAPTestScanner extends EventEmitter { timestamp: dirEvent.timestamp, type: dirEvent.type }); - + // Check if directory exists const stat = await fs.stat(testsDir); if (!stat.isDirectory()) { throw new Error(`Path is not a directory: ${testsDir}`); } - + // Find all test files const testFiles = await this._findTestFiles(testsDir); - + if (testFiles.length === 0) { this.emit('warning', { message: 'No test files found', @@ -370,18 +532,18 @@ class pgTAPTestScanner extends EventEmitter { }); return []; } - + // Process each test file this.testFiles = []; this.filesProcessed = 0; this.totalAssertions = 0; - + for (let i = 0; i < testFiles.length; i++) { const filePath = testFiles[i]; - + this.emit('progress', { message: `Parsing test file: ${path.basename(filePath)}`, - data: { + data: { filePath, filesProcessed: i, totalFiles: testFiles.length @@ -390,7 +552,7 @@ class pgTAPTestScanner extends EventEmitter { type: 'progress', percentage: Math.round((i / testFiles.length) * 100) }); - + try { const testFile = await this.parseTestFile(filePath); this.testFiles.push(testFile); @@ -406,26 +568,25 @@ class pgTAPTestScanner extends EventEmitter { }); } } - + // Build coverage map this._buildCoverageMap(); - + const duration = Date.now() - startTime; const successEvent = new SuccessEvent( `Scanned ${this.filesProcessed} test files and found ${this.totalAssertions} assertions`, { testsDir, filesProcessed: this.filesProcessed, totalAssertions: this.totalAssertions }, duration ); - + this.emit('success', { message: successEvent.message, data: successEvent.details, timestamp: successEvent.timestamp, type: successEvent.type }); - + return this.testFiles; - } catch (error) { const errorEvent = ErrorEvent.fromError(error, `Failed to scan tests directory: ${testsDir}`); this.emit('error', { @@ -438,10 +599,10 @@ class pgTAPTestScanner extends EventEmitter { throw error; } } - + /** * Parse an individual test file - * + * * @param {string} filePath - Path to the test file to parse * @returns {Promise} Parsed test file information * @throws {Error} If file cannot be read or parsed @@ -450,32 +611,32 @@ class pgTAPTestScanner extends EventEmitter { try { // Read file content const content = await fs.readFile(filePath, 'utf8'); - + // Extract test plan const planCount = this._extractPlan(content); - + // Extract assertions const assertions = this.extractAssertions(content); - + // Extract dependencies (basic implementation) const dependencies = this._extractDependencies(content); - + // Validate plan count if enabled if (this.options.validatePlans && planCount !== null && planCount !== assertions.length) { this.emit('warning', { message: `Plan count mismatch in ${path.basename(filePath)}`, - data: { - filePath, - plannedTests: planCount, - foundAssertions: assertions.length + data: { + filePath, + plannedTests: planCount, + foundAssertions: assertions.length }, timestamp: new Date(), type: 'warning' }); } - + this.filesProcessed++; - + const testFile = { filePath, fileName: path.basename(filePath), @@ -488,53 +649,52 @@ class pgTAPTestScanner extends EventEmitter { parsed: new Date() } }; - + return testFile; - } catch (error) { throw new Error(`Failed to parse test file ${filePath}: ${error.message}`); } } - + /** * Extract pgTAP assertions from SQL content - * + * * @param {string} sql - SQL content to analyze * @returns {TestAssertion[]} Array of extracted assertions */ extractAssertions(sql) { const assertions = []; - + // Remove comments if not including commented tests let processedSql = sql; if (!this.options.includeCommented) { processedSql = sql.replace(this.commentPattern, ''); } - + // Split into lines for line number tracking const lines = processedSql.split('\n'); - + // Search for each assertion pattern for (const [assertionType, pattern] of this.assertionPatterns) { let match; - + // Reset regex state pattern.lastIndex = 0; - + while ((match = pattern.exec(processedSql)) !== null) { // Find line number const beforeMatch = processedSql.substring(0, match.index); const lineNumber = beforeMatch.split('\n').length; - + // Extract parameters (filter out undefined captures) - const parameters = match.slice(1).filter(param => param !== undefined); - + const parameters = match.slice(1).filter((param) => param !== undefined); + // Clean parameters for specific assertion types this._cleanParameters(assertionType, parameters); - + // Determine target based on assertion type const target = this._determineTarget(assertionType, parameters); - + const assertion = { type: assertionType, target, @@ -542,42 +702,50 @@ class pgTAPTestScanner extends EventEmitter { lineNumber, rawSql: match[0].trim() }; - + // Add function metadata for function-related assertions - if (assertionType.includes('function') || assertionType.includes('definer') || assertionType === 'volatility_is') { + if ( + assertionType.includes('function') || + assertionType.includes('definer') || + assertionType === 'volatility_is' + ) { assertion.functionMetadata = this._extractFunctionMetadata(assertionType, parameters); } - + // Add table metadata for table-related assertions if (assertionType.includes('table')) { const metadata = this._extractAssertionMetadata(assertionType, parameters); Object.assign(assertion, metadata); } - + // Add RLS policy metadata for policy-related assertions - if (assertionType.includes('policy') || assertionType.includes('policies') || assertionType === 'is_rls_enabled') { + if ( + assertionType.includes('policy') || + assertionType.includes('policies') || + assertionType === 'is_rls_enabled' + ) { assertion.policyMetadata = this._extractPolicyMetadata(assertionType, parameters); } - + assertions.push(assertion); } } - + return assertions.sort((a, b) => a.lineNumber - b.lineNumber); } - + /** * Get the current coverage map - * + * * @returns {CoverageMap} Coverage analysis results */ getCoverageMap() { return { ...this.coverageMap }; } - + /** * Get statistics about the scanned tests - * + * * @returns {Object} Test statistics */ getStatistics() { @@ -588,7 +756,7 @@ class pgTAPTestScanner extends EventEmitter { coverageStats: this._getCoverageStats() }; } - + /** * Reset scanner state */ @@ -607,12 +775,12 @@ class pgTAPTestScanner extends EventEmitter { this.filesProcessed = 0; this.totalAssertions = 0; } - + // Private methods - + /** * Find all test files in directory recursively - * + * * @param {string} dir - Directory to search * @param {number} [depth=0] - Current recursion depth * @returns {Promise} Array of test file paths @@ -621,7 +789,7 @@ class pgTAPTestScanner extends EventEmitter { async _findTestFiles(dir, depth = 0) { const files = []; const startTime = Date.now(); - + // Check depth limit if (depth > this.options.maxDepth) { this.emit('warning', { @@ -632,7 +800,7 @@ class pgTAPTestScanner extends EventEmitter { }); return files; } - + try { // Emit progress for directory scanning this.emit('progress', { @@ -641,9 +809,9 @@ class pgTAPTestScanner extends EventEmitter { timestamp: new Date(), type: 'progress' }); - + const entries = await fs.readdir(dir, { withFileTypes: true }); - + // Process entries in sorted order for consistency const sortedEntries = entries.sort((a, b) => { // Directories first, then files, alphabetically within each group @@ -651,40 +819,37 @@ class pgTAPTestScanner extends EventEmitter { if (!a.isDirectory() && b.isDirectory()) return 1; return a.name.localeCompare(b.name); }); - + for (const entry of sortedEntries) { const fullPath = path.join(dir, entry.name); // Use relative path from the original tests directory being scanned const testsRootDir = arguments.length > 1 ? arguments[2] : dir; // Pass root as 3rd param in recursion const relativePath = path.relative(testsRootDir, fullPath); - + try { // Skip hidden files and directories unless explicitly included if (entry.name.startsWith('.') && !this._shouldIncludeHidden(relativePath)) { continue; } - + // Check exclude patterns first (more efficient) if (this._isExcluded(relativePath)) { continue; } - + if (entry.isDirectory()) { // Recursively search subdirectories, passing the root directory const subFiles = await this._findTestFiles(fullPath, depth + 1, testsRootDir); files.push(...subFiles); - } else if (entry.isFile()) { // Check if file should be included if (await this._shouldIncludeFile(fullPath, relativePath)) { files.push(fullPath); } - } else if (entry.isSymbolicLink() && this.options.followSymlinks) { // Handle symbolic links if enabled await this._handleSymlink(fullPath, relativePath, files, depth, testsRootDir); } - } catch (error) { // Handle permission errors gracefully if (error.code === 'EACCES' || error.code === 'EPERM') { @@ -700,7 +865,7 @@ class pgTAPTestScanner extends EventEmitter { } } } - + // Emit progress for completed directory const duration = Date.now() - startTime; this.emit('progress', { @@ -709,7 +874,6 @@ class pgTAPTestScanner extends EventEmitter { timestamp: new Date(), type: 'progress' }); - } catch (error) { if (error.code === 'EACCES' || error.code === 'EPERM') { this.emit('warning', { @@ -722,13 +886,13 @@ class pgTAPTestScanner extends EventEmitter { throw new Error(`Failed to read directory ${dir}: ${error.message}`); } } - + return files.sort(); // Ensure consistent ordering } - + /** * Check if a file should be included based on patterns and extensions - * + * * @param {string} fullPath - Full file path * @param {string} relativePath - Relative file path * @returns {Promise} True if file should be included @@ -740,55 +904,55 @@ class pgTAPTestScanner extends EventEmitter { if (!this.options.fileExtensions.includes(ext)) { return false; } - + // Check include patterns using minimatch for consistency - const matchesInclude = this.options.includePatterns.some(pattern => + const matchesInclude = this.options.includePatterns.some((pattern) => minimatch(relativePath, pattern, { dot: true }) ); - + if (!matchesInclude) { return false; } - + // Check legacy RegExp patterns - if (this.options.ignorePatterns.some(pattern => pattern.test(fullPath))) { + if (this.options.ignorePatterns.some((pattern) => pattern.test(fullPath))) { return false; } - + return true; } - + /** * Check if a path should be excluded based on exclude patterns - * + * * @param {string} relativePath - Relative path to check * @returns {boolean} True if path should be excluded * @private */ _isExcluded(relativePath) { - return this.options.excludePatterns.some(pattern => + return this.options.excludePatterns.some((pattern) => minimatch(relativePath, pattern, { dot: true }) ); } - + /** * Check if hidden files should be included for this specific path - * + * * @param {string} relativePath - Relative path to check * @returns {boolean} True if hidden file should be included * @private */ _shouldIncludeHidden(relativePath) { // Check if any include pattern explicitly matches this hidden path - return this.options.includePatterns.some(pattern => { + return this.options.includePatterns.some((pattern) => { // Only include hidden files if they're explicitly matched by an include pattern return pattern.includes('.') && this._matchesPattern(relativePath, pattern); }); } - + /** * Handle symbolic links during file discovery - * + * * @param {string} fullPath - Full path to the symlink * @param {string} relativePath - Relative path to the symlink * @param {string[]} files - Array to collect file paths @@ -801,11 +965,11 @@ class pgTAPTestScanner extends EventEmitter { try { const realPath = await fs.realpath(fullPath); const stat = await fs.stat(realPath); - + // Prevent infinite loops by checking if we've seen this real path before // This is a simple check - a more robust solution would track visited inodes const realpathRelative = path.relative(testsRootDir, realPath); - + if (stat.isDirectory()) { // Recursively process symlinked directory this.emit('progress', { @@ -814,17 +978,15 @@ class pgTAPTestScanner extends EventEmitter { timestamp: new Date(), type: 'progress' }); - + const subFiles = await this._findTestFiles(realPath, depth + 1, testsRootDir); files.push(...subFiles); - } else if (stat.isFile()) { // Process symlinked file if (await this._shouldIncludeFile(realPath, realpathRelative)) { files.push(realPath); // Use the real path, not the symlink path } } - } catch (error) { if (error.code === 'ENOENT') { this.emit('warning', { @@ -845,11 +1007,11 @@ class pgTAPTestScanner extends EventEmitter { } } } - + /** * Simple glob pattern matching without external dependencies * Supports basic patterns like *, **, and literal strings - * + * * @param {string} filePath - File path to test * @param {string} pattern - Glob pattern * @returns {boolean} True if path matches pattern @@ -859,52 +1021,54 @@ class pgTAPTestScanner extends EventEmitter { // Normalize paths to use forward slashes const normalizedPath = filePath.replace(/\\/g, '/'); const normalizedPattern = pattern.replace(/\\/g, '/'); - + // Handle exact matches if (normalizedPattern === normalizedPath) { return true; } - + // Handle universal wildcard patterns if (normalizedPattern === '**/*' || normalizedPattern === '**') { return true; } - + // Convert glob pattern to regex with special handling for leading ** let regexPattern = normalizedPattern; - + // Handle leading ** patterns specially if (regexPattern.startsWith('**/')) { regexPattern = regexPattern.substring(3); // Remove leading **/ // Add optional prefix matcher - either nothing or any path with / regexPattern = '(?:.*/)?' + regexPattern; } - + // Handle glob patterns BEFORE escaping special regex chars regexPattern = regexPattern - .replace(/\*\*/g, '__DOUBLESTAR__') // Temporarily mark ** - .replace(/\*/g, '__SINGLESTAR__') // Temporarily mark * - .replace(/\?/g, '__QUESTION__'); // Temporarily mark ? - + .replace(/\*\*/g, '__DOUBLESTAR__') // Temporarily mark ** + .replace(/\*/g, '__SINGLESTAR__') // Temporarily mark * + .replace(/\?/g, '__QUESTION__'); // Temporarily mark ? + // Now escape special regex characters regexPattern = regexPattern.replace(/[.+^${}()|[\]\\]/g, '\\$&'); - + // Convert back to regex patterns regexPattern = regexPattern - .replace(/__LEADINGMATCH__/g, '') // Remove the leading match marker - .replace(/__DOUBLESTAR__/g, '.*') // ** matches any chars including / - .replace(/__SINGLESTAR__/g, '[^/]*') // * matches any chars except / - .replace(/__QUESTION__/g, '[^/]'); // ? matches single char except / - + .replace(/__LEADINGMATCH__/g, '') // Remove the leading match marker + .replace(/__DOUBLESTAR__/g, '.*') // ** matches any chars including / + .replace(/__SINGLESTAR__/g, '[^/]*') // * matches any chars except / + .replace(/__QUESTION__/g, '[^/]'); // ? matches single char except / + try { const regex = new RegExp('^' + regexPattern + '$'); const result = regex.test(normalizedPath); - + // Debug logging (enable when needed) if (process.env.DEBUG_PATTERNS) { - console.log(`Pattern: '${normalizedPattern}' => Regex: '^${regexPattern}$', Path: '${normalizedPath}', Result: ${result}`); + console.log( + `Pattern: '${normalizedPattern}' => Regex: '^${regexPattern}$', Path: '${normalizedPath}', Result: ${result}` + ); } - + return result; } catch (error) { // If regex is invalid, fall back to simple string matching @@ -915,7 +1079,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Extract test plan count from SQL - * + * * @param {string} sql - SQL content * @returns {number|null} Plan count or null if not found * @private @@ -924,31 +1088,31 @@ class pgTAPTestScanner extends EventEmitter { const match = this.planPattern.exec(sql); return match ? parseInt(match[1], 10) : null; } - + /** * Extract dependencies from SQL content - * + * * @param {string} sql - SQL content * @returns {string[]} Array of dependencies found * @private */ _extractDependencies(sql) { const dependencies = []; - + // Look for common dependency patterns const includePattern = /\\i\s+['"`]([^'"`]+)['"`]/gi; let match; - + while ((match = includePattern.exec(sql)) !== null) { dependencies.push(match[1]); } - + return dependencies; } - + /** * Determine target object from assertion parameters - * + * * @param {string} assertionType - Type of assertion * @param {string[]} parameters - Assertion parameters * @returns {string} Target object identifier @@ -957,12 +1121,12 @@ class pgTAPTestScanner extends EventEmitter { _determineTarget(assertionType, parameters) { // Default logic - can be extended for specific assertion types if (parameters.length === 0) return ''; - + // For schema assertions, first parameter is schema name if (assertionType.includes('schema')) { return parameters[0]; } - + // For table assertions - Enhanced logic for new patterns if (assertionType.includes('table')) { if (assertionType.includes('_select')) { @@ -974,7 +1138,11 @@ class pgTAPTestScanner extends EventEmitter { } else if (parameters.length === 2) { // Two parameters: could be [schema, table] or [table, description] // Heuristic: if second param looks like a description (long text or empty), treat first as table - if (parameters[1].length === 0 || parameters[1].length > 30 || parameters[1].includes(' ')) { + if ( + parameters[1].length === 0 || + parameters[1].length > 30 || + parameters[1].includes(' ') + ) { // Likely [table, description] (including empty description) return `public.${parameters[0]}`; } else { @@ -994,7 +1162,11 @@ class pgTAPTestScanner extends EventEmitter { } else if (parameters.length === 2) { // Two parameters: could be [table, outer_desc] or [schema, table] // Check if second param looks like description - if (parameters[1].length === 0 || parameters[1].length > 30 || parameters[1].includes(' ')) { + if ( + parameters[1].length === 0 || + parameters[1].length > 30 || + parameters[1].includes(' ') + ) { // Likely [table, outer_description] (including empty description) return `public.${parameters[0]}`; } else { @@ -1004,7 +1176,12 @@ class pgTAPTestScanner extends EventEmitter { } else if (parameters.length >= 3) { // Three or more parameters: [schema, table, ...] or [table, inner_desc, outer_desc] // Check if first two look like schema.table pattern - if (parameters[0].length < 20 && parameters[1].length < 20 && !parameters[0].includes(' ') && !parameters[1].includes(' ')) { + if ( + parameters[0].length < 20 && + parameters[1].length < 20 && + !parameters[0].includes(' ') && + !parameters[1].includes(' ') + ) { // Likely [schema, table, ...] return `${parameters[0]}.${parameters[1]}`; } else { @@ -1041,10 +1218,12 @@ class pgTAPTestScanner extends EventEmitter { } } else { // Legacy table patterns - return parameters.length > 1 ? `${parameters[0]}.${parameters[1]}` : `public.${parameters[0]}`; + return parameters.length > 1 + ? `${parameters[0]}.${parameters[1]}` + : `public.${parameters[0]}`; } } - + // For column assertions, handle different patterns if (assertionType.includes('column') || assertionType.startsWith('col_')) { // col_type_is, col_default_is have schema, table, column, type/value @@ -1068,14 +1247,18 @@ class pgTAPTestScanner extends EventEmitter { } } } - + // For function assertions - handle specific function testing patterns - if (assertionType.includes('function') || assertionType.includes('definer') || assertionType === 'volatility_is') { + if ( + assertionType.includes('function') || + assertionType.includes('definer') || + assertionType === 'volatility_is' + ) { // Extract function name and schema for different assertion patterns - + // Handle has_function, hasnt_function patterns: // has_function('function_name') - // has_function('schema', 'function_name') + // has_function('schema', 'function_name') // has_function('function_name', ARRAY['type1', 'type2']) // has_function('schema', 'function_name', ARRAY['type1', 'type2']) if (assertionType === 'has_function' || assertionType === 'hasnt_function') { @@ -1087,7 +1270,7 @@ class pgTAPTestScanner extends EventEmitter { return parameters[0]; } } - + // Handle function_returns patterns: // function_returns('function_name', 'return_type') // function_returns('schema', 'function_name', 'return_type') @@ -1106,7 +1289,7 @@ class pgTAPTestScanner extends EventEmitter { // function, args, return_type pattern return parameters[0]; } else { - // schema, function, return_type pattern + // schema, function, return_type pattern return `${parameters[0]}.${parameters[1]}`; } } else if (parameters.length === 2) { @@ -1114,7 +1297,7 @@ class pgTAPTestScanner extends EventEmitter { return parameters[0]; } } - + // Handle function_lang_is patterns: // function_lang_is('function_name', 'language') // function_lang_is('schema', 'function_name', 'language') @@ -1128,7 +1311,7 @@ class pgTAPTestScanner extends EventEmitter { return parameters[0]; } } - + // Handle is_definer, isnt_definer patterns: // is_definer('function_name') // is_definer('schema', 'function_name') @@ -1142,7 +1325,7 @@ class pgTAPTestScanner extends EventEmitter { return parameters[0]; } } - + // Handle volatility_is patterns: // volatility_is('function_name', 'volatility') // volatility_is('schema', 'function_name', 'volatility') @@ -1156,7 +1339,7 @@ class pgTAPTestScanner extends EventEmitter { return parameters[0]; } } - + // Handle function_privs_are patterns: // function_privs_are('schema', 'function', ARRAY['type1'], 'role', ARRAY['privs']) // function_privs_are('function', ARRAY['type1'], 'role', ARRAY['privs']) @@ -1169,13 +1352,13 @@ class pgTAPTestScanner extends EventEmitter { return parameters[0]; } } - + // Fallback for any other function assertions else { return parameters.length > 1 ? `${parameters[0]}.${parameters[1]}` : parameters[0]; } } - + // For index-related assertions if (assertionType.includes('index') || assertionType.includes('unique')) { // Handle different index assertion patterns @@ -1226,9 +1409,13 @@ class pgTAPTestScanner extends EventEmitter { } } } - + // For RLS policy assertions - if (assertionType.includes('policy') || assertionType.includes('policies') || assertionType === 'is_rls_enabled') { + if ( + assertionType.includes('policy') || + assertionType.includes('policies') || + assertionType === 'is_rls_enabled' + ) { if (assertionType === 'is_rls_enabled') { // is_rls_enabled('table') or is_rls_enabled('schema', 'table') return parameters.length > 1 ? `${parameters[0]}.${parameters[1]}` : parameters[0]; @@ -1257,7 +1444,7 @@ class pgTAPTestScanner extends EventEmitter { // policies_are('table', ARRAY['policy1', 'policy2']) or policies_are('schema', 'table', ARRAY['policy1', 'policy2']) // The ARRAY[...] parameter is captured as a single parameter, so: // ['users', "'policy1', 'policy2'"] has length 2 -> target should be 'users' - // ['public', 'users', "'policy1', 'policy2'"] has length 3 -> target should be 'public.users' + // ['public', 'users', "'policy1', 'policy2'"] has length 3 -> target should be 'public.users' // ['public', 'users', "'policy1', 'policy2'", 'description'] has length 4 -> target should be 'public.users' if (parameters.length >= 4) { return `${parameters[0]}.${parameters[1]}`; @@ -1268,7 +1455,7 @@ class pgTAPTestScanner extends EventEmitter { } } } - + // For trigger assertions if (assertionType.includes('trigger')) { if (assertionType === 'has_trigger' || assertionType === 'hasnt_trigger') { @@ -1280,8 +1467,11 @@ class pgTAPTestScanner extends EventEmitter { } else if (parameters.length === 3) { // Could be: schema, table, trigger OR table, trigger, description // Heuristic: if 3rd param looks like a description (contains spaces, is very long, or contains descriptive words), treat as table, trigger, description - if (parameters[2].length > 50 || parameters[2].includes(' ') || - (parameters[2].toLowerCase().includes('trigger') && parameters[2].length > 20)) { + if ( + parameters[2].length > 50 || + parameters[2].includes(' ') || + (parameters[2].toLowerCase().includes('trigger') && parameters[2].length > 20) + ) { // Table, trigger, description return `public.${parameters[0]}.${parameters[1]}`; } else { @@ -1307,7 +1497,11 @@ class pgTAPTestScanner extends EventEmitter { return `${parameters[0]}.${parameters[1]}.${parameters[2]}`; } } - } else if (assertionType === 'is_trigger_on' || assertionType === 'trigger_fires_on' || assertionType === 'trigger_is_for') { + } else if ( + assertionType === 'is_trigger_on' || + assertionType === 'trigger_fires_on' || + assertionType === 'trigger_is_for' + ) { // is_trigger_on('table', 'trigger', 'events') or is_trigger_on('schema', 'table', 'trigger', 'events') // trigger_fires_on('table', 'trigger', 'timing') or trigger_fires_on('schema', 'table', 'trigger', 'timing') // trigger_is_for('table', 'trigger', 'level') or trigger_is_for('schema', 'table', 'trigger', 'level') @@ -1329,14 +1523,14 @@ class pgTAPTestScanner extends EventEmitter { } } } - + // Default: join non-empty parameters - return parameters.filter(p => p).join('.'); + return parameters.filter((p) => p).join('.'); } - + /** * Clean parameters for specific assertion types - * + * * @param {string} assertionType - Type of assertion * @param {string[]} parameters - Parameters array to clean in-place * @private @@ -1346,11 +1540,11 @@ class pgTAPTestScanner extends EventEmitter { if (assertionType === 'col_default_is' && parameters.length > 0) { const lastIndex = parameters.length - 1; let value = parameters[lastIndex]; - + // Remove surrounding quotes if present, but preserve inner content if (value && typeof value === 'string') { value = value.trim(); - + // Handle single quotes if (value.startsWith("'") && value.endsWith("'") && value.length > 1) { parameters[lastIndex] = value.slice(1, -1); @@ -1360,7 +1554,7 @@ class pgTAPTestScanner extends EventEmitter { parameters[lastIndex] = value.slice(1, -1); } // Handle backticks - else if (value.startsWith("`") && value.endsWith("`") && value.length > 1) { + else if (value.startsWith('`') && value.endsWith('`') && value.length > 1) { parameters[lastIndex] = value.slice(1, -1); } } @@ -1369,7 +1563,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Extract additional metadata from assertion parameters - * + * * @param {string} assertionType - Type of assertion * @param {string[]} parameters - Assertion parameters * @returns {Object} Additional metadata for the assertion @@ -1377,7 +1571,7 @@ class pgTAPTestScanner extends EventEmitter { */ _extractAssertionMetadata(assertionType, parameters) { const metadata = {}; - + // Extract metadata for table assertions if (assertionType.includes('table')) { if (assertionType.includes('_select')) { @@ -1388,7 +1582,11 @@ class pgTAPTestScanner extends EventEmitter { metadata.tableName = parameters[0]; } else if (parameters.length === 2) { // [schema, table] or [table, description] - if (parameters[1].length === 0 || parameters[1].length > 30 || parameters[1].includes(' ')) { + if ( + parameters[1].length === 0 || + parameters[1].length > 30 || + parameters[1].includes(' ') + ) { // [table, description] (including empty description) metadata.schema = 'public'; metadata.tableName = parameters[0]; @@ -1414,7 +1612,11 @@ class pgTAPTestScanner extends EventEmitter { metadata.tableName = parameters[0]; } else if (parameters.length === 2) { // [table, outer_desc] or [schema, table] - if (parameters[1].length === 0 || parameters[1].length > 30 || parameters[1].includes(' ')) { + if ( + parameters[1].length === 0 || + parameters[1].length > 30 || + parameters[1].includes(' ') + ) { // [table, outer_description] (including empty description) metadata.schema = 'public'; metadata.tableName = parameters[0]; @@ -1428,7 +1630,12 @@ class pgTAPTestScanner extends EventEmitter { } } else if (parameters.length >= 3) { // [schema, table, outer_desc] or [table, inner_desc, outer_desc] - if (parameters[0].length < 20 && parameters[1].length < 20 && !parameters[0].includes(' ') && !parameters[1].includes(' ')) { + if ( + parameters[0].length < 20 && + parameters[1].length < 20 && + !parameters[0].includes(' ') && + !parameters[1].includes(' ') + ) { // [schema, table, outer_desc] metadata.schema = parameters[0]; metadata.tableName = parameters[1]; @@ -1498,13 +1705,13 @@ class pgTAPTestScanner extends EventEmitter { } } } - + return metadata; } - + /** * Build coverage map from parsed test files - * + * * @private */ _buildCoverageMap() { @@ -1519,11 +1726,11 @@ class pgTAPTestScanner extends EventEmitter { triggers: {}, filesByTarget: {} }; - + for (const testFile of this.testFiles) { for (const assertion of testFile.assertions) { const { type, target } = assertion; - + // Categorize by assertion type if (type.includes('schema')) { this._addToCoverageMap('schemas', target, type, testFile); @@ -1531,31 +1738,39 @@ class pgTAPTestScanner extends EventEmitter { this._addToCoverageMap('tables', target, type, testFile, assertion); } else if (type.includes('column') || type.startsWith('col_')) { this._addToCoverageMap('columns', target, type, testFile); - } else if (type.includes('function') || type.includes('definer') || type === 'volatility_is') { + } else if ( + type.includes('function') || + type.includes('definer') || + type === 'volatility_is' + ) { this._addToCoverageMap('functions', target, type, testFile); - } else if (type.includes('policy') || type.includes('policies') || type === 'is_rls_enabled') { + } else if ( + type.includes('policy') || + type.includes('policies') || + type === 'is_rls_enabled' + ) { this._addToCoverageMap('policies', target, type, testFile); } else if (type.includes('index') || type.includes('unique')) { this._addToCoverageMap('indexes', target, type, testFile); } else if (type.includes('trigger')) { this._addToCoverageMap('triggers', target, type, testFile); } - + // Track files by target if (!this.coverageMap.filesByTarget[target]) { this.coverageMap.filesByTarget[target] = []; } - + if (!this.coverageMap.filesByTarget[target].includes(testFile)) { this.coverageMap.filesByTarget[target].push(testFile); } } } } - + /** * Add entry to coverage map - * + * * @param {string} category - Coverage category * @param {string} target - Target object * @param {string} assertionType - Type of assertion @@ -1579,7 +1794,7 @@ class pgTAPTestScanner extends EventEmitter { this.coverageMap[category][target] = []; } } - + if (category === 'tables' && assertion) { // Enhanced table coverage handling const tableInfo = this.coverageMap[category][target]; @@ -1600,38 +1815,38 @@ class pgTAPTestScanner extends EventEmitter { } } } - + /** * Get assertion type statistics - * + * * @returns {Object.} Count by assertion type * @private */ _getAssertionTypeStats() { const stats = {}; - + for (const testFile of this.testFiles) { for (const assertion of testFile.assertions) { stats[assertion.type] = (stats[assertion.type] || 0) + 1; } } - + return stats; } - + /** * Get coverage statistics - * + * * @returns {Object} Coverage statistics * @private */ _getCoverageStats() { // Calculate enhanced table statistics const tableStats = Object.values(this.coverageMap.tables); - const tablesWithDescriptions = tableStats.filter(table => - typeof table === 'object' && table.descriptions && table.descriptions.length > 0 + const tablesWithDescriptions = tableStats.filter( + (table) => typeof table === 'object' && table.descriptions && table.descriptions.length > 0 ).length; - + return { schemasWithTests: Object.keys(this.coverageMap.schemas).length, tablesWithTests: Object.keys(this.coverageMap.tables).length, @@ -1644,10 +1859,10 @@ class pgTAPTestScanner extends EventEmitter { uniqueTargets: Object.keys(this.coverageMap.filesByTarget).length }; } - + /** * Parse ARRAY['item1', 'item2'] parameter into array of strings - * + * * @param {string} arrayStr - Array parameter string like "'item1', 'item2'" * @returns {string[]} Array of parsed items * @private @@ -1656,12 +1871,12 @@ class pgTAPTestScanner extends EventEmitter { if (!arrayStr || !arrayStr.includes("'")) return []; // Handle both ARRAY['item1', 'item2'] and just 'item1', 'item2' formats const matches = arrayStr.match(/'([^']*)'/g); - return matches ? matches.map(m => m.slice(1, -1)) : []; + return matches ? matches.map((m) => m.slice(1, -1)) : []; } /** * Extract function metadata from assertion parameters - * + * * @param {string} assertionType - Type of assertion * @param {string[]} parameters - Assertion parameters * @returns {Object} Function metadata object @@ -1669,196 +1884,219 @@ class pgTAPTestScanner extends EventEmitter { */ _extractFunctionMetadata(assertionType, parameters) { const metadata = {}; - + // Helper function to determine if a parameter is likely a schema vs function name const isLikelySchema = (param, nextParam) => { if (!nextParam) return false; // Common schema names - const commonSchemas = ['public', 'auth', 'storage', 'extensions', 'pg_catalog', 'information_schema']; - return commonSchemas.includes(param.toLowerCase()) || param.includes('_schema') || param.includes('_db'); + const commonSchemas = [ + 'public', + 'auth', + 'storage', + 'extensions', + 'pg_catalog', + 'information_schema' + ]; + return ( + commonSchemas.includes(param.toLowerCase()) || + param.includes('_schema') || + param.includes('_db') + ); }; - + if (parameters.length === 0) return metadata; - + switch (assertionType) { - case 'has_function': - case 'hasnt_function': - // Patterns: - // has_function('function_name') - // has_function('schema', 'function_name') - // has_function('function_name', ARRAY['type1', 'type2']) - // has_function('schema', 'function_name', ARRAY['type1', 'type2']) - - if (parameters.length >= 2 && !parameters[1].includes("'")) { - // Schema and function name provided (parameters[1] doesn't contain quotes) - metadata.schema = parameters[0]; - metadata.name = parameters[1]; - - if (parameters.length >= 3) { - metadata.parameters = this._parseArrayParameter(parameters[2]); - } - } else { - // Only function name provided, or function name with parameters - metadata.name = parameters[0]; - - if (parameters.length >= 2) { - metadata.parameters = this._parseArrayParameter(parameters[1]); - } - } - break; - - case 'function_returns': - // Patterns: - // function_returns('function_name', 'return_type') - // function_returns('schema', 'function_name', 'return_type') - // function_returns('function_name', ARRAY['type1', 'type2'], 'return_type') - // function_returns('schema', 'function_name', ARRAY['type1', 'type2'], 'return_type') - - if (parameters.length >= 4) { - // Four parameters: schema, function, args, return_type - metadata.schema = parameters[0]; - metadata.name = parameters[1]; + case 'has_function': + case 'hasnt_function': + // Patterns: + // has_function('function_name') + // has_function('schema', 'function_name') + // has_function('function_name', ARRAY['type1', 'type2']) + // has_function('schema', 'function_name', ARRAY['type1', 'type2']) + + if (parameters.length >= 2 && !parameters[1].includes("'")) { + // Schema and function name provided (parameters[1] doesn't contain quotes) + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + + if (parameters.length >= 3) { metadata.parameters = this._parseArrayParameter(parameters[2]); - metadata.returnType = parameters[3]; - } else if (parameters.length === 3) { - // Three parameters could be: - // 1. function, args, return_type (parameters[1] contains quotes from ARRAY) - // 2. schema, function, return_type (no ARRAY parameter) - if (parameters[1] && parameters[1].includes("'")) { - // function, args, return_type pattern - metadata.name = parameters[0]; - metadata.parameters = this._parseArrayParameter(parameters[1]); - metadata.returnType = parameters[2]; - } else { - // schema, function, return_type pattern - metadata.schema = parameters[0]; - metadata.name = parameters[1]; - metadata.returnType = parameters[2]; - } - } else if (parameters.length >= 2) { - // Function, return_type pattern - metadata.name = parameters[0]; - metadata.returnType = parameters[1]; } - break; - - case 'function_lang_is': - // Patterns similar to function_returns but last param is language - if (parameters.length >= 3 && !parameters[1].startsWith('ARRAY') && !parameters[2].startsWith('ARRAY')) { - // Schema, function, language pattern - metadata.schema = parameters[0]; - metadata.name = parameters[1]; - metadata.language = parameters[2]; - } else if (parameters.length >= 4 && parameters[2].startsWith('ARRAY')) { - // Schema, function, args, language pattern - metadata.schema = parameters[0]; - metadata.name = parameters[1]; - metadata.parameters = this._parseArrayParameter(parameters[2]); - metadata.language = parameters[3]; - } else if (parameters.length >= 3 && parameters[1].startsWith('ARRAY')) { - // Function, args, language pattern - metadata.name = parameters[0]; + } else { + // Only function name provided, or function name with parameters + metadata.name = parameters[0]; + + if (parameters.length >= 2) { metadata.parameters = this._parseArrayParameter(parameters[1]); - metadata.language = parameters[2]; - } else if (parameters.length >= 2) { - // Function, language pattern - metadata.name = parameters[0]; - metadata.language = parameters[1]; } - break; - - case 'is_definer': - case 'isnt_definer': - // Similar patterns to has_function - if (parameters.length >= 2 && !parameters[1].includes("'") && !parameters[1].startsWith('ARRAY')) { - metadata.schema = parameters[0]; - metadata.name = parameters[1]; - - if (parameters.length >= 3 && parameters[2].startsWith('ARRAY')) { - metadata.parameters = this._parseArrayParameter(parameters[2]); - } - } else { + } + break; + + case 'function_returns': + // Patterns: + // function_returns('function_name', 'return_type') + // function_returns('schema', 'function_name', 'return_type') + // function_returns('function_name', ARRAY['type1', 'type2'], 'return_type') + // function_returns('schema', 'function_name', ARRAY['type1', 'type2'], 'return_type') + + if (parameters.length >= 4) { + // Four parameters: schema, function, args, return_type + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + metadata.parameters = this._parseArrayParameter(parameters[2]); + metadata.returnType = parameters[3]; + } else if (parameters.length === 3) { + // Three parameters could be: + // 1. function, args, return_type (parameters[1] contains quotes from ARRAY) + // 2. schema, function, return_type (no ARRAY parameter) + if (parameters[1] && parameters[1].includes("'")) { + // function, args, return_type pattern metadata.name = parameters[0]; - - if (parameters.length >= 2 && parameters[1].startsWith('ARRAY')) { - metadata.parameters = this._parseArrayParameter(parameters[1]); - } - } - - metadata.isSecurityDefiner = assertionType === 'is_definer'; - break; - - case 'volatility_is': - // Similar patterns to function_lang_is but last param is volatility - if (parameters.length >= 3 && !parameters[1].startsWith('ARRAY') && !parameters[2].startsWith('ARRAY')) { - // Schema, function, volatility pattern - metadata.schema = parameters[0]; - metadata.name = parameters[1]; - metadata.volatility = parameters[2]; - } else if (parameters.length >= 4 && parameters[2].startsWith('ARRAY')) { - // Schema, function, args, volatility pattern + metadata.parameters = this._parseArrayParameter(parameters[1]); + metadata.returnType = parameters[2]; + } else { + // schema, function, return_type pattern metadata.schema = parameters[0]; metadata.name = parameters[1]; + metadata.returnType = parameters[2]; + } + } else if (parameters.length >= 2) { + // Function, return_type pattern + metadata.name = parameters[0]; + metadata.returnType = parameters[1]; + } + break; + + case 'function_lang_is': + // Patterns similar to function_returns but last param is language + if ( + parameters.length >= 3 && + !parameters[1].startsWith('ARRAY') && + !parameters[2].startsWith('ARRAY') + ) { + // Schema, function, language pattern + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + metadata.language = parameters[2]; + } else if (parameters.length >= 4 && parameters[2].startsWith('ARRAY')) { + // Schema, function, args, language pattern + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + metadata.parameters = this._parseArrayParameter(parameters[2]); + metadata.language = parameters[3]; + } else if (parameters.length >= 3 && parameters[1].startsWith('ARRAY')) { + // Function, args, language pattern + metadata.name = parameters[0]; + metadata.parameters = this._parseArrayParameter(parameters[1]); + metadata.language = parameters[2]; + } else if (parameters.length >= 2) { + // Function, language pattern + metadata.name = parameters[0]; + metadata.language = parameters[1]; + } + break; + + case 'is_definer': + case 'isnt_definer': + // Similar patterns to has_function + if ( + parameters.length >= 2 && + !parameters[1].includes("'") && + !parameters[1].startsWith('ARRAY') + ) { + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + + if (parameters.length >= 3 && parameters[2].startsWith('ARRAY')) { metadata.parameters = this._parseArrayParameter(parameters[2]); - metadata.volatility = parameters[3]; - } else if (parameters.length >= 3 && parameters[1].startsWith('ARRAY')) { - // Function, args, volatility pattern - metadata.name = parameters[0]; + } + } else { + metadata.name = parameters[0]; + + if (parameters.length >= 2 && parameters[1].startsWith('ARRAY')) { metadata.parameters = this._parseArrayParameter(parameters[1]); - metadata.volatility = parameters[2]; - } else if (parameters.length >= 2) { - // Function, volatility pattern - metadata.name = parameters[0]; - metadata.volatility = parameters[1]; } - break; - - case 'function_privs_are': - // Patterns: - // function_privs_are('schema', 'function', ARRAY['type1'], 'role', ARRAY['privs']) - // function_privs_are('function', ARRAY['type1'], 'role', ARRAY['privs']) - // function_privs_are('schema', 'function', 'role', ARRAY['privs']) - // function_privs_are('function', 'role', ARRAY['privs']) - - if (parameters.length >= 5) { - // Full pattern with schema, function, args, role, privs + } + + metadata.isSecurityDefiner = assertionType === 'is_definer'; + break; + + case 'volatility_is': + // Similar patterns to function_lang_is but last param is volatility + if ( + parameters.length >= 3 && + !parameters[1].startsWith('ARRAY') && + !parameters[2].startsWith('ARRAY') + ) { + // Schema, function, volatility pattern + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + metadata.volatility = parameters[2]; + } else if (parameters.length >= 4 && parameters[2].startsWith('ARRAY')) { + // Schema, function, args, volatility pattern + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + metadata.parameters = this._parseArrayParameter(parameters[2]); + metadata.volatility = parameters[3]; + } else if (parameters.length >= 3 && parameters[1].startsWith('ARRAY')) { + // Function, args, volatility pattern + metadata.name = parameters[0]; + metadata.parameters = this._parseArrayParameter(parameters[1]); + metadata.volatility = parameters[2]; + } else if (parameters.length >= 2) { + // Function, volatility pattern + metadata.name = parameters[0]; + metadata.volatility = parameters[1]; + } + break; + + case 'function_privs_are': + // Patterns: + // function_privs_are('schema', 'function', ARRAY['type1'], 'role', ARRAY['privs']) + // function_privs_are('function', ARRAY['type1'], 'role', ARRAY['privs']) + // function_privs_are('schema', 'function', 'role', ARRAY['privs']) + // function_privs_are('function', 'role', ARRAY['privs']) + + if (parameters.length >= 5) { + // Full pattern with schema, function, args, role, privs + metadata.schema = parameters[0]; + metadata.name = parameters[1]; + if (parameters[2].startsWith('ARRAY')) { + metadata.parameters = this._parseArrayParameter(parameters[2]); + metadata.role = parameters[3]; + metadata.privileges = this._parseArrayParameter(parameters[4]); + } + } else if (parameters.length >= 4) { + // Could be: schema, function, role, privs OR function, args, role, privs + if (parameters[1].startsWith('ARRAY')) { + // Function, args, role, privs + metadata.name = parameters[0]; + metadata.parameters = this._parseArrayParameter(parameters[1]); + metadata.role = parameters[2]; + metadata.privileges = this._parseArrayParameter(parameters[3]); + } else { + // Schema, function, role, privs metadata.schema = parameters[0]; metadata.name = parameters[1]; - if (parameters[2].startsWith('ARRAY')) { - metadata.parameters = this._parseArrayParameter(parameters[2]); - metadata.role = parameters[3]; - metadata.privileges = this._parseArrayParameter(parameters[4]); - } - } else if (parameters.length >= 4) { - // Could be: schema, function, role, privs OR function, args, role, privs - if (parameters[1].startsWith('ARRAY')) { - // Function, args, role, privs - metadata.name = parameters[0]; - metadata.parameters = this._parseArrayParameter(parameters[1]); - metadata.role = parameters[2]; - metadata.privileges = this._parseArrayParameter(parameters[3]); - } else { - // Schema, function, role, privs - metadata.schema = parameters[0]; - metadata.name = parameters[1]; - metadata.role = parameters[2]; - metadata.privileges = this._parseArrayParameter(parameters[3]); - } - } else if (parameters.length >= 3) { - // Function, role, privs - metadata.name = parameters[0]; - metadata.role = parameters[1]; - metadata.privileges = this._parseArrayParameter(parameters[2]); + metadata.role = parameters[2]; + metadata.privileges = this._parseArrayParameter(parameters[3]); } - break; + } else if (parameters.length >= 3) { + // Function, role, privs + metadata.name = parameters[0]; + metadata.role = parameters[1]; + metadata.privileges = this._parseArrayParameter(parameters[2]); + } + break; } - + return metadata; } /** * Extract RLS policy metadata from assertion parameters - * + * * @param {string} assertionType - Type of assertion * @param {string[]} parameters - Assertion parameters * @returns {Object} Policy metadata object @@ -1866,116 +2104,120 @@ class pgTAPTestScanner extends EventEmitter { */ _extractPolicyMetadata(assertionType, parameters) { const metadata = {}; - + // Helper function to parse array parameters like ARRAY['role1', 'role2'] or ARRAY['policy1', 'policy2'] const parseArrayParameter = (arrayStr) => { if (!arrayStr || !arrayStr.includes("'")) return []; // Extract quoted items from array string const matches = arrayStr.match(/'([^']*)'/g); - return matches ? matches.map(m => m.slice(1, -1)) : []; + return matches ? matches.map((m) => m.slice(1, -1)) : []; }; - + if (parameters.length === 0) return metadata; - + switch (assertionType) { - case 'is_rls_enabled': - // is_rls_enabled('table') or is_rls_enabled('schema', 'table') - if (parameters.length >= 2) { - metadata.schema = parameters[0]; - metadata.tableName = parameters[1]; - } else { - metadata.schema = 'public'; // Default schema - metadata.tableName = parameters[0]; - } - break; - - case 'policy_exists': - // policy_exists('table', 'policy_name') or policy_exists('schema', 'table', 'policy_name') - if (parameters.length >= 3) { - metadata.schema = parameters[0]; - metadata.tableName = parameters[1]; - metadata.policyName = parameters[2]; - } else if (parameters.length === 2) { - metadata.schema = 'public'; - metadata.tableName = parameters[0]; - metadata.policyName = parameters[1]; - } - break; - - case 'policy_cmd_is': - // policy_cmd_is('table', 'policy', 'SELECT') or policy_cmd_is('schema', 'table', 'policy', 'SELECT') - if (parameters.length >= 4) { - metadata.schema = parameters[0]; - metadata.tableName = parameters[1]; - metadata.policyName = parameters[2]; - metadata.command = parameters[3]; - } else if (parameters.length >= 3) { - metadata.schema = 'public'; - metadata.tableName = parameters[0]; - metadata.policyName = parameters[1]; - metadata.command = parameters[2]; - } - break; - - case 'policy_roles_are': - // policy_roles_are('table', 'policy', ARRAY['role']) or policy_roles_are('schema', 'table', 'policy', ARRAY['role']) + case 'is_rls_enabled': + // is_rls_enabled('table') or is_rls_enabled('schema', 'table') + if (parameters.length >= 2) { + metadata.schema = parameters[0]; + metadata.tableName = parameters[1]; + } else { + metadata.schema = 'public'; // Default schema + metadata.tableName = parameters[0]; + } + break; + + case 'policy_exists': + // policy_exists('table', 'policy_name') or policy_exists('schema', 'table', 'policy_name') + if (parameters.length >= 3) { + metadata.schema = parameters[0]; + metadata.tableName = parameters[1]; + metadata.policyName = parameters[2]; + } else if (parameters.length === 2) { + metadata.schema = 'public'; + metadata.tableName = parameters[0]; + metadata.policyName = parameters[1]; + } + break; + + case 'policy_cmd_is': + // policy_cmd_is('table', 'policy', 'SELECT') or policy_cmd_is('schema', 'table', 'policy', 'SELECT') + if (parameters.length >= 4) { + metadata.schema = parameters[0]; + metadata.tableName = parameters[1]; + metadata.policyName = parameters[2]; + metadata.command = parameters[3]; + } else if (parameters.length >= 3) { + metadata.schema = 'public'; + metadata.tableName = parameters[0]; + metadata.policyName = parameters[1]; + metadata.command = parameters[2]; + } + break; + + case 'policy_roles_are': + // policy_roles_are('table', 'policy', ARRAY['role']) or policy_roles_are('schema', 'table', 'policy', ARRAY['role']) + if (parameters.length >= 4) { + metadata.schema = parameters[0]; + metadata.tableName = parameters[1]; + metadata.policyName = parameters[2]; + metadata.roles = parseArrayParameter(parameters[3]); + } else if (parameters.length >= 3) { + metadata.schema = 'public'; + metadata.tableName = parameters[0]; + metadata.policyName = parameters[1]; + metadata.roles = parseArrayParameter(parameters[2]); + } + break; + + case 'policies_are': + // policies_are('table', ARRAY['policy1', 'policy2']) or policies_are('schema', 'table', ARRAY['policy1', 'policy2']) + if (parameters.length >= 3) { + metadata.schema = parameters[0]; + metadata.tableName = parameters[1]; + metadata.policies = parseArrayParameter(parameters[2]); if (parameters.length >= 4) { - metadata.schema = parameters[0]; - metadata.tableName = parameters[1]; - metadata.policyName = parameters[2]; - metadata.roles = parseArrayParameter(parameters[3]); - } else if (parameters.length >= 3) { - metadata.schema = 'public'; - metadata.tableName = parameters[0]; - metadata.policyName = parameters[1]; - metadata.roles = parseArrayParameter(parameters[2]); + metadata.description = parameters[3]; } - break; - - case 'policies_are': - // policies_are('table', ARRAY['policy1', 'policy2']) or policies_are('schema', 'table', ARRAY['policy1', 'policy2']) + } else if (parameters.length >= 2) { + metadata.schema = 'public'; + metadata.tableName = parameters[0]; + metadata.policies = parseArrayParameter(parameters[1]); if (parameters.length >= 3) { - metadata.schema = parameters[0]; - metadata.tableName = parameters[1]; - metadata.policies = parseArrayParameter(parameters[2]); - if (parameters.length >= 4) { - metadata.description = parameters[3]; - } - } else if (parameters.length >= 2) { - metadata.schema = 'public'; - metadata.tableName = parameters[0]; - metadata.policies = parseArrayParameter(parameters[1]); - if (parameters.length >= 3) { - metadata.description = parameters[2]; - } + metadata.description = parameters[2]; } - break; + } + break; } - + return metadata; } /** * Build a comprehensive coverage database from all scanned test files - * + * * This method processes all test files and builds an enhanced coverage database * that indexes coverage by object type and name, tracks assertion counts, * and enables efficient querying for coverage analysis. - * + * * @returns {Object} Enhanced coverage database * @public */ async buildCoverageDatabase() { - this.emit('progress', new ProgressEvent('Building coverage database with memory management...')); - + this.emit( + 'progress', + new ProgressEvent('Building coverage database with memory management...') + ); + // Check if we should use streaming mode based on file count and memory const initialMemory = MemoryMonitor.getMemoryUsage(); - const shouldStream = this.options.enableStreaming && - (this.testFiles.length > this.options.batchSize || - initialMemory.heapUsed > (this.options.maxMemoryMB * 0.5)); - + const shouldStream = + this.options.enableStreaming && + (this.testFiles.length > this.options.batchSize || + initialMemory.heapUsed > this.options.maxMemoryMB * 0.5); + if (shouldStream) { - return await this._buildCoverageDatabaseBatched(); + return this._buildCoverageDatabaseBatched(); } else { return this._buildCoverageDatabaseStandard(); } @@ -1987,11 +2229,11 @@ class pgTAPTestScanner extends EventEmitter { */ _buildCoverageDatabaseStandard() { const database = this._createEmptyDatabase(); - + // Process files with periodic memory checks for (let i = 0; i < this.testFiles.length; i++) { const testFile = this.testFiles[i]; - + // Check memory every 10 files if (i % 10 === 0) { const memUsage = MemoryMonitor.getMemoryUsage(); @@ -2005,13 +2247,16 @@ class pgTAPTestScanner extends EventEmitter { this._identifyCoverageGaps(database); this.coverageDatabase = database; - - this.emit('success', new SuccessEvent('Coverage database built successfully', { - totalObjects: this._getTotalIndexedObjects(database), - totalAssertions: database.assertionCounts.total, - coverage: this._calculateOverallCoverage(database), - memoryStats: this.getMemoryStats() - })); + + this.emit( + 'success', + new SuccessEvent('Coverage database built successfully', { + totalObjects: this._getTotalIndexedObjects(database), + totalAssertions: database.assertionCounts.total, + coverage: this._calculateOverallCoverage(database), + memoryStats: this.getMemoryStats() + }) + ); return database; } @@ -2023,44 +2268,44 @@ class pgTAPTestScanner extends EventEmitter { async _buildCoverageDatabaseBatched() { this.memoryState.streamingMode = true; const database = this._createEmptyDatabase(); - + // Use BatchProcessor for memory-managed processing - await this.batchProcessor.processBatches( - this.testFiles, - async (batch, batchIndex) => { - // Check if streaming DB should limit objects - if (this.streamingDB) { - for (const testFile of batch) { - if (!this.streamingDB.addObject('files', testFile.filePath, testFile)) { - this.emit('warning', { - type: 'memory_limit', - message: `File processing limit reached at batch ${batchIndex}` - }); - break; - } - } - } - - // Process batch files + await this.batchProcessor.processBatches(this.testFiles, async (batch, batchIndex) => { + // Check if streaming DB should limit objects + if (this.streamingDB) { for (const testFile of batch) { - this._processFileForDatabase(testFile, database); + if (!this.streamingDB.addObject('files', testFile.filePath, testFile)) { + this.emit('warning', { + type: 'memory_limit', + message: `File processing limit reached at batch ${batchIndex}` + }); + break; + } } - - this.memoryState.batchesProcessed++; - - return batch.map(f => f.filePath); } - ); + + // Process batch files + for (const testFile of batch) { + this._processFileForDatabase(testFile, database); + } + + this.memoryState.batchesProcessed++; + + return batch.map((f) => f.filePath); + }); this._identifyCoverageGaps(database); this.coverageDatabase = database; - - this.emit('success', new SuccessEvent('Batched coverage database built successfully', { - totalObjects: this._getTotalIndexedObjects(database), - totalAssertions: database.assertionCounts.total, - coverage: this._calculateOverallCoverage(database), - memoryStats: this.getMemoryStats() - })); + + this.emit( + 'success', + new SuccessEvent('Batched coverage database built successfully', { + totalObjects: this._getTotalIndexedObjects(database), + totalAssertions: database.assertionCounts.total, + coverage: this._calculateOverallCoverage(database), + memoryStats: this.getMemoryStats() + }) + ); return database; } @@ -2126,7 +2371,7 @@ class pgTAPTestScanner extends EventEmitter { for (const assertion of testFile.assertions) { database.assertionCounts.total++; this.memoryState.objectsProcessed++; - + // Track assertion types const typeCount = database.assertionCounts.byType.get(assertion.type) || 0; database.assertionCounts.byType.set(assertion.type, typeCount + 1); @@ -2138,7 +2383,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Get coverage information for a specific database object - * + * * @param {string} objectType - Type of object (table, column, function, etc.) * @param {string} objectName - Name/identifier of the object * @returns {Object|null} Coverage information for the object @@ -2151,29 +2396,30 @@ class pgTAPTestScanner extends EventEmitter { const normalizedType = objectType.toLowerCase(); const objectMap = this.coverageDatabase.objects[normalizedType]; - + if (!objectMap || !objectMap.has(objectName)) { return null; } const objectCoverage = objectMap.get(objectName); - + // Calculate coverage percentage for this object const totalPossibleAssertions = this._estimateMaxAssertions(normalizedType, objectName); - const coveragePercentage = totalPossibleAssertions > 0 - ? Math.round((objectCoverage.assertions.length / totalPossibleAssertions) * 100) - : 100; + const coveragePercentage = + totalPossibleAssertions > 0 + ? Math.round((objectCoverage.assertions.length / totalPossibleAssertions) * 100) + : 100; return { objectType: normalizedType, objectName, assertionCount: objectCoverage.assertions.length, assertionTypes: [...objectCoverage.assertionTypes], - testFiles: [...objectCoverage.testFiles].map(f => f.fileName), + testFiles: [...objectCoverage.testFiles].map((f) => f.fileName), metadata: objectCoverage.metadata, coveragePercentage, lastTested: objectCoverage.lastTested, - assertions: objectCoverage.assertions.map(a => ({ + assertions: objectCoverage.assertions.map((a) => ({ type: a.type, testFile: a.testFile.fileName, lineNumber: a.lineNumber, @@ -2184,7 +2430,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Get comprehensive coverage statistics with percentages and analysis - * + * * @returns {Object} Detailed coverage statistics * @public */ @@ -2250,7 +2496,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Export coverage report in various formats - * + * * @param {Object} [options={}] - Export options * @param {string} [options.format='json'] - Export format (json, csv, html, markdown) * @param {boolean} [options.includeGaps=true] - Include coverage gaps in report @@ -2294,20 +2540,20 @@ class pgTAPTestScanner extends EventEmitter { // Format the report based on requested format switch (format.toLowerCase()) { - case 'json': - return JSON.stringify(report, null, 2); - - case 'csv': - return this._formatReportAsCsv(report); - - case 'html': - return this._formatReportAsHtml(report); - - case 'markdown': - return this._formatReportAsMarkdown(report); - - default: - throw new Error(`Unsupported export format: ${format}`); + case 'json': + return JSON.stringify(report, null, 2); + + case 'csv': + return this._formatReportAsCsv(report); + + case 'html': + return this._formatReportAsHtml(report); + + case 'markdown': + return this._formatReportAsMarkdown(report); + + default: + throw new Error(`Unsupported export format: ${format}`); } } @@ -2315,7 +2561,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Index a single assertion in the coverage database - * + * * @param {Object} database - Coverage database being built * @param {TestAssertion} assertion - Assertion to index * @param {TestFile} testFile - Test file containing the assertion @@ -2323,14 +2569,14 @@ class pgTAPTestScanner extends EventEmitter { */ _indexAssertionInDatabase(database, assertion, testFile) { const { type, target } = assertion; - + // Determine object type and name from assertion const objectInfo = this._parseObjectFromTarget(type, target); if (!objectInfo) return; const { objectType, objectName } = objectInfo; const objectMap = database.objects[objectType]; - + if (!objectMap) return; // Get or create object entry @@ -2345,7 +2591,7 @@ class pgTAPTestScanner extends EventEmitter { } const objectEntry = objectMap.get(objectName); - + // Add assertion to object entry objectEntry.assertions.push({ type, @@ -2355,14 +2601,17 @@ class pgTAPTestScanner extends EventEmitter { description: assertion.description, parameters: assertion.parameters }); - + objectEntry.assertionTypes.add(type); objectEntry.testFiles.add(testFile); objectEntry.lastTested = new Date().toISOString(); - + // Store additional metadata based on assertion type if (assertion.functionMetadata) { - objectEntry.metadata.function = { ...objectEntry.metadata.function, ...assertion.functionMetadata }; + objectEntry.metadata.function = { + ...objectEntry.metadata.function, + ...assertion.functionMetadata + }; } if (assertion.policyMetadata) { objectEntry.metadata.policy = { ...objectEntry.metadata.policy, ...assertion.policyMetadata }; @@ -2376,7 +2625,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Parse object type and name from assertion target - * + * * @param {string} assertionType - Type of assertion * @param {string} target - Target string from assertion * @returns {Object|null} Object type and name @@ -2421,18 +2670,18 @@ class pgTAPTestScanner extends EventEmitter { /** * Identify coverage gaps in the database - * + * * @param {Object} database - Coverage database * @private */ _identifyCoverageGaps(database) { - // This is a simplified implementation - in practice, you'd want to + // This is a simplified implementation - in practice, you'd want to // compare against actual database schema to find truly uncovered objects - + for (const [objectType, objectMap] of Object.entries(database.objects)) { for (const [objectName, objectData] of objectMap.entries()) { const assertionCount = objectData.assertions.length; - + // Consider objects with very few assertions as having coverage gaps if (assertionCount === 0) { database.gaps.uncoveredObjects.add(`${objectType}:${objectName}`); @@ -2445,7 +2694,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Calculate overall coverage percentage - * + * * @param {Object} database - Coverage database * @returns {number} Coverage percentage * @private @@ -2453,51 +2702,50 @@ class pgTAPTestScanner extends EventEmitter { _calculateOverallCoverage(database) { const totalObjects = this._getTotalIndexedObjects(database); const uncoveredObjects = database.gaps.uncoveredObjects.size; - + if (totalObjects === 0) return 100; - + const coveredObjects = totalObjects - uncoveredObjects; return Math.round((coveredObjects / totalObjects) * 100); } /** * Get total number of indexed objects across all types - * + * * @param {Object} database - Coverage database * @returns {number} Total object count * @private */ _getTotalIndexedObjects(database) { - return Object.values(database.objects) - .reduce((total, objectMap) => total + objectMap.size, 0); + return Object.values(database.objects).reduce((total, objectMap) => total + objectMap.size, 0); } /** * Calculate coverage percentage for a specific object type - * + * * @param {string} objectType - Type of object * @returns {number} Coverage percentage * @private */ _calculateTypesCoverage(objectType) { if (!this.coverageDatabase) return 0; - + const objectMap = this.coverageDatabase.objects[objectType]; if (!objectMap || objectMap.size === 0) return 0; - + let coveredCount = 0; for (const [, objectData] of objectMap.entries()) { if (objectData.assertions.length > 0) { coveredCount++; } } - + return Math.round((coveredCount / objectMap.size) * 100); } /** * Estimate maximum possible assertions for an object type - * + * * @param {string} objectType - Type of object * @param {string} objectName - Name of object * @returns {number} Estimated maximum assertions @@ -2506,96 +2754,98 @@ class pgTAPTestScanner extends EventEmitter { _estimateMaxAssertions(objectType, objectName) { // These are rough estimates - could be enhanced with actual schema introspection switch (objectType) { - case 'tables': - return 8; // has_table, table_privs, columns, constraints, etc. - case 'columns': - return 4; // has_column, col_type_is, col_default_is, col_not_null - case 'functions': - return 6; // has_function, function_returns, function_lang, etc. - case 'indexes': - return 3; // has_index, index_is_unique, index_is_primary - case 'triggers': - return 4; // has_trigger, trigger_is, etc. - case 'policies': - return 3; // policy_is, policy_cmd, etc. - case 'schemas': - return 2; // has_schema, schema_owner - default: - return 3; + case 'tables': + return 8; // has_table, table_privs, columns, constraints, etc. + case 'columns': + return 4; // has_column, col_type_is, col_default_is, col_not_null + case 'functions': + return 6; // has_function, function_returns, function_lang, etc. + case 'indexes': + return 3; // has_index, index_is_unique, index_is_primary + case 'triggers': + return 4; // has_trigger, trigger_is, etc. + case 'policies': + return 3; // policy_is, policy_cmd, etc. + case 'schemas': + return 2; // has_schema, schema_owner + default: + return 3; } } /** * Get minimum assertion threshold for object type - * + * * @param {string} objectType - Type of object * @returns {number} Minimum assertion threshold * @private */ _getMinimumAssertionThreshold(objectType) { switch (objectType) { - case 'tables': - return 2; // At minimum should test existence and basic properties - case 'functions': - return 2; // Should test existence and return type - case 'columns': - return 1; // At minimum test type - default: - return 1; + case 'tables': + return 2; // At minimum should test existence and basic properties + case 'functions': + return 2; // Should test existence and return type + case 'columns': + return 1; // At minimum test type + default: + return 1; } } /** * Count files with high coverage (multiple assertions per object) - * + * * @returns {number} Count of high coverage files * @private */ _countHighCoverageFiles() { let highCoverageCount = 0; - + for (const testFile of this.testFiles) { - if (testFile.assertions.length >= 5) { // Arbitrary threshold + if (testFile.assertions.length >= 5) { + // Arbitrary threshold highCoverageCount++; } } - + return highCoverageCount; } /** * Count objects that have multiple test types - * + * * @returns {number} Count of multi-tested objects * @private */ _countMultiTestedObjects() { if (!this.coverageDatabase) return 0; - + let multiTestedCount = 0; - + for (const objectMap of Object.values(this.coverageDatabase.objects)) { for (const [, objectData] of objectMap.entries()) { - if (objectData.assertionTypes.size >= 3) { // Multiple assertion types + if (objectData.assertionTypes.size >= 3) { + // Multiple assertion types multiTestedCount++; } } } - + return multiTestedCount; } /** * Categorize uncovered objects by type - * + * * @returns {Object} Uncovered objects by category * @private */ _categorizeUncoveredObjects() { if (!this.coverageDatabase) return {}; - + const categorized = {}; - + for (const objectRef of this.coverageDatabase.gaps.uncoveredObjects) { const [objectType] = objectRef.split(':'); if (!categorized[objectType]) { @@ -2603,55 +2853,55 @@ class pgTAPTestScanner extends EventEmitter { } categorized[objectType].push(objectRef); } - + return categorized; } /** * Generate test recommendations based on coverage gaps - * + * * @returns {string[]} Array of test recommendations * @private */ _generateTestRecommendations() { const recommendations = []; - + if (!this.coverageDatabase) return recommendations; - + // Analyze gaps and suggest specific tests for (const objectRef of this.coverageDatabase.gaps.uncoveredObjects) { const [objectType, objectName] = objectRef.split(':', 2); - + switch (objectType) { - case 'tables': - recommendations.push(`Add has_table test for ${objectName}`); - break; - case 'functions': - recommendations.push(`Add has_function test for ${objectName}`); - break; - case 'columns': - recommendations.push(`Add column type test for ${objectName}`); - break; - default: - recommendations.push(`Add test coverage for ${objectType}: ${objectName}`); + case 'tables': + recommendations.push(`Add has_table test for ${objectName}`); + break; + case 'functions': + recommendations.push(`Add has_function test for ${objectName}`); + break; + case 'columns': + recommendations.push(`Add column type test for ${objectName}`); + break; + default: + recommendations.push(`Add test coverage for ${objectType}: ${objectName}`); } } - + return recommendations.slice(0, 20); // Limit recommendations } /** * Get top tested objects - * + * * @param {number} limit - Maximum number to return * @returns {Array} Array of top tested objects * @private */ _getTopTestedObjects(limit = 10) { if (!this.coverageDatabase) return []; - + const objectStats = []; - + for (const [objectType, objectMap] of Object.entries(this.coverageDatabase.objects)) { for (const [objectName, objectData] of objectMap.entries()) { objectStats.push({ @@ -2663,15 +2913,13 @@ class pgTAPTestScanner extends EventEmitter { }); } } - - return objectStats - .sort((a, b) => b.assertionCount - a.assertionCount) - .slice(0, limit); + + return objectStats.sort((a, b) => b.assertionCount - a.assertionCount).slice(0, limit); } /** * Build detailed coverage report data - * + * * @param {string[]} objectTypes - Object types to include * @param {boolean} includeDetails - Include detailed assertion info * @returns {Object} Coverage report data @@ -2679,17 +2927,17 @@ class pgTAPTestScanner extends EventEmitter { */ _buildCoverageReport(objectTypes, includeDetails) { const report = {}; - + if (!this.coverageDatabase) return report; - + const typesToInclude = objectTypes || Object.keys(this.coverageDatabase.objects); - + for (const objectType of typesToInclude) { const objectMap = this.coverageDatabase.objects[objectType]; if (!objectMap) continue; - + report[objectType] = {}; - + for (const [objectName, objectData] of objectMap.entries()) { const objectReport = { assertionCount: objectData.assertions.length, @@ -2697,57 +2945,58 @@ class pgTAPTestScanner extends EventEmitter { testFileCount: objectData.testFiles.size, lastTested: objectData.lastTested }; - + if (includeDetails) { - objectReport.assertions = objectData.assertions.map(a => ({ + objectReport.assertions = objectData.assertions.map((a) => ({ type: a.type, testFile: a.testFile.fileName, lineNumber: a.lineNumber, description: a.description })); } - + report[objectType][objectName] = objectReport; } } - + return report; } /** * Format report as CSV - * + * * @param {Object} report - Report data * @returns {string} CSV formatted report * @private */ _formatReportAsCsv(report) { const lines = ['Object Type,Object Name,Assertion Count,Assertion Types,Test Files,Coverage %']; - + for (const [objectType, objects] of Object.entries(report.coverage)) { for (const [objectName, data] of Object.entries(objects)) { const maxAssertions = this._estimateMaxAssertions(objectType, objectName); - const coverage = maxAssertions > 0 - ? Math.round((data.assertionCount / maxAssertions) * 100) - : 100; - - lines.push([ - objectType, - objectName, - data.assertionCount, - data.assertionTypes.length, - data.testFileCount, - coverage - ].join(',')); + const coverage = + maxAssertions > 0 ? Math.round((data.assertionCount / maxAssertions) * 100) : 100; + + lines.push( + [ + objectType, + objectName, + data.assertionCount, + data.assertionTypes.length, + data.testFileCount, + coverage + ].join(',') + ); } } - + return lines.join('\n'); } /** * Format report as HTML - * + * * @param {Object} report - Report data * @returns {string} HTML formatted report * @private @@ -2797,7 +3046,7 @@ class pgTAPTestScanner extends EventEmitter { /** * Format report as Markdown - * + * * @param {Object} report - Report data * @returns {string} Markdown formatted report * @private @@ -2817,48 +3066,48 @@ class pgTAPTestScanner extends EventEmitter { '## Coverage by Object Type', '' ]; - + for (const [objectType, objects] of Object.entries(report.coverage)) { lines.push(`### ${objectType.charAt(0).toUpperCase() + objectType.slice(1)}`); lines.push(''); lines.push('| Object Name | Assertions | Types | Files | Coverage |'); lines.push('|-------------|------------|-------|-------|----------|'); - + for (const [objectName, data] of Object.entries(objects)) { const maxAssertions = this._estimateMaxAssertions(objectType, objectName); - const coverage = maxAssertions > 0 - ? Math.round((data.assertionCount / maxAssertions) * 100) - : 100; - - lines.push(`| ${objectName} | ${data.assertionCount} | ${data.assertionTypes.length} | ${data.testFileCount} | ${coverage}% |`); + const coverage = + maxAssertions > 0 ? Math.round((data.assertionCount / maxAssertions) * 100) : 100; + + lines.push( + `| ${objectName} | ${data.assertionCount} | ${data.assertionTypes.length} | ${data.testFileCount} | ${coverage}% |` + ); } - + lines.push(''); } - + return lines.join('\n'); } /** * Generate HTML table rows for coverage report - * + * * @param {Object} coverage - Coverage data * @returns {string} HTML table rows * @private */ _generateHtmlTableRows(coverage) { const rows = []; - + for (const [objectType, objects] of Object.entries(coverage)) { for (const [objectName, data] of Object.entries(objects)) { const maxAssertions = this._estimateMaxAssertions(objectType, objectName); - const coverage = maxAssertions > 0 - ? Math.round((data.assertionCount / maxAssertions) * 100) - : 100; - - const coverageClass = coverage >= 80 ? 'high-coverage' : - coverage >= 50 ? 'medium-coverage' : 'low-coverage'; - + const coverage = + maxAssertions > 0 ? Math.round((data.assertionCount / maxAssertions) * 100) : 100; + + const coverageClass = + coverage >= 80 ? 'high-coverage' : coverage >= 50 ? 'medium-coverage' : 'low-coverage'; + rows.push(` ${objectType} ${objectName} @@ -2869,12 +3118,12 @@ class pgTAPTestScanner extends EventEmitter { `); } } - + return rows.join('\n'); } - + // Memory Management Methods - + /** * Initialize memory monitoring and management * @private @@ -2883,14 +3132,14 @@ class pgTAPTestScanner extends EventEmitter { // Initialize streaming database and batch processor this.streamingDB = new StreamingCoverageDatabase(this.options); this.batchProcessor = new BatchProcessor(this, this.options); - + // Set up periodic memory monitoring if (this.options.cleanupInterval > 0) { this.memoryMonitoringInterval = setInterval(() => { this._checkMemoryUsage(); }, this.options.cleanupInterval); } - + // Listen for process events process.once('exit', () => this._cleanup()); process.once('SIGINT', () => this._cleanup()); @@ -2919,7 +3168,6 @@ class pgTAPTestScanner extends EventEmitter { }); } - /** * Perform memory cleanup operations * @private @@ -2949,7 +3197,7 @@ class pgTAPTestScanner extends EventEmitter { } this.memoryState.lastCleanup = Date.now(); - + this.emit('cleanup', { type: 'memory_cleanup', memoryUsage: MemoryMonitor.getMemoryUsage(), @@ -2963,23 +3211,23 @@ class pgTAPTestScanner extends EventEmitter { */ _limitObjectAccumulation() { // Limit coverage map sizes - Object.keys(this.coverageMap).forEach(type => { + Object.keys(this.coverageMap).forEach((type) => { if (type === 'filesByTarget') return; - + const objects = this.coverageMap[type]; const objectKeys = Object.keys(objects); - + if (objectKeys.length > this.options.maxObjectsPerType) { // Keep only the most recent objects const toKeep = objectKeys.slice(-Math.floor(this.options.maxObjectsPerType * 0.8)); const newObjects = {}; - - toKeep.forEach(key => { + + toKeep.forEach((key) => { newObjects[key] = objects[key]; }); - + this.coverageMap[type] = newObjects; - + this.emit('warning', { type: 'object_limit', message: `Limited ${type} objects to ${toKeep.length} items` @@ -2988,7 +3236,6 @@ class pgTAPTestScanner extends EventEmitter { }); } - /** * Cleanup resources * @private @@ -2998,7 +3245,7 @@ class pgTAPTestScanner extends EventEmitter { clearInterval(this.memoryMonitoringInterval); this.memoryMonitoringInterval = null; } - + if (this.abortController) { this.abortController.abort(); } @@ -3026,4 +3273,4 @@ class pgTAPTestScanner extends EventEmitter { } } -export default pgTAPTestScanner; \ No newline at end of file +export default pgTAPTestScanner; diff --git a/starfleet/data-templates/index.js b/starfleet/data-templates/index.js new file mode 100644 index 0000000..0f3b6f5 --- /dev/null +++ b/starfleet/data-templates/index.js @@ -0,0 +1,108 @@ +/** + * @fileoverview Main entry point for DATA Edge Function templates + * Provides template generation for Supabase Edge Functions with Deno runtime + */ + +import { TemplateEngine } from './lib/TemplateEngine.js'; +import { EdgeFunctionGenerator } from './lib/EdgeFunctionGenerator.js'; + +/** + * Create a new template engine instance + * @returns {TemplateEngine} - Template engine instance + */ +export function createTemplateEngine() { + return new TemplateEngine(); +} + +/** + * Create a new Edge Function generator instance + * @returns {EdgeFunctionGenerator} - Generator instance + */ +export function createEdgeFunctionGenerator() { + return new EdgeFunctionGenerator(); +} + +/** + * Quick generation function for common use cases + * @param {string} name - Function name + * @param {string} type - Template type (edge-function, database-function, webhook-handler) + * @param {Object} [options] - Additional options + * @returns {Promise} - Generation result + */ +export function generateEdgeFunction(name, type, options = {}) { + const generator = new EdgeFunctionGenerator(); + return generator.generate({ name, type, ...options }); +} + +/** + * Get available template types + * @returns {Array} - Available template types + */ +export function getAvailableTemplateTypes() { + return ['edge-function', 'database-function', 'webhook-handler']; +} + +/** + * Get template configuration schema + * @returns {Object} - Configuration schema with defaults + */ +export function getTemplateConfigSchema() { + return { + runtime: { type: 'string', default: 'deno', options: ['deno'] }, + typescript: { type: 'boolean', default: true }, + cors: { type: 'boolean', default: true }, + corsOrigins: { type: 'array', default: ['*'] }, + jwtVerification: { type: 'boolean', default: false }, + rateLimit: { type: 'boolean', default: false }, + supabaseIntegration: { type: 'boolean', default: true }, + errorHandling: { type: 'boolean', default: true }, + logging: { type: 'boolean', default: true }, + validation: { type: 'boolean', default: true }, + timeout: { type: 'number', default: 30 }, + description: { type: 'string', default: '' }, + author: { type: 'string', default: 'DATA CLI' } + }; +} + +/** + * Validate template configuration + * @param {Object} config - Configuration to validate + * @returns {Array} - Validation errors (empty if valid) + */ +export function validateTemplateConfig(config) { + const errors = []; + const schema = getTemplateConfigSchema(); + + Object.entries(config).forEach(([key, value]) => { + const fieldSchema = schema[key]; + if (!fieldSchema) { + errors.push(`Unknown configuration option: ${key}`); + return; + } + + if (fieldSchema.type === 'boolean' && typeof value !== 'boolean') { + errors.push(`${key} must be a boolean, got ${typeof value}`); + } + + if (fieldSchema.type === 'string' && typeof value !== 'string') { + errors.push(`${key} must be a string, got ${typeof value}`); + } + + if (fieldSchema.type === 'number' && typeof value !== 'number') { + errors.push(`${key} must be a number, got ${typeof value}`); + } + + if (fieldSchema.type === 'array' && !Array.isArray(value)) { + errors.push(`${key} must be an array, got ${typeof value}`); + } + + if (fieldSchema.options && !fieldSchema.options.includes(value)) { + errors.push(`${key} must be one of: ${fieldSchema.options.join(', ')}`); + } + }); + + return errors; +} + +// Re-export classes for direct use +export { TemplateEngine, EdgeFunctionGenerator }; diff --git a/starfleet/data-templates/lib/EdgeFunctionGenerator.js b/starfleet/data-templates/lib/EdgeFunctionGenerator.js new file mode 100644 index 0000000..47546cf --- /dev/null +++ b/starfleet/data-templates/lib/EdgeFunctionGenerator.js @@ -0,0 +1,508 @@ +/** + * @fileoverview Edge Function generator for Supabase with Deno runtime + * Creates complete Edge Function projects with proper Web API patterns + */ + +import { TemplateEngine } from './TemplateEngine.js'; + +/** + * Edge Function project generator + * Creates complete Supabase Edge Functions using Web API standards + */ +export class EdgeFunctionGenerator { + constructor() { + this.templateEngine = new TemplateEngine(); + this.defaultConfig = { + runtime: 'deno', + typescript: true, + cors: true, + jwtVerification: false, + rateLimit: false, + supabaseIntegration: true, + errorHandling: true + }; + } + + /** + * Generate an Edge Function project + * @param {Object} options - Generation options + * @param {string} options.name - Function name + * @param {string} options.type - Template type (edge-function, database-function, webhook-handler) + * @param {Object} [options.config] - Configuration overrides + * @param {string} [options.outputDir] - Output directory path + * @returns {Promise} - Generation result with file paths + */ + generate(options) { + const { name, type, config = {}, outputDir = '.' } = options; + + if (!name || !type) { + throw new Error('Function name and type are required'); + } + + const finalConfig = { ...this.defaultConfig, ...config }; + const templateVars = this._createTemplateVariables(name, finalConfig); + + this.templateEngine + .setVariables(templateVars) + .setConditionals(this._createConditionals(finalConfig)); + + const templates = this._getTemplatesForType(type); + const generatedFiles = []; + + for (const template of templates) { + const content = this._getTemplateContent(template.name, type); + const processedContent = this.templateEngine.process(content); + + const outputPath = this._resolveOutputPath(outputDir, name, template.filename); + generatedFiles.push({ + path: outputPath, + content: processedContent, + type: template.type + }); + } + + return { + functionName: name, + type, + config: finalConfig, + files: generatedFiles, + totalFiles: generatedFiles.length + }; + } + + /** + * Create template variables for substitution + * @private + */ + _createTemplateVariables(name, config) { + return { + functionName: name, + functionNameCamel: this._toCamelCase(name), + functionNamePascal: this._toPascalCase(name), + functionNameKebab: this._toKebabCase(name), + timestamp: new Date().toISOString(), + denoVersion: '>=1.40.0', + corsOrigins: config.corsOrigins || ['*'], + defaultTimeout: config.timeout || 30, + description: config.description || `Supabase Edge Function: ${name}`, + author: config.author || 'DATA CLI' + }; + } + + /** + * Create conditional flags for template processing + * @private + */ + _createConditionals(config) { + return { + typescript: config.typescript, + cors: config.cors, + jwtVerification: config.jwtVerification, + rateLimit: config.rateLimit, + supabaseIntegration: config.supabaseIntegration, + errorHandling: config.errorHandling, + logging: config.logging !== false, + validation: config.validation !== false + }; + } + + /** + * Get template definitions for function type + * @private + */ + _getTemplatesForType(type) { + const templates = { + 'edge-function': [ + { name: 'index', filename: 'index.ts', type: 'main' }, + { name: 'readme', filename: 'README.md', type: 'docs' }, + { name: 'config', filename: 'deno.json', type: 'config' } + ], + 'database-function': [{ name: 'database', filename: 'index.ts', type: 'main' }], + 'webhook-handler': [{ name: 'webhook', filename: 'index.ts', type: 'main' }] + }; + + const templateList = templates[type]; + if (!templateList) { + throw new Error(`Unknown template type: ${type}`); + } + + return templateList; + } + + /** + * Get template content by name and type + * This would normally load from template files + * @private + */ + _getTemplateContent(templateName, functionType) { + // In a real implementation, this would load from template files + // For now, return inline templates + const templates = this._getInlineTemplates(); + return templates[functionType]?.[templateName] || ''; + } + + /** + * Get inline template definitions + * @private + */ + _getInlineTemplates() { + return { + 'edge-function': { + index: `// {{description}} +// Generated by DATA CLI on {{timestamp}} + +{{#if supabaseIntegration}} +import { createClient } from 'https://esm.sh/@supabase/supabase-js@2' +{{/if}} + +{{#if jwtVerification}} +import { verify } from 'https://deno.land/x/djwt@v3.0.0/mod.ts' +{{/if}} + +{{#if cors}} +const corsHeaders = { + 'Access-Control-Allow-Origin': '{{corsOrigins.0}}', + 'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type', +} +{{/if}} + +{{#if supabaseIntegration}} +// Initialize Supabase client +const supabaseUrl = Deno.env.get('SUPABASE_URL')! +const supabaseKey = Deno.env.get('SUPABASE_ANON_KEY')! +const supabase = createClient(supabaseUrl, supabaseKey) +{{/if}} + +Deno.serve(async (req: Request): Promise => { + {{#if cors}} + // Handle CORS preflight requests + if (req.method === 'OPTIONS') { + return new Response('ok', { headers: corsHeaders }) + } + {{/if}} + + try { + {{#if jwtVerification}} + // Verify JWT token + const authHeader = req.headers.get('Authorization') + if (!authHeader?.startsWith('Bearer ')) { + return new Response( + JSON.stringify({ error: 'Missing or invalid authorization header' }), + { + status: 401, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } + {{/if}} + + {{#if rateLimit}} + // Basic rate limiting (implement with external store in production) + const clientIP = req.headers.get('x-forwarded-for') || 'unknown' + console.log(\`Request from: \${clientIP}\`) + {{/if}} + + // Main function logic + const { method, url } = req + console.log(\`{{functionName}}: \${method} \${url}\`) + + if (method === 'POST') { + const body = await req.json() + {{#if validation}} + + // Validate request body + if (!body) { + return new Response( + JSON.stringify({ error: 'Request body is required' }), + { + status: 400, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } + {{/if}} + + {{#if supabaseIntegration}} + // Example: Query Supabase + const { data, error } = await supabase + .from('your_table') + .select('*') + .limit(10) + + if (error) { + console.error('Database error:', error) + return new Response( + JSON.stringify({ error: 'Database query failed' }), + { + status: 500, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } + {{/if}} + + // Process the request + const result = { + message: 'Hello from {{functionName}}!', + timestamp: new Date().toISOString(), + {{#if supabaseIntegration}} + data: data || [], + {{/if}} + body + } + + return new Response( + JSON.stringify(result), + { + status: 200, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } + + return new Response( + JSON.stringify({ error: 'Method not allowed' }), + { + status: 405, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + + } catch (error) { + {{#if errorHandling}} + console.error('{{functionName}} error:', error) + + return new Response( + JSON.stringify({ + error: 'Internal server error', + message: error.message + }), + { + status: 500, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + {{/if}} + } +})`, + + readme: `# {{functionName}} + +{{description}} + +## Overview + +This Edge Function runs on Deno and uses Web APIs exclusively. It provides: + +{{#if cors}} +- CORS support for browser requests +{{/if}} +{{#if jwtVerification}} +- JWT token verification +{{/if}} +{{#if rateLimit}} +- Basic rate limiting +{{/if}} +{{#if supabaseIntegration}} +- Supabase database integration +{{/if}} +{{#if errorHandling}} +- Comprehensive error handling +{{/if}} + +## Local Development + +\`\`\`bash +# Serve locally using Supabase CLI +supabase functions serve {{functionNameKebab}} + +# Deploy to remote +supabase functions deploy {{functionNameKebab}} +\`\`\` + +## Environment Variables + +\`\`\`bash +{{#if supabaseIntegration}} +SUPABASE_URL=your-project-url +SUPABASE_ANON_KEY=your-anon-key +{{/if}} +\`\`\` + +## API Usage + +\`\`\`bash +# POST request example +curl -X POST 'http://localhost:54321/functions/v1/{{functionNameKebab}}' \\ + -H 'Authorization: Bearer YOUR_TOKEN' \\ + -H 'Content-Type: application/json' \\ + -d '{"message": "Hello World"}' +\`\`\` + +Generated by DATA CLI on {{timestamp}}`, + + config: `{ + "compilerOptions": { + "allowJs": true, + "lib": ["deno.window"], + "strict": true + }, + "imports": { + "supabase": "https://esm.sh/@supabase/supabase-js@2"{{#if jwtVerification}}, + "djwt": "https://deno.land/x/djwt@v3.0.0/mod.ts"{{/if}} + } +}` + }, + + 'database-function': { + database: `// Database-focused Edge Function +// Generated by DATA CLI on {{timestamp}} + +import { createClient } from 'https://esm.sh/@supabase/supabase-js@2' + +const supabase = createClient( + Deno.env.get('SUPABASE_URL')!, + Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')! +) + +Deno.serve(async (req: Request): Promise => { + if (req.method === 'OPTIONS') { + return new Response('ok', { headers: { 'Access-Control-Allow-Origin': '*' } }) + } + + try { + const { action, table, data } = await req.json() + + switch (action) { + case 'select': + const { data: selectData, error: selectError } = await supabase + .from(table) + .select('*') + + if (selectError) throw selectError + return new Response(JSON.stringify(selectData)) + + case 'insert': + const { data: insertData, error: insertError } = await supabase + .from(table) + .insert(data) + .select() + + if (insertError) throw insertError + return new Response(JSON.stringify(insertData)) + + default: + return new Response( + JSON.stringify({ error: 'Unsupported action' }), + { status: 400 } + ) + } + } catch (error) { + return new Response( + JSON.stringify({ error: error.message }), + { status: 500 } + ) + } +})` + }, + + 'webhook-handler': { + webhook: `// Webhook Handler Edge Function +// Generated by DATA CLI on {{timestamp}} + +{{#if supabaseIntegration}} +import { createClient } from 'https://esm.sh/@supabase/supabase-js@2' + +const supabase = createClient( + Deno.env.get('SUPABASE_URL')!, + Deno.env.get('SUPABASE_ANON_KEY')! +) +{{/if}} + +Deno.serve(async (req: Request): Promise => { + if (req.method !== 'POST') { + return new Response('Method not allowed', { status: 405 }) + } + + try { + // Verify webhook signature if needed + const signature = req.headers.get('X-Signature') + const payload = await req.text() + + {{#if validation}} + if (!signature) { + return new Response('Missing signature', { status: 401 }) + } + {{/if}} + + // Parse the webhook payload + const webhookData = JSON.parse(payload) + console.log('Webhook received:', webhookData) + + {{#if supabaseIntegration}} + // Store webhook event + const { error } = await supabase + .from('webhook_events') + .insert({ + source: '{{functionName}}', + payload: webhookData, + received_at: new Date().toISOString() + }) + + if (error) { + console.error('Failed to store webhook:', error) + } + {{/if}} + + // Process webhook data here + // Add your business logic + + return new Response( + JSON.stringify({ + success: true, + processed_at: new Date().toISOString() + }), + { + status: 200, + headers: { 'Content-Type': 'application/json' } + } + ) + + } catch (error) { + console.error('Webhook processing error:', error) + + return new Response( + JSON.stringify({ error: 'Processing failed' }), + { + status: 500, + headers: { 'Content-Type': 'application/json' } + } + ) + } +})` + } + }; + } + + /** + * Resolve output file path + * @private + */ + _resolveOutputPath(outputDir, functionName, filename) { + const kebabName = this._toKebabCase(functionName); + return `${outputDir}/${kebabName}/${filename}`; + } + + // String transformation utilities + _toCamelCase(str) { + return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase()); + } + + _toPascalCase(str) { + return str.charAt(0).toUpperCase() + this._toCamelCase(str).slice(1); + } + + _toKebabCase(str) { + return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`); + } +} diff --git a/starfleet/data-templates/lib/TemplateEngine.js b/starfleet/data-templates/lib/TemplateEngine.js new file mode 100644 index 0000000..2d9d926 --- /dev/null +++ b/starfleet/data-templates/lib/TemplateEngine.js @@ -0,0 +1,152 @@ +/** + * @fileoverview Template processing engine for Deno Edge Functions + * Provides variable substitution and template rendering using only Web APIs + */ + +/** + * Template variable substitution engine + * Processes templates with {{variable}} placeholders and conditionals + */ +export class TemplateEngine { + constructor() { + this.variables = new Map(); + this.conditionals = new Map(); + } + + /** + * Set template variables for substitution + * @param {Record} vars - Variables to set + * @returns {TemplateEngine} - Fluent interface + */ + setVariables(vars) { + Object.entries(vars).forEach(([key, value]) => { + this.variables.set(key, value); + }); + return this; + } + + /** + * Set conditional blocks for template processing + * @param {Record} conditions - Conditional flags + * @returns {TemplateEngine} - Fluent interface + */ + setConditionals(conditions) { + Object.entries(conditions).forEach(([key, value]) => { + this.conditionals.set(key, Boolean(value)); + }); + return this; + } + + /** + * Process template string with variable substitution and conditionals + * @param {string} template - Template content to process + * @returns {string} - Processed template + */ + process(template) { + let result = template; + + // Process conditional blocks first + result = this._processConditionals(result); + + // Then process variable substitutions + result = this._processVariables(result); + + // Clean up any remaining template syntax + result = this._cleanupTemplate(result); + + return result; + } + + /** + * Process conditional blocks in template + * Format: {{#if condition}}content{{/if}} + * @private + */ + _processConditionals(template) { + const conditionalRegex = /\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g; + + return template.replace(conditionalRegex, (match, condition, content) => { + const shouldInclude = this.conditionals.get(condition) || false; + return shouldInclude ? content : ''; + }); + } + + /** + * Process variable substitutions in template + * Format: {{variableName}} + * @private + */ + _processVariables(template) { + const variableRegex = /\{\{(\w+)\}\}/g; + + return template.replace(variableRegex, (match, varName) => { + const value = this.variables.get(varName); + + if (value === undefined || value === null) { + return match; // Leave unresolved variables as-is + } + + if (typeof value === 'string') { + return value; + } + + if (typeof value === 'object') { + return JSON.stringify(value, null, 2); + } + + return String(value); + }); + } + + /** + * Clean up any remaining template artifacts + * @private + */ + _cleanupTemplate(template) { + // Remove empty lines that might be left from conditionals + return template.replace(/^\s*\n/gm, ''); + } + + /** + * Load and process a template file + * Note: In Deno runtime, this would use Deno.readTextFile + * @param {string} templatePath - Path to template file + * @returns {Promise} - Processed template content + */ + loadAndProcess(templatePath) { + try { + // This is a placeholder - actual implementation would depend on runtime + // In Deno: const content = await Deno.readTextFile(templatePath); + // In Node: const content = await fs.readFile(templatePath, 'utf8'); + throw new Error('loadAndProcess must be implemented by runtime-specific subclass'); + } catch (error) { + throw new Error(`Failed to load template from ${templatePath}: ${error.message}`); + } + } + + /** + * Validate template syntax before processing + * @param {string} template - Template to validate + * @returns {Array} - Array of validation errors (empty if valid) + */ + validate(template) { + const errors = []; + + // Check for unmatched conditional blocks + const ifCount = (template.match(/\{\{#if\s+\w+\}\}/g) || []).length; + const endifCount = (template.match(/\{\{\/if\}\}/g) || []).length; + + if (ifCount !== endifCount) { + errors.push(`Unmatched conditional blocks: ${ifCount} {{#if}} but ${endifCount} {{/if}}`); + } + + // Check for nested conditionals (not supported) + const nestedRegex = + /\{\{#if\s+\w+\}\}[\s\S]*?\{\{#if\s+\w+\}\}[\s\S]*?\{\{\/if\}\}[\s\S]*?\{\{\/if\}\}/; + if (nestedRegex.test(template)) { + errors.push('Nested conditional blocks are not supported'); + } + + return errors; + } +} diff --git a/starfleet/data-templates/package.json b/starfleet/data-templates/package.json new file mode 100644 index 0000000..662dfa5 --- /dev/null +++ b/starfleet/data-templates/package.json @@ -0,0 +1,43 @@ +{ + "name": "@starfleet/templates", + "version": "1.0.0", + "description": "Template generation system for Supabase Edge Functions with Deno runtime", + "type": "module", + "main": "index.js", + "exports": { + ".": "./index.js", + "./lib/TemplateEngine": "./lib/TemplateEngine.js", + "./lib/EdgeFunctionGenerator": "./lib/EdgeFunctionGenerator.js" + }, + "scripts": { + "lint": "eslint \"*.js\" \"lib/**/*.{js,mjs,cjs}\"", + "test": "vitest --run --passWithNoTests", + "build": "echo \"No build needed for pure JS\"" + }, + "keywords": [ + "supabase", + "edge-functions", + "deno", + "templates", + "web-api" + ], + "author": "Flyingrobots Development Team", + "license": "MIT", + "dependencies": {}, + "peerDependencies": { + "@supabase/supabase-js": "^2.45.0" + }, + "engines": { + "node": ">=18", + "deno": ">=1.40.0" + }, + "files": [ + "src", + "lib", + "index.js" + ], + "sideEffects": false, + "publishConfig": { + "access": "public" + } +} \ No newline at end of file diff --git a/starfleet/data-templates/templates/database-function/index.ts.template b/starfleet/data-templates/templates/database-function/index.ts.template new file mode 100644 index 0000000..7652a56 --- /dev/null +++ b/starfleet/data-templates/templates/database-function/index.ts.template @@ -0,0 +1,363 @@ +// Database-focused Edge Function: {{functionName}} +// Generated by DATA CLI on {{timestamp}} +// Runtime: Deno {{denoVersion}} - Web API Only + +import { createClient } from 'https://esm.sh/@supabase/supabase-js@2' + +// Database client with elevated privileges for admin operations +const supabaseUrl = Deno.env.get('SUPABASE_URL')! +const supabaseServiceKey = Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')! + +if (!supabaseUrl || !supabaseServiceKey) { + throw new Error('Missing required environment variables: SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY') +} + +// Use service role key for database operations requiring elevated privileges +const supabase = createClient(supabaseUrl, supabaseServiceKey) + +// CORS headers for browser compatibility +const corsHeaders = { + 'Access-Control-Allow-Origin': '*', + 'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type', + 'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS', +} + +/** + * Database operation types supported by this function + */ +type DatabaseOperation = 'select' | 'insert' | 'update' | 'delete' | 'upsert' | 'count' | 'execute' + +interface DatabaseRequest { + operation: DatabaseOperation + table: string + data?: any + filters?: Record + columns?: string + options?: { + limit?: number + offset?: number + orderBy?: string + orderDirection?: 'asc' | 'desc' + } + sql?: string // For raw SQL execution +} + +/** + * Main database function handler + */ +Deno.serve(async (req: Request): Promise => { + const startTime = performance.now() + + console.log(`[${new Date().toISOString()}] {{functionName}}: ${req.method} ${req.url}`) + + // Handle CORS preflight + if (req.method === 'OPTIONS') { + return new Response('ok', { headers: corsHeaders }) + } + + try { + // Only allow POST requests for database operations + if (req.method !== 'POST') { + return new Response( + JSON.stringify({ error: 'Only POST method is allowed for database operations' }), + { + status: 405, + headers: { + 'Content-Type': 'application/json', + 'Allow': 'POST, OPTIONS', + ...corsHeaders + } + } + ) + } + + // Parse and validate request + let dbRequest: DatabaseRequest + try { + dbRequest = await req.json() + } catch (error) { + return new Response( + JSON.stringify({ error: 'Invalid JSON in request body' }), + { + status: 400, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } + + // Validate required fields + if (!dbRequest.operation) { + return new Response( + JSON.stringify({ error: 'Missing required field: operation' }), + { + status: 400, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } + + // Route to appropriate handler + let result: any + switch (dbRequest.operation) { + case 'select': + result = await handleSelect(dbRequest) + break + + case 'insert': + result = await handleInsert(dbRequest) + break + + case 'update': + result = await handleUpdate(dbRequest) + break + + case 'delete': + result = await handleDelete(dbRequest) + break + + case 'upsert': + result = await handleUpsert(dbRequest) + break + + case 'count': + result = await handleCount(dbRequest) + break + + case 'execute': + result = await handleExecute(dbRequest) + break + + default: + return new Response( + JSON.stringify({ + error: `Unsupported operation: ${dbRequest.operation}`, + supportedOperations: ['select', 'insert', 'update', 'delete', 'upsert', 'count', 'execute'] + }), + { + status: 400, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } + + const duration = performance.now() - startTime + console.log(`Operation ${dbRequest.operation} completed in ${duration.toFixed(2)}ms`) + + return new Response( + JSON.stringify({ + success: true, + operation: dbRequest.operation, + data: result.data, + count: result.count, + duration: Math.round(duration), + timestamp: new Date().toISOString() + }), + { + status: 200, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + + } catch (error) { + const duration = performance.now() - startTime + + console.error('Database operation error:', { + message: error.message, + stack: error.stack, + duration: Math.round(duration) + }) + + return new Response( + JSON.stringify({ + error: 'Database operation failed', + message: error.message, + requestId: crypto.randomUUID(), + timestamp: new Date().toISOString() + }), + { + status: 500, + headers: { 'Content-Type': 'application/json', ...corsHeaders } + } + ) + } +}) + +/** + * Handle SELECT operations + */ +async function handleSelect(request: DatabaseRequest) { + if (!request.table) { + throw new Error('Table name is required for select operations') + } + + let query = supabase + .from(request.table) + .select(request.columns || '*', { count: 'exact' }) + + // Apply filters + if (request.filters) { + Object.entries(request.filters).forEach(([column, value]) => { + if (Array.isArray(value)) { + query = query.in(column, value) + } else if (typeof value === 'object' && value !== null) { + // Support for operators like { gte: 10 }, { like: '%pattern%' } + Object.entries(value).forEach(([operator, operatorValue]) => { + query = (query as any)[operator](column, operatorValue) + }) + } else { + query = query.eq(column, value) + } + }) + } + + // Apply options + if (request.options) { + const { limit, offset, orderBy, orderDirection } = request.options + + if (limit) query = query.limit(limit) + if (offset) query = query.range(offset, offset + (limit || 1000) - 1) + if (orderBy) query = query.order(orderBy, { ascending: orderDirection !== 'desc' }) + } + + const { data, error, count } = await query + + if (error) throw error + + return { data, count } +} + +/** + * Handle INSERT operations + */ +async function handleInsert(request: DatabaseRequest) { + if (!request.table || !request.data) { + throw new Error('Table name and data are required for insert operations') + } + + const { data, error } = await supabase + .from(request.table) + .insert(request.data) + .select() + + if (error) throw error + + return { data, count: Array.isArray(data) ? data.length : (data ? 1 : 0) } +} + +/** + * Handle UPDATE operations + */ +async function handleUpdate(request: DatabaseRequest) { + if (!request.table || !request.data || !request.filters) { + throw new Error('Table name, data, and filters are required for update operations') + } + + let query = supabase + .from(request.table) + .update(request.data) + + // Apply filters + Object.entries(request.filters).forEach(([column, value]) => { + query = query.eq(column, value) + }) + + const { data, error, count } = await query.select() + + if (error) throw error + + return { data, count } +} + +/** + * Handle DELETE operations + */ +async function handleDelete(request: DatabaseRequest) { + if (!request.table || !request.filters) { + throw new Error('Table name and filters are required for delete operations') + } + + let query = supabase.from(request.table).delete() + + // Apply filters + Object.entries(request.filters).forEach(([column, value]) => { + query = query.eq(column, value) + }) + + const { data, error, count } = await query.select() + + if (error) throw error + + return { data, count } +} + +/** + * Handle UPSERT operations + */ +async function handleUpsert(request: DatabaseRequest) { + if (!request.table || !request.data) { + throw new Error('Table name and data are required for upsert operations') + } + + const { data, error } = await supabase + .from(request.table) + .upsert(request.data) + .select() + + if (error) throw error + + return { data, count: Array.isArray(data) ? data.length : (data ? 1 : 0) } +} + +/** + * Handle COUNT operations + */ +async function handleCount(request: DatabaseRequest) { + if (!request.table) { + throw new Error('Table name is required for count operations') + } + + let query = supabase + .from(request.table) + .select('*', { count: 'exact', head: true }) + + // Apply filters + if (request.filters) { + Object.entries(request.filters).forEach(([column, value]) => { + query = query.eq(column, value) + }) + } + + const { count, error } = await query + + if (error) throw error + + return { data: null, count } +} + +/** + * Handle raw SQL execution + * WARNING: Use with extreme caution in production + */ +async function handleExecute(request: DatabaseRequest) { + if (!request.sql) { + throw new Error('SQL query is required for execute operations') + } + + // Basic SQL injection protection (very basic - implement proper validation) + const dangerousKeywords = ['DROP', 'TRUNCATE', 'DELETE FROM', 'ALTER', 'CREATE'] + const upperSQL = request.sql.toUpperCase() + + for (const keyword of dangerousKeywords) { + if (upperSQL.includes(keyword)) { + throw new Error(`Potentially dangerous SQL keyword detected: ${keyword}`) + } + } + + const { data, error } = await supabase.rpc('execute_sql', { + query: request.sql + }) + + if (error) throw error + + return { data, count: Array.isArray(data) ? data.length : (data ? 1 : 0) } +} \ No newline at end of file diff --git a/starfleet/data-templates/templates/edge-function/README.md.template b/starfleet/data-templates/templates/edge-function/README.md.template new file mode 100644 index 0000000..e5880d4 --- /dev/null +++ b/starfleet/data-templates/templates/edge-function/README.md.template @@ -0,0 +1,319 @@ +# {{functionName}} + +{{description}} + +**Generated by DATA CLI on {{timestamp}}** + +## Overview + +This Supabase Edge Function runs on the Deno runtime and uses Web APIs exclusively. No Node.js built-ins are used, ensuring compatibility with the Edge Functions environment. + +### Features + +{{#if cors}} +- โœ… CORS support for browser requests +{{/if}} +{{#if jwtVerification}} +- โœ… JWT token verification and user authentication +{{/if}} +{{#if rateLimit}} +- โœ… In-memory rate limiting ({{RATE_LIMIT_MAX}} requests per minute) +{{/if}} +{{#if supabaseIntegration}} +- โœ… Supabase database integration via PostgREST API +{{/if}} +{{#if errorHandling}} +- โœ… Comprehensive error handling with proper HTTP status codes +{{/if}} +{{#if validation}} +- โœ… Request validation and type checking +{{/if}} +{{#if logging}} +- โœ… Structured logging with performance metrics +{{/if}} + +## Environment Variables + +Set these in your Supabase project settings: + +```bash +{{#if supabaseIntegration}} +# Supabase Configuration (Auto-provided by Supabase) +SUPABASE_URL=https://your-project.supabase.co +SUPABASE_ANON_KEY=your-anon-key + +# For database operations requiring elevated privileges +SUPABASE_SERVICE_ROLE_KEY=your-service-role-key +{{/if}} + +{{#if jwtVerification}} +# JWT Configuration +JWT_SECRET=your-jwt-secret-key +{{/if}} + +# Custom Environment Variables +FUNCTION_TIMEOUT={{defaultTimeout}} +LOG_LEVEL=info +``` + +## Local Development + +### Prerequisites + +- [Supabase CLI](https://supabase.com/docs/guides/cli/getting-started) installed +- Deno {{denoVersion}} or higher + +### Running Locally + +```bash +# Start Supabase services +supabase start + +# Serve the function locally +supabase functions serve {{functionNameKebab}} --no-verify-jwt + +# Or with JWT verification enabled +supabase functions serve {{functionNameKebab}} +``` + +The function will be available at: +``` +http://localhost:54321/functions/v1/{{functionNameKebab}} +``` + +### Testing + +```bash +{{#if cors}} +# Basic GET request +curl 'http://localhost:54321/functions/v1/{{functionNameKebab}}' +{{/if}} + +# POST request with JSON data +curl -X POST 'http://localhost:54321/functions/v1/{{functionNameKebab}}' \ + -H 'Content-Type: application/json' \ + {{#if jwtVerification}}-H 'Authorization: Bearer your-jwt-token' \{{/if}} + -d '{"message": "Hello World", "data": {"key": "value"}}' + +{{#if rateLimit}} +# Test rate limiting (send multiple requests quickly) +for i in {1..15}; do + curl -s 'http://localhost:54321/functions/v1/{{functionNameKebab}}' && echo +done +{{/if}} +``` + +## Deployment + +### Deploy to Supabase + +```bash +# Deploy the function +supabase functions deploy {{functionNameKebab}} + +# Deploy with custom environment variables +supabase functions deploy {{functionNameKebab}} --no-verify-jwt +``` + +### Deploy with Import Maps (for dependencies) + +The function uses ESM imports for dependencies. Supabase automatically handles these, but you can customize via `deno.json`: + +```json +{ + "imports": { + "supabase": "https://esm.sh/@supabase/supabase-js@2"{{#if jwtVerification}}, + "djwt": "https://deno.land/x/djwt@v3.0.0/mod.ts"{{/if}} + } +} +``` + +## API Documentation + +### Endpoints + +#### GET / + +Returns basic information and supports pagination. + +**Query Parameters:** +- `limit` (number, optional): Number of records to return (default: 10) +- `offset` (number, optional): Number of records to skip (default: 0) + +**Response:** +```json +{ + "data": [...], + "pagination": { + "limit": 10, + "offset": 0, + "total": 100 + }, + "timestamp": "2024-01-01T00:00:00.000Z" +} +``` + +#### POST / + +Create or process data. + +**Request Body:** +```json +{ + "message": "string", + "data": "object" +} +``` + +**Response:** +```json +{ + "success": true, + "data": {...}, + "timestamp": "2024-01-01T00:00:00.000Z" +} +``` + +### Error Responses + +All error responses follow this format: + +```json +{ + "error": "Error description", + "requestId": "uuid-v4", + "timestamp": "2024-01-01T00:00:00.000Z" +} +``` + +**HTTP Status Codes:** +{{#if rateLimit}} +- `429`: Rate limit exceeded +{{/if}} +{{#if jwtVerification}} +- `401`: Invalid or missing JWT token +{{/if}} +- `400`: Bad request (invalid JSON, validation errors) +- `405`: Method not allowed +- `415`: Unsupported media type +- `500`: Internal server error +- `501`: Method not implemented + +## Database Schema + +{{#if supabaseIntegration}} +If using Supabase integration, ensure your database has the required tables: + +```sql +-- Example table (customize for your needs) +CREATE TABLE your_table_name ( + id UUID DEFAULT gen_random_uuid() PRIMARY KEY, + {{#if jwtVerification}} + user_id UUID REFERENCES auth.users(id), + {{/if}} + created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), + updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), + -- Add your custom fields here + data JSONB +); + +-- RLS policies (customize for your security requirements) +ALTER TABLE your_table_name ENABLE ROW LEVEL SECURITY; + +{{#if jwtVerification}} +CREATE POLICY "Users can read own records" ON your_table_name + FOR SELECT USING (auth.uid() = user_id); + +CREATE POLICY "Users can insert own records" ON your_table_name + FOR INSERT WITH CHECK (auth.uid() = user_id); +{{/if}} +``` +{{/if}} + +## Security Considerations + +{{#if jwtVerification}} +- **JWT Verification**: All authenticated endpoints verify JWT tokens +- **User Context**: Authenticated user information is available in request handlers +{{/if}} +{{#if rateLimit}} +- **Rate Limiting**: Basic in-memory rate limiting is implemented + - For production, consider using Redis or similar external store + - Current limit: 10 requests per minute per IP +{{/if}} +{{#if cors}} +- **CORS**: Configured for origins: {{corsOrigins}} + - Customize `corsOrigins` in the template configuration +{{/if}} +{{#if supabaseIntegration}} +- **Database Security**: Uses Supabase RLS (Row Level Security) +- **API Keys**: Never expose service role keys in client-side code +{{/if}} + +## Performance Notes + +- **Cold Starts**: Functions may experience cold starts after periods of inactivity +- **Memory Limits**: Edge Functions have memory constraints +- **Timeout**: Functions timeout after {{defaultTimeout}} seconds by default +{{#if supabaseIntegration}} +- **Connection Pooling**: Supabase handles PostgreSQL connection pooling automatically +- **PostgREST**: Database queries go through PostgREST API, not direct PostgreSQL connections +{{/if}} + +## Troubleshooting + +### Common Issues + +1. **CORS Errors**: Check that your client origin is included in `corsOrigins` +2. **Environment Variables**: Ensure all required variables are set in Supabase dashboard +{{#if jwtVerification}} +3. **JWT Errors**: Verify that JWT_SECRET matches your token issuer +{{/if}} +{{#if supabaseIntegration}} +4. **Database Errors**: Check RLS policies and table permissions +{{/if}} + +### Debugging + +```bash +# View function logs +supabase functions logs {{functionNameKebab}} + +# Stream logs in real-time +supabase functions logs {{functionNameKebab}} --follow +``` + +### Performance Monitoring + +The function includes built-in performance logging: +- Request duration tracking +- Memory usage (via Deno APIs) +- Error rate monitoring + +## Development Guidelines + +### Web API Only +This function uses only Web APIs compatible with the Deno runtime: +- โœ… `fetch()`, `Request`, `Response`, `Headers` +- โœ… `URL`, `URLSearchParams` +- โœ… `JSON`, `crypto` +- โœ… `console`, `performance` +- โŒ No Node.js built-ins (`fs`, `process`, `path`, etc.) + +### Code Organization +- Keep handlers focused and single-purpose +- Use TypeScript for better development experience +- Validate inputs early and provide clear error messages +- Log important events for debugging + +## Contributing + +When modifying this function: +1. Maintain Web API compatibility +2. Update this README with any new features +3. Test locally before deploying +4. Consider security implications of changes + +--- + +Generated by DATA CLI v{{version}} | Last updated: {{timestamp}} \ No newline at end of file diff --git a/starfleet/data-templates/templates/edge-function/deno.json.template b/starfleet/data-templates/templates/edge-function/deno.json.template new file mode 100644 index 0000000..de26e6d --- /dev/null +++ b/starfleet/data-templates/templates/edge-function/deno.json.template @@ -0,0 +1,41 @@ +{ + "compilerOptions": { + "allowJs": true, + "lib": ["deno.window"], + "strict": true, + "noImplicitAny": true, + "noImplicitReturns": true, + "noUnusedLocals": false, + "noUnusedParameters": false + }, + "imports": { + {{#if supabaseIntegration}} + "supabase": "https://esm.sh/@supabase/supabase-js@2"{{#if jwtVerification}},{{/if}} + {{/if}} + {{#if jwtVerification}} + "djwt": "https://deno.land/x/djwt@v3.0.0/mod.ts" + {{/if}} + }, + "tasks": { + "dev": "deno run --allow-net --allow-env --watch index.ts", + "serve": "supabase functions serve {{functionNameKebab}}", + "deploy": "supabase functions deploy {{functionNameKebab}}", + "logs": "supabase functions logs {{functionNameKebab}}", + "test": "deno test --allow-all tests/" + }, + "fmt": { + "useTabs": false, + "lineWidth": 100, + "indentWidth": 2, + "semiColons": false, + "singleQuote": true, + "proseWrap": "preserve" + }, + "lint": { + "rules": { + "tags": ["recommended"], + "include": ["ban-untagged-todo"], + "exclude": ["no-unused-vars"] + } + } +} \ No newline at end of file diff --git a/starfleet/data-templates/templates/edge-function/index.ts.template b/starfleet/data-templates/templates/edge-function/index.ts.template new file mode 100644 index 0000000..58fc10d --- /dev/null +++ b/starfleet/data-templates/templates/edge-function/index.ts.template @@ -0,0 +1,435 @@ +// {{description}} +// Generated by DATA CLI on {{timestamp}} +// Runtime: Deno {{denoVersion}} +// Web API Only - No Node.js built-ins + +{{#if supabaseIntegration}} +import { createClient } from 'https://esm.sh/@supabase/supabase-js@2' +{{/if}} + +{{#if jwtVerification}} +import { verify } from 'https://deno.land/x/djwt@v3.0.0/mod.ts' +{{/if}} + +{{#if cors}} +// CORS configuration +const corsHeaders = { + 'Access-Control-Allow-Origin': '{{corsOrigins.0}}', + 'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type', + 'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS', +} +{{/if}} + +{{#if supabaseIntegration}} +// Supabase client initialization +// Uses PostgREST API for database access (no direct PostgreSQL connection) +const supabaseUrl = Deno.env.get('SUPABASE_URL')! +const supabaseKey = Deno.env.get('SUPABASE_ANON_KEY')! + +if (!supabaseUrl || !supabaseKey) { + throw new Error('Missing required environment variables: SUPABASE_URL, SUPABASE_ANON_KEY') +} + +const supabase = createClient(supabaseUrl, supabaseKey) +{{/if}} + +{{#if rateLimit}} +// Simple in-memory rate limiter (use external store in production) +const rateLimitStore = new Map() +const RATE_LIMIT_WINDOW = 60000 // 1 minute +const RATE_LIMIT_MAX = 10 // 10 requests per minute + +function checkRateLimit(identifier: string): boolean { + const now = Date.now() + const record = rateLimitStore.get(identifier) + + if (!record || now > record.resetTime) { + rateLimitStore.set(identifier, { count: 1, resetTime: now + RATE_LIMIT_WINDOW }) + return true + } + + if (record.count >= RATE_LIMIT_MAX) { + return false + } + + record.count++ + return true +} +{{/if}} + +{{#if jwtVerification}} +// JWT verification helper +async function verifyToken(authHeader: string | null): Promise { + if (!authHeader?.startsWith('Bearer ')) { + throw new Error('Invalid authorization header format') + } + + const token = authHeader.slice(7) + const secret = Deno.env.get('JWT_SECRET') + + if (!secret) { + throw new Error('JWT_SECRET not configured') + } + + return await verify(token, secret) +} +{{/if}} + +/** + * Main Edge Function handler + * Processes HTTP requests using Web APIs only + */ +Deno.serve(async (req: Request): Promise => { + {{#if logging}} + const startTime = performance.now() + const { method, url } = req + const userAgent = req.headers.get('User-Agent') || 'unknown' + + console.log(`[${new Date().toISOString()}] {{functionName}}: ${method} ${url} (${userAgent})`) + {{/if}} + + {{#if cors}} + // Handle CORS preflight requests + if (req.method === 'OPTIONS') { + return new Response('ok', { + status: 200, + headers: corsHeaders + }) + } + {{/if}} + + try { + {{#if rateLimit}} + // Rate limiting check + const clientIP = req.headers.get('x-forwarded-for') || + req.headers.get('x-real-ip') || + 'unknown' + + if (!checkRateLimit(clientIP)) { + {{#if logging}} + console.warn(`Rate limit exceeded for IP: ${clientIP}`) + {{/if}} + return new Response( + JSON.stringify({ + error: 'Rate limit exceeded', + retryAfter: Math.ceil(RATE_LIMIT_WINDOW / 1000) + }), + { + status: 429, + headers: { + 'Content-Type': 'application/json', + 'Retry-After': String(Math.ceil(RATE_LIMIT_WINDOW / 1000)), + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + {{/if}} + + {{#if jwtVerification}} + // JWT token verification + let user: any = null + try { + user = await verifyToken(req.headers.get('Authorization')) + {{#if logging}} + console.log(`Authenticated user: ${user.sub || user.id}`) + {{/if}} + } catch (error) { + {{#if logging}} + console.warn('JWT verification failed:', error.message) + {{/if}} + return new Response( + JSON.stringify({ error: 'Invalid or expired token' }), + { + status: 401, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + {{/if}} + + // Route handling + switch (req.method) { + case 'GET': + return await handleGet(req) + + case 'POST': + return await handlePost(req{{#if jwtVerification}}, user{{/if}}) + + case 'PUT': + return await handlePut(req{{#if jwtVerification}}, user{{/if}}) + + case 'DELETE': + return await handleDelete(req{{#if jwtVerification}}, user{{/if}}) + + default: + return new Response( + JSON.stringify({ error: 'Method not allowed' }), + { + status: 405, + headers: { + 'Content-Type': 'application/json', + 'Allow': 'GET, POST, PUT, DELETE, OPTIONS', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + + } catch (error) { + {{#if errorHandling}} + {{#if logging}} + console.error('{{functionName}} error:', { + message: error.message, + stack: error.stack, + url: req.url, + method: req.method + }) + {{/if}} + + return new Response( + JSON.stringify({ + error: 'Internal server error', + requestId: crypto.randomUUID(), + timestamp: new Date().toISOString() + }), + { + status: 500, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + {{/if}} + } finally { + {{#if logging}} + const duration = performance.now() - startTime + console.log(`Request completed in ${duration.toFixed(2)}ms`) + {{/if}} + } +}) + +/** + * Handle GET requests + */ +async function handleGet(req: Request): Promise { + const url = new URL(req.url) + const params = url.searchParams + + {{#if supabaseIntegration}} + // Example: Fetch data from Supabase + const limit = parseInt(params.get('limit') || '10', 10) + const offset = parseInt(params.get('offset') || '0', 10) + + const { data, error, count } = await supabase + .from('your_table_name') + .select('*', { count: 'exact' }) + .range(offset, offset + limit - 1) + + if (error) { + {{#if logging}} + console.error('Database query error:', error) + {{/if}} + return new Response( + JSON.stringify({ error: 'Failed to fetch data' }), + { + status: 500, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + + return new Response( + JSON.stringify({ + data: data || [], + pagination: { + limit, + offset, + total: count || 0 + }, + timestamp: new Date().toISOString() + }), + { + status: 200, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + {{/if}} + + // Basic GET response without Supabase + return new Response( + JSON.stringify({ + message: 'Hello from {{functionName}}!', + method: 'GET', + timestamp: new Date().toISOString(), + query: Object.fromEntries(params.entries()) + }), + { + status: 200, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) +} + +/** + * Handle POST requests + */ +async function handlePost(req: Request{{#if jwtVerification}}, user?: any{{/if}}): Promise { + {{#if validation}} + // Validate Content-Type + const contentType = req.headers.get('Content-Type') + if (!contentType?.includes('application/json')) { + return new Response( + JSON.stringify({ error: 'Content-Type must be application/json' }), + { + status: 415, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + {{/if}} + + let body: any + try { + body = await req.json() + } catch (error) { + return new Response( + JSON.stringify({ error: 'Invalid JSON in request body' }), + { + status: 400, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + + {{#if validation}} + // Basic validation + if (!body || typeof body !== 'object') { + return new Response( + JSON.stringify({ error: 'Request body must be a JSON object' }), + { + status: 400, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + {{/if}} + + {{#if supabaseIntegration}} + // Example: Insert data into Supabase + const { data, error } = await supabase + .from('your_table_name') + .insert([{ + ...body, + {{#if jwtVerification}} + user_id: user?.sub || user?.id, + {{/if}} + created_at: new Date().toISOString() + }]) + .select() + + if (error) { + {{#if logging}} + console.error('Database insert error:', error) + {{/if}} + return new Response( + JSON.stringify({ error: 'Failed to create record' }), + { + status: 500, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + } + + return new Response( + JSON.stringify({ + success: true, + data: data?.[0], + timestamp: new Date().toISOString() + }), + { + status: 201, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) + {{/if}} + + // Basic POST response without Supabase + return new Response( + JSON.stringify({ + message: 'Data received successfully', + receivedData: body, + {{#if jwtVerification}} + user: user ? { id: user.sub || user.id } : null, + {{/if}} + timestamp: new Date().toISOString() + }), + { + status: 201, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) +} + +/** + * Handle PUT requests + */ +async function handlePut(req: Request{{#if jwtVerification}}, user?: any{{/if}}): Promise { + return new Response( + JSON.stringify({ error: 'PUT method not implemented yet' }), + { + status: 501, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) +} + +/** + * Handle DELETE requests + */ +async function handleDelete(req: Request{{#if jwtVerification}}, user?: any{{/if}}): Promise { + return new Response( + JSON.stringify({ error: 'DELETE method not implemented yet' }), + { + status: 501, + headers: { + 'Content-Type': 'application/json', + {{#if cors}}...corsHeaders{{/if}} + } + } + ) +} \ No newline at end of file diff --git a/starfleet/data-templates/templates/webhook-handler/index.ts.template b/starfleet/data-templates/templates/webhook-handler/index.ts.template new file mode 100644 index 0000000..cdf516d --- /dev/null +++ b/starfleet/data-templates/templates/webhook-handler/index.ts.template @@ -0,0 +1,437 @@ +// Webhook Handler Edge Function: {{functionName}} +// Generated by DATA CLI on {{timestamp}} +// Runtime: Deno {{denoVersion}} - Web API Only + +{{#if supabaseIntegration}} +import { createClient } from 'https://esm.sh/@supabase/supabase-js@2' +{{/if}} + +{{#if supabaseIntegration}} +// Supabase client for webhook event storage +const supabaseUrl = Deno.env.get('SUPABASE_URL')! +const supabaseKey = Deno.env.get('SUPABASE_SERVICE_ROLE_KEY') || Deno.env.get('SUPABASE_ANON_KEY')! + +if (!supabaseUrl || !supabaseKey) { + throw new Error('Missing Supabase configuration') +} + +const supabase = createClient(supabaseUrl, supabaseKey) +{{/if}} + +// Webhook configuration +const WEBHOOK_SECRETS = { + github: Deno.env.get('GITHUB_WEBHOOK_SECRET'), + stripe: Deno.env.get('STRIPE_WEBHOOK_SECRET'), + default: Deno.env.get('WEBHOOK_SECRET') || 'default-secret-change-in-production' +} + +// Supported webhook sources +type WebhookSource = 'github' | 'stripe' | 'generic' | 'custom' + +interface WebhookEvent { + id: string + source: WebhookSource + event_type: string + payload: any + headers: Record + signature?: string + timestamp: string + processed: boolean + metadata?: any +} + +/** + * Main webhook handler + */ +Deno.serve(async (req: Request): Promise => { + const startTime = performance.now() + const requestId = crypto.randomUUID() + + console.log(`[${new Date().toISOString()}] {{functionName}} - Request ${requestId}: ${req.method} ${req.url}`) + + // Only allow POST requests for webhooks + if (req.method !== 'POST') { + return new Response( + JSON.stringify({ error: 'Only POST method is allowed for webhooks' }), + { + status: 405, + headers: { + 'Content-Type': 'application/json', + 'Allow': 'POST' + } + } + ) + } + + try { + // Extract request information + const userAgent = req.headers.get('User-Agent') || 'unknown' + const contentType = req.headers.get('Content-Type') || '' + const signature = req.headers.get('X-Hub-Signature-256') || + req.headers.get('Stripe-Signature') || + req.headers.get('X-Signature') + + // Determine webhook source based on headers and user agent + const source = determineWebhookSource(req.headers, userAgent) + + console.log(`Webhook source detected: ${source}`) + + // Get raw payload for signature verification + const rawPayload = await req.text() + + // Verify webhook signature + if (!await verifyWebhookSignature(source, rawPayload, signature)) { + console.warn(`Invalid signature for ${source} webhook`) + return new Response( + JSON.stringify({ error: 'Invalid webhook signature' }), + { + status: 401, + headers: { 'Content-Type': 'application/json' } + } + ) + } + + // Parse payload + let payload: any + try { + payload = contentType.includes('application/json') ? JSON.parse(rawPayload) : rawPayload + } catch (error) { + console.error('Failed to parse webhook payload:', error) + return new Response( + JSON.stringify({ error: 'Invalid payload format' }), + { + status: 400, + headers: { 'Content-Type': 'application/json' } + } + ) + } + + // Create webhook event record + const webhookEvent: WebhookEvent = { + id: requestId, + source, + event_type: extractEventType(source, payload, req.headers), + payload, + headers: Object.fromEntries(req.headers.entries()), + signature, + timestamp: new Date().toISOString(), + processed: false, + metadata: { + user_agent: userAgent, + content_type: contentType, + payload_size: rawPayload.length + } + } + + {{#if supabaseIntegration}} + // Store webhook event in database + const { error: storeError } = await supabase + .from('webhook_events') + .insert([webhookEvent]) + + if (storeError) { + console.error('Failed to store webhook event:', storeError) + // Continue processing even if storage fails + } + {{/if}} + + // Process the webhook based on source and event type + const processingResult = await processWebhook(webhookEvent) + + {{#if supabaseIntegration}} + // Update webhook event as processed + if (processingResult.success) { + await supabase + .from('webhook_events') + .update({ + processed: true, + metadata: { + ...webhookEvent.metadata, + processing_duration: performance.now() - startTime, + processing_result: processingResult + } + }) + .eq('id', requestId) + } + {{/if}} + + const duration = performance.now() - startTime + console.log(`Webhook ${requestId} processed in ${duration.toFixed(2)}ms`) + + return new Response( + JSON.stringify({ + success: true, + request_id: requestId, + source, + event_type: webhookEvent.event_type, + processed: processingResult.success, + duration: Math.round(duration), + timestamp: new Date().toISOString() + }), + { + status: 200, + headers: { 'Content-Type': 'application/json' } + } + ) + + } catch (error) { + const duration = performance.now() - startTime + + console.error(`Webhook processing error (${requestId}):`, { + message: error.message, + stack: error.stack, + duration: Math.round(duration) + }) + + return new Response( + JSON.stringify({ + error: 'Webhook processing failed', + request_id: requestId, + message: error.message, + timestamp: new Date().toISOString() + }), + { + status: 500, + headers: { 'Content-Type': 'application/json' } + } + ) + } +}) + +/** + * Determine webhook source based on headers and user agent + */ +function determineWebhookSource(headers: Headers, userAgent: string): WebhookSource { + // GitHub webhooks + if (headers.get('X-GitHub-Event') || userAgent.includes('GitHub-Hookshot')) { + return 'github' + } + + // Stripe webhooks + if (headers.get('Stripe-Signature') || userAgent.includes('Stripe')) { + return 'stripe' + } + + // Custom webhook with specific header + if (headers.get('X-Custom-Webhook')) { + return 'custom' + } + + return 'generic' +} + +/** + * Extract event type from payload and headers + */ +function extractEventType(source: WebhookSource, payload: any, headers: Headers): string { + switch (source) { + case 'github': + return headers.get('X-GitHub-Event') || 'unknown' + + case 'stripe': + return payload?.type || 'unknown' + + case 'custom': + return headers.get('X-Event-Type') || payload?.event_type || 'custom_event' + + default: + return payload?.event_type || payload?.type || 'generic_event' + } +} + +/** + * Verify webhook signature based on source + */ +async function verifyWebhookSignature( + source: WebhookSource, + payload: string, + signature?: string | null +): Promise { + if (!signature) { + console.warn(`No signature provided for ${source} webhook`) + return true // Allow unsigned webhooks in development + } + + const secret = WEBHOOK_SECRETS[source] || WEBHOOK_SECRETS.default + if (!secret) { + console.warn(`No webhook secret configured for ${source}`) + return true // Allow if no secret configured + } + + try { + switch (source) { + case 'github': + return await verifyGitHubSignature(payload, signature, secret) + + case 'stripe': + return await verifyStripeSignature(payload, signature, secret) + + default: + return await verifyHMACSignature(payload, signature, secret) + } + } catch (error) { + console.error(`Signature verification failed for ${source}:`, error) + return false + } +} + +/** + * Verify GitHub webhook signature + */ +async function verifyGitHubSignature(payload: string, signature: string, secret: string): Promise { + const expectedSignature = 'sha256=' + await hmacSHA256(secret, payload) + return signature === expectedSignature +} + +/** + * Verify Stripe webhook signature + */ +async function verifyStripeSignature(payload: string, signature: string, secret: string): Promise { + // Stripe signature format: t=timestamp,v1=signature + const elements = signature.split(',') + const signatureElement = elements.find(element => element.startsWith('v1=')) + + if (!signatureElement) return false + + const stripeSignature = signatureElement.split('=')[1] + const expectedSignature = await hmacSHA256(secret, payload) + + return stripeSignature === expectedSignature +} + +/** + * Verify generic HMAC signature + */ +async function verifyHMACSignature(payload: string, signature: string, secret: string): Promise { + const expectedSignature = await hmacSHA256(secret, payload) + return signature === expectedSignature || signature === `sha256=${expectedSignature}` +} + +/** + * Generate HMAC-SHA256 signature + */ +async function hmacSHA256(secret: string, payload: string): Promise { + const encoder = new TextEncoder() + const key = await crypto.subtle.importKey( + 'raw', + encoder.encode(secret), + { name: 'HMAC', hash: 'SHA-256' }, + false, + ['sign'] + ) + + const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(payload)) + return Array.from(new Uint8Array(signature)) + .map(b => b.toString(16).padStart(2, '0')) + .join('') +} + +/** + * Process webhook based on source and event type + */ +async function processWebhook(event: WebhookEvent): Promise<{ success: boolean; result?: any }> { + try { + console.log(`Processing ${event.source} webhook: ${event.event_type}`) + + switch (event.source) { + case 'github': + return await processGitHubWebhook(event) + + case 'stripe': + return await processStripeWebhook(event) + + case 'custom': + return await processCustomWebhook(event) + + default: + return await processGenericWebhook(event) + } + } catch (error) { + console.error('Webhook processing error:', error) + return { success: false, result: { error: error.message } } + } +} + +/** + * Process GitHub webhook events + */ +async function processGitHubWebhook(event: WebhookEvent): Promise<{ success: boolean; result?: any }> { + const { event_type, payload } = event + + switch (event_type) { + case 'push': + console.log(`GitHub push to ${payload.repository?.full_name}: ${payload.commits?.length} commits`) + // Add your GitHub push processing logic here + break + + case 'pull_request': + const action = payload.action + const pr = payload.pull_request + console.log(`GitHub PR ${action}: ${pr?.title} (#${pr?.number})`) + // Add your PR processing logic here + break + + case 'issues': + const issue = payload.issue + console.log(`GitHub issue ${payload.action}: ${issue?.title} (#${issue?.number})`) + // Add your issue processing logic here + break + + default: + console.log(`Unhandled GitHub event: ${event_type}`) + } + + return { success: true, result: { processed_event: event_type } } +} + +/** + * Process Stripe webhook events + */ +async function processStripeWebhook(event: WebhookEvent): Promise<{ success: boolean; result?: any }> { + const { event_type, payload } = event + + switch (event_type) { + case 'payment_intent.succeeded': + console.log(`Stripe payment succeeded: ${payload.data?.object?.id}`) + // Add your payment processing logic here + break + + case 'customer.subscription.created': + console.log(`Stripe subscription created: ${payload.data?.object?.id}`) + // Add your subscription processing logic here + break + + case 'invoice.payment_failed': + console.log(`Stripe payment failed: ${payload.data?.object?.id}`) + // Add your failed payment processing logic here + break + + default: + console.log(`Unhandled Stripe event: ${event_type}`) + } + + return { success: true, result: { processed_event: event_type } } +} + +/** + * Process custom webhook events + */ +async function processCustomWebhook(event: WebhookEvent): Promise<{ success: boolean; result?: any }> { + console.log(`Processing custom webhook event: ${event.event_type}`) + + // Add your custom webhook processing logic here + // Example: send notifications, update database, trigger workflows + + return { success: true, result: { processed_event: event.event_type } } +} + +/** + * Process generic webhook events + */ +async function processGenericWebhook(event: WebhookEvent): Promise<{ success: boolean; result?: any }> { + console.log(`Processing generic webhook event: ${event.event_type}`) + + // Add your generic webhook processing logic here + + return { success: true, result: { processed_event: event.event_type } } +} \ No newline at end of file diff --git a/test/CliReporter.test.js b/test/CliReporter.test.js index 8d083f2..cc197a0 100644 --- a/test/CliReporter.test.js +++ b/test/CliReporter.test.js @@ -7,26 +7,32 @@ import { createRequire } from 'module'; import { EventEmitter } from 'events'; const require = createRequire(import.meta.url); -const CliReporter = require('../src/reporters/CliReporter'); -const { CommandEvent, ProgressEvent, ErrorEvent, SuccessEvent, WarningEvent } = require('../src/lib/events/CommandEvents'); +import CliReporter from '../packages/data-cli/src/reporters/CliReporter.js'; +import { + CommandEvent, + ProgressEvent, + ErrorEvent, + SuccessEvent, + WarningEvent +} from '../src/lib/events/CommandEvents.js'; describe('CliReporter', () => { let reporter; let mockCommand; let consoleLogSpy; let consoleErrorSpy; - + beforeEach(() => { reporter = new CliReporter(false); // Not silent mockCommand = new EventEmitter(); - + // Spy on console methods consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); - + reporter.attach(mockCommand); }); - + afterEach(() => { consoleLogSpy.mockRestore(); consoleErrorSpy.mockRestore(); @@ -35,18 +41,16 @@ describe('CliReporter', () => { describe('Legacy Event Handling', () => { it('should handle legacy progress events', () => { mockCommand.emit('progress', { message: 'Legacy progress' }); - - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('๐Ÿ”„ Legacy progress') - ); + + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('๐Ÿ”„ Legacy progress')); }); it('should handle legacy warning events', () => { - mockCommand.emit('warning', { + mockCommand.emit('warning', { message: 'Legacy warning', data: { actions: ['Action 1', 'Action 2'] } }); - + expect(consoleLogSpy).toHaveBeenCalledWith( expect.stringContaining('โš ๏ธ WARNING: Legacy warning') ); @@ -54,33 +58,25 @@ describe('CliReporter', () => { it('should handle legacy error events', () => { const testError = new Error('Test error'); - mockCommand.emit('error', { + mockCommand.emit('error', { message: 'Legacy error', error: testError }); - - expect(consoleErrorSpy).toHaveBeenCalledWith( - expect.stringContaining('โœ— Legacy error') - ); - expect(consoleErrorSpy).toHaveBeenCalledWith( - expect.stringContaining('Test error') - ); + + expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('โœ— Legacy error')); + expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Test error')); }); it('should handle legacy success events', () => { mockCommand.emit('success', { message: 'Legacy success' }); - - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('โœ“ Legacy success') - ); + + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('โœ“ Legacy success')); }); it('should handle legacy start events with isProd', () => { mockCommand.emit('start', { isProd: true }); - - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('๐Ÿšจ PRODUCTION MODE ๐Ÿšจ') - ); + + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('๐Ÿšจ PRODUCTION MODE ๐Ÿšจ')); }); }); @@ -88,10 +84,8 @@ describe('CliReporter', () => { it('should handle typed progress events', () => { const progressEvent = new ProgressEvent('Typed progress'); mockCommand.emit('progress', progressEvent); - - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('๐Ÿ”„ Typed progress') - ); + + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('๐Ÿ”„ Typed progress')); }); it('should handle typed warning events', () => { @@ -99,7 +93,7 @@ describe('CliReporter', () => { actions: ['Action 1', 'Action 2'] }); mockCommand.emit('warning', warningEvent); - + expect(consoleLogSpy).toHaveBeenCalledWith( expect.stringContaining('โš ๏ธ WARNING: Typed warning') ); @@ -109,22 +103,18 @@ describe('CliReporter', () => { const testError = new Error('Typed error'); const errorEvent = new ErrorEvent('Typed error message', testError); mockCommand.emit('error', errorEvent); - + expect(consoleErrorSpy).toHaveBeenCalledWith( expect.stringContaining('โœ— Typed error message') ); - expect(consoleErrorSpy).toHaveBeenCalledWith( - expect.stringContaining('Typed error') - ); + expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Typed error')); }); it('should handle typed success events', () => { const successEvent = new SuccessEvent('Typed success'); mockCommand.emit('success', successEvent); - - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('โœ“ Typed success') - ); + + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('โœ“ Typed success')); }); it('should handle typed start events with isProd', () => { @@ -132,31 +122,29 @@ describe('CliReporter', () => { const startEvent = new CommandEvent(); startEvent.isProd = true; mockCommand.emit('start', startEvent); - - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('๐Ÿšจ PRODUCTION MODE ๐Ÿšจ') - ); + + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('๐Ÿšจ PRODUCTION MODE ๐Ÿšจ')); }); }); describe('Undefined Value Handling', () => { it('should handle undefined message gracefully', () => { mockCommand.emit('progress', { message: undefined }); - + // Should not log anything for undefined message expect(consoleLogSpy).not.toHaveBeenCalled(); }); it('should handle null event data gracefully', () => { mockCommand.emit('progress', null); - + // Should not log anything for null data expect(consoleLogSpy).not.toHaveBeenCalled(); }); it('should handle missing error object gracefully', () => { mockCommand.emit('error', { message: 'Error without error object' }); - + expect(consoleErrorSpy).toHaveBeenCalledWith( expect.stringContaining('โœ— Error without error object') ); @@ -170,11 +158,11 @@ describe('CliReporter', () => { const silentReporter = new CliReporter(true); const silentCommand = new EventEmitter(); silentReporter.attach(silentCommand); - + silentCommand.emit('progress', { message: 'Silent progress' }); silentCommand.emit('success', { message: 'Silent success' }); silentCommand.emit('error', { message: 'Silent error' }); - + expect(consoleLogSpy).not.toHaveBeenCalled(); expect(consoleErrorSpy).not.toHaveBeenCalled(); }); @@ -184,18 +172,14 @@ describe('CliReporter', () => { it('should handle both legacy and typed events in the same session', () => { // Legacy event mockCommand.emit('progress', { message: 'Legacy progress' }); - + // Typed event const typedEvent = new ProgressEvent('Typed progress'); mockCommand.emit('progress', typedEvent); - - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('๐Ÿ”„ Legacy progress') - ); - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('๐Ÿ”„ Typed progress') - ); + + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('๐Ÿ”„ Legacy progress')); + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('๐Ÿ”„ Typed progress')); expect(consoleLogSpy).toHaveBeenCalledTimes(2); }); }); -}); \ No newline at end of file +}); diff --git a/test/Command.integration.test.js b/test/Command.integration.test.js index 6ce07a2..bae057b 100644 --- a/test/Command.integration.test.js +++ b/test/Command.integration.test.js @@ -1,5 +1,5 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; -import Command from '../src/lib/Command.js'; +import Command from '../packages/data-cli/src/lib/Command.js'; import { ProgressEvent, WarningEvent, @@ -24,12 +24,12 @@ describe('Command Integration Tests', () => { it('should emit typed progress events with correct structure', async () => { const progressSpy = vi.fn(); command.on('progress', progressSpy); - + command.progress('Test progress', { step: 1 }); - + expect(progressSpy).toHaveBeenCalledTimes(1); const emittedEvent = progressSpy.mock.calls[0][0]; - + expect(emittedEvent).toHaveProperty('type', 'progress'); expect(emittedEvent).toHaveProperty('message', 'Test progress'); expect(emittedEvent).toHaveProperty('data', { step: 1 }); @@ -41,12 +41,12 @@ describe('Command Integration Tests', () => { it('should emit typed warning events with correct structure', async () => { const warnSpy = vi.fn(); command.on('warning', warnSpy); - + command.warn('Test warning', { severity: 'low' }); - + expect(warnSpy).toHaveBeenCalledTimes(1); const emittedEvent = warnSpy.mock.calls[0][0]; - + expect(emittedEvent).toHaveProperty('type', 'warning'); expect(emittedEvent).toHaveProperty('message', 'Test warning'); expect(emittedEvent.data).toMatchObject({ severity: 'low' }); // May have additional properties like code: null @@ -57,13 +57,13 @@ describe('Command Integration Tests', () => { it('should emit typed error events with correct structure', async () => { const errorSpy = vi.fn(); command.on('error', errorSpy); - + const testError = new Error('Test error'); command.error('Test error message', testError, { code: 'E001' }); - + expect(errorSpy).toHaveBeenCalledTimes(1); const emittedEvent = errorSpy.mock.calls[0][0]; - + expect(emittedEvent).toHaveProperty('type', 'error'); expect(emittedEvent).toHaveProperty('message', 'Test error message'); expect(emittedEvent).toHaveProperty('error', testError); @@ -76,12 +76,12 @@ describe('Command Integration Tests', () => { it('should emit typed success events with correct structure', async () => { const successSpy = vi.fn(); command.on('success', successSpy); - + command.success('Test success', { result: 'OK' }); - + expect(successSpy).toHaveBeenCalledTimes(1); const emittedEvent = successSpy.mock.calls[0][0]; - + expect(emittedEvent).toHaveProperty('type', 'success'); expect(emittedEvent).toHaveProperty('message', 'Test success'); expect(emittedEvent.data).toMatchObject({ result: 'OK' }); // May have additional properties like duration: null @@ -94,25 +94,25 @@ describe('Command Integration Tests', () => { it('should emit start and complete events during execution', async () => { const startSpy = vi.fn(); const completeSpy = vi.fn(); - + command.on('start', startSpy); command.on('complete', completeSpy); - + const result = await command.execute(); - + expect(startSpy).toHaveBeenCalledTimes(1); expect(completeSpy).toHaveBeenCalledTimes(1); - + const startEvent = startSpy.mock.calls[0][0]; expect(startEvent).toHaveProperty('type', 'start'); expect(startEvent.message).toContain('Command'); expect(startEvent).toHaveProperty('isProd', false); - + const completeEvent = completeSpy.mock.calls[0][0]; expect(completeEvent).toHaveProperty('type', 'complete'); expect(completeEvent.message).toContain('completed successfully'); expect(completeEvent).toHaveProperty('result', 'test-result'); - + expect(result).toBe('test-result'); }); @@ -120,20 +120,20 @@ describe('Command Integration Tests', () => { const startSpy = vi.fn(); const errorSpy = vi.fn(); const completeSpy = vi.fn(); - + command.on('start', startSpy); command.on('error', errorSpy); command.on('complete', completeSpy); - + const testError = new Error('Execution failed'); command.performExecute = vi.fn().mockRejectedValue(testError); - + await expect(command.execute()).rejects.toThrow('Execution failed'); - + expect(startSpy).toHaveBeenCalledTimes(1); expect(errorSpy).toHaveBeenCalledTimes(1); expect(completeSpy).not.toHaveBeenCalled(); // Should not emit complete on error - + const errorEvent = errorSpy.mock.calls[0][0]; expect(errorEvent).toHaveProperty('type', 'error'); expect(errorEvent.message).toContain('failed'); @@ -145,10 +145,10 @@ describe('Command Integration Tests', () => { it('should validate events correctly with basic structure check', () => { const validEvent = { type: 'progress', message: 'Test', timestamp: new Date(), data: {} }; const invalidEvent = { type: 'invalid-type' }; // Missing required fields - + const validResult = command.validateEvent(validEvent); const invalidResult = command.validateEvent(invalidEvent); - + expect(validResult.success).toBe(true); expect(invalidResult.success).toBe(false); }); @@ -156,10 +156,10 @@ describe('Command Integration Tests', () => { it('should validate events against specific class types', () => { const progressEventInstance = new ProgressEvent('Test progress', null, {}); const errorEventInstance = new ErrorEvent('Test error', new Error(), null, {}); - + const validProgressResult = command.validateEvent(progressEventInstance, ProgressEvent); const invalidResult = command.validateEvent(errorEventInstance, ProgressEvent); - + expect(validProgressResult.success).toBe(true); expect(invalidResult.success).toBe(false); }); @@ -167,11 +167,11 @@ describe('Command Integration Tests', () => { it('should emit typed events with validation via emitTypedEvent', () => { const testSpy = vi.fn(); command.on('test-event', testSpy); - + const validEvent = new ProgressEvent('Test progress', null, {}); - + command.emitTypedEvent('test-event', validEvent, ProgressEvent); - + expect(testSpy).toHaveBeenCalledTimes(1); const emittedEvent = testSpy.mock.calls[0][0]; expect(emittedEvent).toHaveProperty('message', 'Test progress'); @@ -185,7 +185,7 @@ describe('Command Integration Tests', () => { it('should maintain the same event structure for existing listeners', () => { // This test ensures that existing code listening for events will still work const legacyListenerSpy = vi.fn(); - + // Simulate how existing code might listen for events command.on('progress', (eventData) => { legacyListenerSpy({ @@ -195,9 +195,9 @@ describe('Command Integration Tests', () => { hasType: 'type' in eventData }); }); - + command.progress('Legacy test', { oldField: 'value' }); - + expect(legacyListenerSpy).toHaveBeenCalledWith({ message: 'Legacy test', data: { oldField: 'value' }, @@ -209,20 +209,20 @@ describe('Command Integration Tests', () => { it('should maintain existing event object properties', () => { const eventSpy = vi.fn(); command.on('success', eventSpy); - + command.success('Test message', { custom: 'data' }); - + expect(eventSpy).toHaveBeenCalledTimes(1); const event = eventSpy.mock.calls[0][0]; - + // Check all expected properties are present expect(event).toHaveProperty('message', 'Test message'); expect(event.data).toMatchObject({ custom: 'data' }); // May have additional properties expect(event).toHaveProperty('timestamp'); expect(event).toHaveProperty('type', 'success'); - + // Ensure timestamp is a Date object (not string) expect(event.timestamp).toBeInstanceOf(Date); }); }); -}); \ No newline at end of file +}); diff --git a/test/CommandRouter.test.js b/test/CommandRouter.test.js index d0c489a..cad26ff 100644 --- a/test/CommandRouter.test.js +++ b/test/CommandRouter.test.js @@ -3,7 +3,7 @@ */ import { describe, it, expect, beforeEach, vi } from 'vitest'; -import CommandRouter from '../src/lib/CommandRouter.js'; +import CommandRouter from '../packages/data-cli/src/lib/CommandRouter.js'; import { z } from 'zod'; describe('CommandRouter', () => { @@ -16,13 +16,11 @@ describe('CommandRouter', () => { describe('Basic Routing', () => { it('should register and execute a simple command', async () => { const handler = vi.fn(async (args) => ({ result: 'success', args })); - - router - .command('test') - .handler(handler); + + router.command('test').handler(handler); const result = await router.execute('test', { foo: 'bar' }); - + expect(handler).toHaveBeenCalledWith( { foo: 'bar' }, expect.objectContaining({ @@ -35,35 +33,35 @@ describe('CommandRouter', () => { it('should handle subcommands', async () => { const handler = vi.fn(async () => 'subcommand executed'); - - router - .command('parent') - .subcommand('child') - .handler(handler); + + router.command('parent').subcommand('child').handler(handler); const result = await router.execute('parent/child', {}); - + expect(handler).toHaveBeenCalled(); expect(result).toBe('subcommand executed'); }); it('should throw error for unregistered commands', async () => { - await expect(router.execute('nonexistent', {})) - .rejects.toThrow('No handler registered for command: nonexistent'); + await expect(router.execute('nonexistent', {})).rejects.toThrow( + 'No handler registered for command: nonexistent' + ); }); }); describe('Zod Schema Validation', () => { it('should validate arguments with Zod schema', async () => { const handler = vi.fn(async (args) => args); - + router .command('validate') - .schema(z.object({ - name: z.string(), - age: z.number().min(0).max(120), - email: z.string().email().optional() - })) + .schema( + z.object({ + name: z.string(), + age: z.number().min(0).max(120), + email: z.string().email().optional() + }) + ) .handler(handler); const result = await router.execute('validate', { @@ -89,14 +87,16 @@ describe('CommandRouter', () => { it('should apply default values from schema', async () => { const handler = vi.fn(async (args) => args); - + router .command('defaults') - .schema(z.object({ - verbose: z.boolean().default(false), - output: z.string().default('console'), - limit: z.number().default(10) - })) + .schema( + z.object({ + verbose: z.boolean().default(false), + output: z.string().default('console'), + limit: z.number().default(10) + }) + ) .handler(handler); const result = await router.execute('defaults', {}); @@ -111,26 +111,30 @@ describe('CommandRouter', () => { it('should reject invalid arguments', async () => { router .command('strict') - .schema(z.object({ - count: z.number().int().positive() - })) + .schema( + z.object({ + count: z.number().int().positive() + }) + ) .handler(async () => 'should not reach'); - await expect(router.execute('strict', { count: 'not-a-number' })) - .rejects.toThrow('Validation failed'); + await expect(router.execute('strict', { count: 'not-a-number' })).rejects.toThrow( + 'Validation failed' + ); - await expect(router.execute('strict', { count: -5 })) - .rejects.toThrow('Validation failed'); + await expect(router.execute('strict', { count: -5 })).rejects.toThrow('Validation failed'); }); it('should handle enum schemas', async () => { const handler = vi.fn(async (args) => args); - + router .command('format') - .schema(z.object({ - type: z.enum(['json', 'yaml', 'xml']).default('json') - })) + .schema( + z.object({ + type: z.enum(['json', 'yaml', 'xml']).default('json') + }) + ) .handler(handler); const result = await router.execute('format', { type: 'yaml' }); @@ -144,14 +148,16 @@ describe('CommandRouter', () => { describe('CLI Argument Conversion', () => { it('should convert kebab-case CLI args to camelCase', async () => { const handler = vi.fn(async (args) => args); - + router .command('convert') - .schema(z.object({ - firstName: z.string(), - lastName: z.string(), - phoneNumber: z.string().optional() - })) + .schema( + z.object({ + firstName: z.string(), + lastName: z.string(), + phoneNumber: z.string().optional() + }) + ) .handler(handler); const result = await router.execute('convert', { @@ -169,14 +175,16 @@ describe('CommandRouter', () => { it('should handle boolean flags correctly', async () => { const handler = vi.fn(async (args) => args); - + router .command('flags') - .schema(z.object({ - verbose: z.boolean().default(false), - quiet: z.boolean().default(false), - force: z.boolean().default(false) - })) + .schema( + z.object({ + verbose: z.boolean().default(false), + quiet: z.boolean().default(false), + force: z.boolean().default(false) + }) + ) .handler(handler); const result = await router.execute('flags', { @@ -196,18 +204,20 @@ describe('CommandRouter', () => { describe('Help Generation', () => { it('should return help flag when --help is passed', async () => { const handler = vi.fn(); - + router .command('helpful') .description('A helpful command') - .schema(z.object({ - input: z.string().describe('Input file path'), - output: z.string().describe('Output file path') - })) + .schema( + z.object({ + input: z.string().describe('Input file path'), + output: z.string().describe('Output file path') + }) + ) .handler(handler); const result = await router.execute('helpful', { '--help': true }); - + expect(result).toEqual({ help: true }); expect(handler).not.toHaveBeenCalled(); }); @@ -218,17 +228,15 @@ describe('CommandRouter', () => { const middleware = vi.fn(async (context) => { context.args.middlewareRan = true; }); - + const handler = vi.fn(async (args) => args); - + router.use(middleware); - - router - .command('middleware-test') - .handler(handler); + + router.command('middleware-test').handler(handler); const result = await router.execute('middleware-test', { foo: 'bar' }); - + expect(middleware).toHaveBeenCalled(); expect(result.middlewareRan).toBe(true); }); @@ -237,16 +245,13 @@ describe('CommandRouter', () => { const routeMiddleware = vi.fn(async (context) => { context.args.routeSpecific = true; }); - + const handler = vi.fn(async (args) => args); - - router - .command('route-middleware') - .use(routeMiddleware) - .handler(handler); + + router.command('route-middleware').use(routeMiddleware).handler(handler); const result = await router.execute('route-middleware', {}); - + expect(routeMiddleware).toHaveBeenCalled(); expect(result.routeSpecific).toBe(true); }); @@ -255,14 +260,12 @@ describe('CommandRouter', () => { describe('Pattern Matching', () => { it('should match wildcard patterns', async () => { const handler = vi.fn(async () => 'wildcard matched'); - - router - .command('api/*') - .handler(handler); + + router.command('api/*').handler(handler); const result1 = await router.execute('api/users', {}); const result2 = await router.execute('api/posts/123', {}); - + expect(result1).toBe('wildcard matched'); expect(result2).toBe('wildcard matched'); expect(handler).toHaveBeenCalledTimes(2); @@ -277,7 +280,7 @@ describe('CommandRouter', () => { this.logger = logger; this.isProd = isProd; } - + async execute(args) { return { executed: true, @@ -286,16 +289,14 @@ describe('CommandRouter', () => { }; } } - + router.config = { test: 'config' }; router.logger = console; - - router - .command('class-handler') - .handler(TestCommand); + + router.command('class-handler').handler(TestCommand); const result = await router.execute('class-handler', { prod: true }); - + expect(result.executed).toBe(true); expect(result.hasConfig).toBe(true); }); @@ -313,7 +314,7 @@ describe('CommandRouter', () => { it('should validate port numbers correctly', () => { const portSchema = CommandRouter.schemas.port; - + expect(portSchema.safeParse(3000).success).toBe(true); expect(portSchema.safeParse(80).success).toBe(true); expect(portSchema.safeParse(0).success).toBe(false); @@ -326,16 +327,13 @@ describe('CommandRouter', () => { it('should emit error events on failure', async () => { const errorHandler = vi.fn(); router.on('error', errorHandler); - - router - .command('failing') - .handler(async () => { - throw new Error('Command failed'); - }); - - await expect(router.execute('failing', {})) - .rejects.toThrow('Command failed'); - + + router.command('failing').handler(async () => { + throw new Error('Command failed'); + }); + + await expect(router.execute('failing', {})).rejects.toThrow('Command failed'); + expect(errorHandler).toHaveBeenCalledWith( expect.objectContaining({ path: 'failing', @@ -352,7 +350,7 @@ describe('CommandRouter', () => { .description('First command') .schema(z.object({ test: z.string() })) .handler(async () => {}); - + router .command('second') .subcommand('sub') @@ -360,7 +358,7 @@ describe('CommandRouter', () => { .handler(async () => {}); const routes = router.getRoutes(); - + expect(routes).toHaveLength(2); expect(routes[0]).toEqual({ path: 'first', @@ -378,4 +376,4 @@ describe('CommandRouter', () => { }); }); }); -}); \ No newline at end of file +}); diff --git a/test/MigrateCommand.test.js b/test/MigrateCommand.test.js index c182ee6..f16f46f 100644 --- a/test/MigrateCommand.test.js +++ b/test/MigrateCommand.test.js @@ -13,11 +13,11 @@ describe('MigrateCommand', () => { beforeEach(async () => { // Reset modules to ensure clean mocks vi.resetModules(); - + // Mock console to prevent output during tests consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); - + // Mock all subcommand modules before importing MigrateCommand vi.doMock('../src/commands/db/migrate/generate.js', () => { return { @@ -89,7 +89,7 @@ describe('MigrateCommand', () => { } // Now import MigrateCommand after all mocks are set up - const module = await import('../src/commands/db/MigrateCommand.js'); + const module = await import('../packages/data-cli/src/commands/db/MigrateCommand.js'); MigrateCommand = module.default; command = new MigrateCommand(); }); @@ -103,8 +103,8 @@ describe('MigrateCommand', () => { describe('Router Integration', () => { it('should initialize router with all subcommands', () => { const routes = command.router.getRoutes(); - const subcommands = routes.map(r => r.path.split('/')[1]); - + const subcommands = routes.map((r) => r.path.split('/')[1]); + expect(subcommands).toContain('generate'); expect(subcommands).toContain('test'); expect(subcommands).toContain('status'); @@ -118,8 +118,8 @@ describe('MigrateCommand', () => { it('should have schemas for all subcommands', () => { const routes = command.router.getRoutes(); - - routes.forEach(route => { + + routes.forEach((route) => { expect(route.hasSchema).toBe(true); expect(route.description).toBeTruthy(); }); @@ -159,13 +159,11 @@ describe('MigrateCommand', () => { describe('Help System', () => { it('should show general help when no subcommand provided', async () => { await command.execute({}); - + expect(consoleLogSpy).toHaveBeenCalledWith( expect.stringContaining('Usage: data db migrate ') ); - expect(consoleLogSpy).toHaveBeenCalledWith( - expect.stringContaining('Commands:') - ); + expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Commands:')); }); it('should show subcommand help with --help flag', async () => { @@ -183,13 +181,15 @@ describe('MigrateCommand', () => { describe('Error Handling', () => { it('should handle unknown subcommands gracefully', async () => { - await expect(command.execute({ - _: ['unknown-command'] - })).rejects.toThrow(); + await expect( + command.execute({ + _: ['unknown-command'] + }) + ).rejects.toThrow(); expect(consoleErrorSpy).toHaveBeenCalledWith( expect.stringContaining('Unknown migration command: unknown-command') ); }); }); -}); \ No newline at end of file +}); diff --git a/test/TestRequirementAnalyzer.column.test.js b/test/TestRequirementAnalyzer.column.test.js index 995d897..6d25352 100644 --- a/test/TestRequirementAnalyzer.column.test.js +++ b/test/TestRequirementAnalyzer.column.test.js @@ -4,7 +4,11 @@ */ import { describe, it, expect, beforeEach } from 'vitest'; -import { TestRequirementAnalyzer, TEST_TYPES, TEST_PRIORITIES } from '../src/lib/testing/TestRequirementAnalyzer.js'; +import { + TestRequirementAnalyzer, + TEST_TYPES, + TEST_PRIORITIES +} from '../src/lib/testing/TestRequirementAnalyzer.js'; describe('TestRequirementAnalyzer - Column Test Mapping', () => { let analyzer; @@ -29,7 +33,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { ); expect(requirements).toHaveLength(1); - + const req = requirements[0]; expect(req.type).toBe(TEST_TYPES.SCHEMA); expect(req.priority).toBe(TEST_PRIORITIES.HIGH); @@ -42,7 +46,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should generate test requirements for DROP_COLUMN operation', () => { const operation = { - sql: "ALTER TABLE users DROP COLUMN old_field;", + sql: 'ALTER TABLE users DROP COLUMN old_field;', type: 'ALTER_TABLE' }; @@ -55,7 +59,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { ); expect(requirements).toHaveLength(2); // Drop test + comprehensive validation - + const dropReq = requirements[0]; expect(dropReq.type).toBe(TEST_TYPES.SCHEMA); expect(dropReq.priority).toBe(TEST_PRIORITIES.CRITICAL); @@ -66,7 +70,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should generate test requirements for ALTER_TYPE operation', () => { const operation = { - sql: "ALTER TABLE users ALTER COLUMN age TYPE INTEGER;", + sql: 'ALTER TABLE users ALTER COLUMN age TYPE INTEGER;', type: 'ALTER_TABLE' }; @@ -93,7 +97,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should generate test requirements for SET_NOT_NULL operation', () => { const operation = { - sql: "ALTER TABLE users ALTER COLUMN name SET NOT NULL;", + sql: 'ALTER TABLE users ALTER COLUMN name SET NOT NULL;', type: 'ALTER_TABLE' }; @@ -116,7 +120,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should generate test requirements for DROP_NOT_NULL operation', () => { const operation = { - sql: "ALTER TABLE users ALTER COLUMN description DROP NOT NULL;", + sql: 'ALTER TABLE users ALTER COLUMN description DROP NOT NULL;', type: 'ALTER_TABLE' }; @@ -163,7 +167,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should generate test requirements for DROP_DEFAULT operation', () => { const operation = { - sql: "ALTER TABLE users ALTER COLUMN status DROP DEFAULT;", + sql: 'ALTER TABLE users ALTER COLUMN status DROP DEFAULT;', type: 'ALTER_TABLE' }; @@ -186,7 +190,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should handle unknown column operations gracefully', () => { const operation = { - sql: "ALTER TABLE users ALTER COLUMN some_field SOME_UNKNOWN_OP;", + sql: 'ALTER TABLE users ALTER COLUMN some_field SOME_UNKNOWN_OP;', type: 'ALTER_TABLE' }; @@ -212,7 +216,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { describe('_generateConstraintTests', () => { it('should generate primary key constraint tests', () => { const operation = { - sql: "ALTER TABLE users ADD CONSTRAINT pk_users PRIMARY KEY (id);", + sql: 'ALTER TABLE users ADD CONSTRAINT pk_users PRIMARY KEY (id);', type: 'ALTER_TABLE' }; @@ -234,7 +238,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should generate foreign key constraint tests', () => { const operation = { - sql: "ALTER TABLE posts ADD CONSTRAINT fk_posts_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;", + sql: 'ALTER TABLE posts ADD CONSTRAINT fk_posts_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;', type: 'ALTER_TABLE' }; @@ -259,7 +263,7 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { it('should generate check constraint tests', () => { const operation = { - sql: "ALTER TABLE users ADD CONSTRAINT chk_age CHECK (age >= 18);", + sql: 'ALTER TABLE users ADD CONSTRAINT chk_age CHECK (age >= 18);', type: 'ALTER_TABLE' }; @@ -283,14 +287,18 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { describe('Column parsing helpers', () => { it('should extract column names correctly', () => { - expect(analyzer._extractColumnName("ADD COLUMN email VARCHAR(255)", "ADD COLUMN")).toBe("email"); - expect(analyzer._extractColumnName("DROP COLUMN old_field", "DROP COLUMN")).toBe("old_field"); - expect(analyzer._extractColumnName("ALTER COLUMN name TYPE TEXT", "ALTER COLUMN")).toBe("name"); + expect(analyzer._extractColumnName('ADD COLUMN email VARCHAR(255)', 'ADD COLUMN')).toBe( + 'email' + ); + expect(analyzer._extractColumnName('DROP COLUMN old_field', 'DROP COLUMN')).toBe('old_field'); + expect(analyzer._extractColumnName('ALTER COLUMN name TYPE TEXT', 'ALTER COLUMN')).toBe( + 'name' + ); }); it('should parse column definitions correctly', () => { const sql = "ADD COLUMN email VARCHAR(255) NOT NULL DEFAULT 'user@example.com' UNIQUE"; - const metadata = analyzer._parseColumnConstraints(sql, "email"); + const metadata = analyzer._parseColumnConstraints(sql, 'email'); expect(metadata.type).toBe('VARCHAR(255)'); expect(metadata.notNull).toBe(true); @@ -300,10 +308,20 @@ describe('TestRequirementAnalyzer - Column Test Mapping', () => { }); it('should identify constraint types correctly', () => { - expect(analyzer._identifyConstraintType("ADD CONSTRAINT pk_test PRIMARY KEY (id)")).toBe('PRIMARY_KEY'); - expect(analyzer._identifyConstraintType("ADD CONSTRAINT fk_test FOREIGN KEY (user_id) REFERENCES users(id)")).toBe('FOREIGN_KEY'); - expect(analyzer._identifyConstraintType("ADD CONSTRAINT uk_test UNIQUE (email)")).toBe('UNIQUE'); - expect(analyzer._identifyConstraintType("ADD CONSTRAINT chk_test CHECK (age > 0)")).toBe('CHECK'); + expect(analyzer._identifyConstraintType('ADD CONSTRAINT pk_test PRIMARY KEY (id)')).toBe( + 'PRIMARY_KEY' + ); + expect( + analyzer._identifyConstraintType( + 'ADD CONSTRAINT fk_test FOREIGN KEY (user_id) REFERENCES users(id)' + ) + ).toBe('FOREIGN_KEY'); + expect(analyzer._identifyConstraintType('ADD CONSTRAINT uk_test UNIQUE (email)')).toBe( + 'UNIQUE' + ); + expect(analyzer._identifyConstraintType('ADD CONSTRAINT chk_test CHECK (age > 0)')).toBe( + 'CHECK' + ); }); }); -}); \ No newline at end of file +}); diff --git a/test/TestRequirementAnalyzer.rls.test.js b/test/TestRequirementAnalyzer.rls.test.js index 7bb4b94..cea208f 100644 --- a/test/TestRequirementAnalyzer.rls.test.js +++ b/test/TestRequirementAnalyzer.rls.test.js @@ -1,11 +1,15 @@ /** * Unit tests for RLS policy test mapping in TestRequirementAnalyzer - * + * * Tests the specific RLS functionality implemented for task T007 */ import { describe, it, expect, beforeEach } from 'vitest'; -import { TestRequirementAnalyzer, TEST_TYPES, TEST_PRIORITIES } from '../src/lib/testing/TestRequirementAnalyzer.js'; +import { + TestRequirementAnalyzer, + TEST_TYPES, + TEST_PRIORITIES +} from '../starfleet/data-core/src/testing/TestRequirementAnalyzer.js'; describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { let analyzer; @@ -27,34 +31,36 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { expect(requirements.length).toBeGreaterThan(3); // Should include RLS and PERMISSION test types - const testTypes = requirements.map(req => req.type); + const testTypes = requirements.map((req) => req.type); expect(testTypes).toContain(TEST_TYPES.RLS); expect(testTypes).toContain(TEST_TYPES.PERMISSION); // All requirements should be CRITICAL priority for security - const priorities = requirements.map(req => req.priority); - priorities.forEach(priority => { + const priorities = requirements.map((req) => req.priority); + priorities.forEach((priority) => { expect(priority).toBe(TEST_PRIORITIES.CRITICAL); }); // Should test multiple user roles - const userRoleTests = requirements.filter(req => - req.description.includes('role anon') || - req.description.includes('role authenticated') || - req.description.includes('role service_role') + const userRoleTests = requirements.filter( + (req) => + req.description.includes('role anon') || + req.description.includes('role authenticated') || + req.description.includes('role service_role') ); expect(userRoleTests.length).toBe(3); }); it('should extract policy details correctly', () => { - const sql = 'CREATE POLICY test_policy ON users FOR SELECT TO authenticated, anon USING (auth.uid() = id) WITH CHECK (status = \'active\')'; + const sql = + "CREATE POLICY test_policy ON users FOR SELECT TO authenticated, anon USING (auth.uid() = id) WITH CHECK (status = 'active')"; const details = analyzer._extractPolicyDetails(sql); expect(details.commands).toEqual(['SELECT']); expect(details.roles).toEqual(['authenticated', 'anon']); expect(details.isPermissive).toBe(true); expect(details.expression).toBe('auth.uid() = id'); - expect(details.checkExpression).toBe('status = \'active\''); + expect(details.checkExpression).toBe("status = 'active'"); }); it('should handle FOR ALL commands', () => { @@ -69,7 +75,7 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { describe('ALTER POLICY mapping', () => { it('should generate test requirements for ALTER POLICY', async () => { const operation = { - sql: 'ALTER POLICY user_policy ON users TO authenticated, admin USING (auth.uid() = id OR auth.role() = \'admin\')', + sql: "ALTER POLICY user_policy ON users TO authenticated, admin USING (auth.uid() = id OR auth.role() = 'admin')", type: 'WARNING' }; @@ -78,8 +84,8 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { expect(requirements.length).toBeGreaterThan(2); // Should include altered security boundary tests - const alteredTests = requirements.filter(req => - req.metadata?.testType === 'altered_security_boundary' + const alteredTests = requirements.filter( + (req) => req.metadata?.testType === 'altered_security_boundary' ); expect(alteredTests.length).toBeGreaterThan(0); }); @@ -97,14 +103,14 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { expect(requirements.length).toBeGreaterThan(1); // Should include policy removal tests - const removalTests = requirements.filter(req => - req.metadata?.testType === 'policy_removal' + const removalTests = requirements.filter( + (req) => req.metadata?.testType === 'policy_removal' ); expect(removalTests.length).toBe(1); // Should include post-drop security tests - const postDropTests = requirements.filter(req => - req.metadata?.testType === 'post_drop_security' + const postDropTests = requirements.filter( + (req) => req.metadata?.testType === 'post_drop_security' ); expect(postDropTests.length).toBe(1); }); @@ -122,14 +128,14 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { expect(requirements.length).toBeGreaterThan(1); // Should include is_rls_enabled test - const rlsEnabledTests = requirements.filter(req => - req.testCases.some(tc => tc.includes('is_rls_enabled')) + const rlsEnabledTests = requirements.filter((req) => + req.testCases.some((tc) => tc.includes('is_rls_enabled')) ); expect(rlsEnabledTests.length).toBe(1); // Should test security impact - const securityTests = requirements.filter(req => - req.metadata?.testType === 'rls_security_impact' + const securityTests = requirements.filter( + (req) => req.metadata?.testType === 'rls_security_impact' ); expect(securityTests.length).toBe(1); }); @@ -147,14 +153,14 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { expect(requirements.length).toBe(2); // Should include RLS disablement test - const disablementTests = requirements.filter(req => - req.metadata?.testType === 'rls_disablement' + const disablementTests = requirements.filter( + (req) => req.metadata?.testType === 'rls_disablement' ); expect(disablementTests.length).toBe(1); // Should test security impact with HIGH priority (potential security risk) - const securityTests = requirements.filter(req => - req.metadata?.testType === 'rls_disable_security_impact' + const securityTests = requirements.filter( + (req) => req.metadata?.testType === 'rls_disable_security_impact' ); expect(securityTests.length).toBe(1); expect(securityTests[0].priority).toBe(TEST_PRIORITIES.HIGH); @@ -175,15 +181,15 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { expect(scenarios.length).toBeGreaterThan(2); // Should include basic operation tests - const selectScenario = scenarios.find(s => s.operation === 'SELECT'); + const selectScenario = scenarios.find((s) => s.operation === 'SELECT'); expect(selectScenario).toBeDefined(); expect(selectScenario.role).toBe('authenticated'); - const insertScenario = scenarios.find(s => s.operation === 'INSERT'); + const insertScenario = scenarios.find((s) => s.operation === 'INSERT'); expect(insertScenario).toBeDefined(); // Should include service_role bypass test - const bypassScenario = scenarios.find(s => s.role === 'service_role'); + const bypassScenario = scenarios.find((s) => s.role === 'service_role'); expect(bypassScenario).toBeDefined(); expect(bypassScenario.shouldAllow).toBe(true); }); @@ -222,4 +228,4 @@ describe('TestRequirementAnalyzer - RLS Policy Mapping', () => { } }); }); -}); \ No newline at end of file +}); diff --git a/test/TestTemplateGenerator.table.test.js b/test/TestTemplateGenerator.table.test.js index b90e5f3..a9bbf10 100644 --- a/test/TestTemplateGenerator.table.test.js +++ b/test/TestTemplateGenerator.table.test.js @@ -150,7 +150,7 @@ describe('TestTemplateGenerator - Table Tests', () => { }; const template = generator.generateTemplate(requirement); - + // Base count (12) + columns (3*2=6) + constraints (2*2=4) + indexes (2*2=4) + RLS (3) = 29 expect(template.content).toContain('tap.plan(29)'); }); @@ -229,7 +229,9 @@ describe('TestTemplateGenerator - Table Tests', () => { name: 'invalid-table-name' }; - expect(() => generator.generateTemplate(invalidRequirement)).toThrow('Name must contain only letters, numbers, and underscores'); + expect(() => generator.generateTemplate(invalidRequirement)).toThrow( + 'Name must contain only letters, numbers, and underscores' + ); }); }); -}); \ No newline at end of file +}); diff --git a/test/config.validation.test.js b/test/config.validation.test.js index d8426d1..a3416f3 100644 --- a/test/config.validation.test.js +++ b/test/config.validation.test.js @@ -1,10 +1,10 @@ -const { describe, it, expect } = require('vitest'); -const { +import { describe, it, expect } from 'vitest'; +import { DataConfigSchema, parsedataConfig, safeParsedataConfig, - mergeConfigs -} = require('../src/lib/schemas/DataConfigSchema'); + mergeConfigs +} from '../src/lib/schemas/DataConfigSchema.js'; describe('dataConfigSchema', () => { describe('parsedataConfig', () => { @@ -16,7 +16,7 @@ describe('dataConfigSchema', () => { } } }; - + expect(() => parsedataConfig(config)).not.toThrow(); }); @@ -33,7 +33,7 @@ describe('dataConfigSchema', () => { } } }; - + expect(() => parsedataConfig(config)).toThrow(); }); @@ -45,7 +45,7 @@ describe('dataConfigSchema', () => { } } }; - + expect(() => parsedataConfig(config)).toThrow(); }); @@ -104,7 +104,7 @@ describe('dataConfigSchema', () => { timestamps: false } }; - + const parsed = parsedataConfig(config); expect(parsed).toMatchObject(config); }); @@ -118,7 +118,7 @@ describe('dataConfigSchema', () => { } } }; - + expect(() => parsedataConfig(config)).not.toThrow(); }); @@ -131,7 +131,7 @@ describe('dataConfigSchema', () => { } } }; - + expect(() => parsedataConfig(config)).toThrow(); }); @@ -141,15 +141,15 @@ describe('dataConfigSchema', () => { minimum_coverage: 150 } }; - + expect(() => parsedataConfig(invalidConfig)).toThrow(); - + const validConfig = { test: { minimum_coverage: 85 } }; - + expect(() => parsedataConfig(validConfig)).not.toThrow(); }); @@ -159,15 +159,15 @@ describe('dataConfigSchema', () => { output_formats: ['console', 'invalid-format'] } }; - + expect(() => parsedataConfig(invalidConfig)).toThrow(); - + const validConfig = { test: { output_formats: ['console', 'json', 'junit', 'tap', 'html'] } }; - + expect(() => parsedataConfig(validConfig)).not.toThrow(); }); @@ -177,15 +177,15 @@ describe('dataConfigSchema', () => { level: 'invalid-level' } }; - + expect(() => parsedataConfig(invalidConfig)).toThrow(); - + const validConfig = { logging: { level: 'debug' } }; - + expect(() => parsedataConfig(validConfig)).not.toThrow(); }); }); @@ -199,7 +199,7 @@ describe('dataConfigSchema', () => { } } }; - + const result = safeParsedataConfig(config); expect(result.success).toBe(true); expect(result.data).toMatchObject(config); @@ -213,7 +213,7 @@ describe('dataConfigSchema', () => { } } }; - + const result = safeParsedataConfig(config); expect(result.success).toBe(false); expect(result.error).toBeDefined(); @@ -232,7 +232,7 @@ describe('dataConfigSchema', () => { } } }; - + const result = safeParsedataConfig(config); expect(result.success).toBe(false); expect(result.error.errors.length).toBeGreaterThan(1); @@ -252,7 +252,7 @@ describe('dataConfigSchema', () => { } } }; - + const override = { test: { minimum_coverage: 90 @@ -263,7 +263,7 @@ describe('dataConfigSchema', () => { } } }; - + const merged = mergeConfigs(base, override); expect(merged.test.minimum_coverage).toBe(90); expect(merged.test.test_timeout).toBe(300); @@ -277,20 +277,20 @@ describe('dataConfigSchema', () => { minimum_coverage: 80 } }; - + const override = { test: { minimum_coverage: 200 // Invalid } }; - + expect(() => mergeConfigs(base, override)).toThrow(); }); it('should handle empty configs', () => { const base = {}; const override = {}; - + expect(() => mergeConfigs(base, override)).not.toThrow(); }); @@ -300,15 +300,15 @@ describe('dataConfigSchema', () => { output_formats: ['console', 'json'] } }; - + const override = { test: { output_formats: ['junit'] } }; - + const merged = mergeConfigs(base, override); expect(merged.test.output_formats).toEqual(['junit']); }); }); -}); \ No newline at end of file +}); diff --git a/test/formatters.test.js b/test/formatters.test.js index fc9cead..7931ba9 100644 --- a/test/formatters.test.js +++ b/test/formatters.test.js @@ -64,7 +64,7 @@ describe('Test Result Formatters', () => { it('should format results as valid JUnit XML', () => { const formatter = new JUnitFormatter(); const xml = formatter.format(mockResults); - + expect(xml).toContain(''); expect(xml).toContain(''); expect(xml).toContain(' { failed: 0, testFunctions: [] }; - + const formatter = new JUnitFormatter(); const xml = formatter.format(resultsWithSpecialChars); - + expect(xml).toContain('<special> & "characters"'); }); @@ -106,9 +106,9 @@ describe('Test Result Formatters', () => { it('should format results as valid JSON', () => { const formatter = new JSONFormatter(); const jsonString = formatter.format(mockResults); - + const parsed = JSON.parse(jsonString); - + expect(parsed.stats.total).toBe(3); expect(parsed.stats.passed).toBe(2); expect(parsed.stats.failed).toBe(1); @@ -121,7 +121,7 @@ describe('Test Result Formatters', () => { const formatter = new JSONFormatter(); const jsonString = formatter.format(mockResults); const parsed = JSON.parse(jsonString); - + expect(parsed.metadata).toBeDefined(); expect(parsed.metadata.format).toBe('json'); expect(parsed.metadata.version).toBe('1.0'); @@ -133,10 +133,10 @@ describe('Test Result Formatters', () => { const formatter = new JSONFormatter(); const jsonString = formatter.format(mockResults); const parsed = JSON.parse(jsonString); - + expect(parsed.summary.passRate).toBe('66.7'); // 2/3 * 100 expect(parsed.summary.failRate).toBe('33.3'); // 1/3 * 100 - expect(parsed.summary.skipRate).toBe('0.0'); // 0/3 * 100 + expect(parsed.summary.skipRate).toBe('0.0'); // 0/3 * 100 }); it('should return .json file extension', () => { @@ -144,4 +144,4 @@ describe('Test Result Formatters', () => { expect(formatter.getFileExtension()).toBe('.json'); }); }); -}); \ No newline at end of file +}); diff --git a/test/function-parsing.test.js b/test/function-parsing.test.js index cb6abbc..6241aa7 100644 --- a/test/function-parsing.test.js +++ b/test/function-parsing.test.js @@ -17,7 +17,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse has_function with just function name', () => { const sql = "SELECT has_function('user_count');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_function'); expect(assertions[0].target).toBe('user_count'); @@ -29,7 +29,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse has_function with schema and function name', () => { const sql = "SELECT has_function('public', 'user_count');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_function'); expect(assertions[0].target).toBe('public.user_count'); @@ -42,7 +42,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse has_function with parameters', () => { const sql = "SELECT has_function('user_count', ARRAY['integer', 'text']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_function'); expect(assertions[0].target).toBe('user_count'); @@ -55,7 +55,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse has_function with schema, function name and parameters', () => { const sql = "SELECT has_function('public', 'user_count', ARRAY['integer', 'text']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_function'); expect(assertions[0].target).toBe('public.user_count'); @@ -71,7 +71,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse function_returns with function name and return type', () => { const sql = "SELECT function_returns('user_count', 'integer');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('function_returns'); expect(assertions[0].target).toBe('user_count'); @@ -84,7 +84,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse function_returns with schema, function name and return type', () => { const sql = "SELECT function_returns('public', 'user_count', 'integer');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('function_returns'); expect(assertions[0].target).toBe('public.user_count'); @@ -98,7 +98,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse function_returns with parameters', () => { const sql = "SELECT function_returns('user_count', ARRAY['text', 'integer'], 'boolean');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('function_returns'); expect(assertions[0].target).toBe('user_count'); @@ -114,7 +114,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse function_lang_is', () => { const sql = "SELECT function_lang_is('user_count', 'plpgsql');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('function_lang_is'); expect(assertions[0].target).toBe('user_count'); @@ -129,7 +129,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse is_definer', () => { const sql = "SELECT is_definer('secure_function');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('is_definer'); expect(assertions[0].target).toBe('secure_function'); @@ -142,7 +142,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse isnt_definer', () => { const sql = "SELECT isnt_definer('normal_function');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('isnt_definer'); expect(assertions[0].target).toBe('normal_function'); @@ -157,7 +157,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse volatility_is', () => { const sql = "SELECT volatility_is('pure_function', 'immutable');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('volatility_is'); expect(assertions[0].target).toBe('pure_function'); @@ -172,7 +172,7 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { it('should parse function_privs_are with basic pattern', () => { const sql = "SELECT function_privs_are('calc_func', 'app_user', ARRAY['EXECUTE']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('function_privs_are'); expect(assertions[0].target).toBe('calc_func'); @@ -192,22 +192,24 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { SELECT function_lang_is('public', 'user_count', 'sql'); SELECT is_definer('public', 'admin_func'); `; - + const assertions = scanner.extractAssertions(sql); expect(assertions).toHaveLength(4); - + // Mock test file structure for coverage map building - scanner.testFiles = [{ - filePath: '/test/functions.sql', - fileName: 'functions.sql', - assertions: assertions, - planCount: 4, - dependencies: [], - metadata: {} - }]; - + scanner.testFiles = [ + { + filePath: '/test/functions.sql', + fileName: 'functions.sql', + assertions, + planCount: 4, + dependencies: [], + metadata: {} + } + ]; + scanner._buildCoverageMap(); - + const coverage = scanner.getCoverageMap(); expect(coverage.functions).toHaveProperty('public.user_count'); expect(coverage.functions).toHaveProperty('public.admin_func'); @@ -217,4 +219,4 @@ describe('pgTAPTestScanner Function Assertion Parsing', () => { expect(coverage.functions['public.admin_func']).toContain('is_definer'); }); }); -}); \ No newline at end of file +}); diff --git a/test/integration/command-execution.test.js b/test/integration/command-execution.test.js new file mode 100644 index 0000000..b355e40 --- /dev/null +++ b/test/integration/command-execution.test.js @@ -0,0 +1,742 @@ +/** + * Integration tests for Command execution flow + * + * Tests the complete command execution system including: + * - Command class inheritance and event emission + * - Production safety gates and confirmation + * - Event-driven architecture with real listeners + * - Command router and execution pipeline + * - Error handling and cleanup + * - ESM imports and dependency injection + * - Real command implementations + */ + +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import { EventEmitter } from 'events'; +import { Command } from '../../packages/data-cli/src/lib/Command.js'; +import { + ProgressEvent, + ErrorEvent, + SuccessEvent, + StartEvent, + CompleteEvent, + CancelledEvent, + validateCommandEvent +} from '../../src/lib/events/CommandEvents.cjs'; + +// Mock configuration class for testing +class MockConfig { + constructor(data = {}) { + this.data = data; + } + + get(key, defaultValue) { + const keys = key.split('.'); + let value = this.data; + for (const k of keys) { + value = value?.[k]; + } + return value !== undefined ? value : defaultValue; + } + + has(key) { + return this.get(key) !== undefined; + } +} + +// Mock output configuration class +class MockOutputConfig { + constructor(paths = {}) { + this.paths = paths; + } + + getSqlDir() { + return this.paths.sqlDir || './sql'; + } + + getTestsDir() { + return this.paths.testsDir || './tests'; + } + + getMigrationsDir() { + return this.paths.migrationsDir || './migrations'; + } +} + +// Test command implementations +class TestCommand extends Command { + constructor(config, logger, isProd, outputConfig, options = {}) { + super(config, logger, isProd, outputConfig); + this.options = options; + this.executeCount = 0; + this.shouldFail = options.shouldFail || false; + this.shouldThrow = options.shouldThrow || false; + } + + async performExecute(...args) { + this.executeCount++; + this.progress('Starting test command'); + + if (this.shouldThrow) { + throw new Error('Test command failed'); + } + + if (this.shouldFail) { + this.error('Command failed', null, { code: 'TEST_FAILURE' }); + return null; + } + + await this.simulateWork(); + this.success('Test command completed', { args }); + + return { success: true, args }; + } + + async simulateWork() { + // Simulate some async work with progress updates + for (let i = 0; i < 5; i++) { + this.progress(`Processing step ${i + 1}`, { step: i + 1, total: 5 }); + await new Promise((resolve) => setTimeout(resolve, 10)); + } + } +} + +class ProductionCommand extends Command { + constructor(config, logger, isProd, outputConfig) { + super(config, logger, isProd, outputConfig); + this.requiresProductionConfirmation = true; + } + + async performExecute() { + this.progress('Starting production operation'); + this.warn('This operation affects production data'); + this.success('Production operation completed'); + + return { environment: 'production' }; + } +} + +class InteractiveCommand extends Command { + constructor(config, logger, isProd, outputConfig) { + super(config, logger, isProd, outputConfig); + this.userResponses = new Map(); + } + + setUserResponse(type, response) { + this.userResponses.set(type, response); + } + + async performExecute() { + const name = await this.input('Enter your name:'); + const confirmed = await this.confirm('Proceed with operation?'); + + return { name, confirmed }; + } + + // Override prompt to provide test responses + prompt(type, options) { + // Emit the event before resolving for consistency with base class + return new Promise((resolve) => { + this.emit('prompt', { + type, + options, + resolve: (response) => { + resolve(this.userResponses.get(type) || response || false); + } + }); + }); + } +} + +class EventValidationCommand extends Command { + constructor(config, logger, isProd, outputConfig) { + super(config, logger, isProd, outputConfig); + this.validationResults = []; + } + + async performExecute() { + // Test various event types + const progressEvent = new ProgressEvent('Testing progress', 50); + const validation1 = this.validateEvent(progressEvent, ProgressEvent); + this.validationResults.push(validation1); + + const errorEvent = new ErrorEvent('Test error', new Error('test')); + const validation2 = this.validateEvent(errorEvent, ErrorEvent); + this.validationResults.push(validation2); + + // Test invalid validation + const validation3 = this.validateEvent(progressEvent, ErrorEvent); + this.validationResults.push(validation3); + + return { validationResults: this.validationResults }; + } +} + +describe('Command execution integration', () => { + let mockConfig; + let mockOutputConfig; + let mockLogger; + let eventLog; + + beforeEach(() => { + mockConfig = new MockConfig({ + logging: { level: 'info' }, + test: { timeout: 5000 } + }); + + mockOutputConfig = new MockOutputConfig({ + sqlDir: '/test/sql', + testsDir: '/test/tests', + migrationsDir: '/test/migrations' + }); + + mockLogger = { + info: vi.fn(), + warn: vi.fn(), + error: vi.fn(), + debug: vi.fn(), + trace: vi.fn() + }; + + eventLog = []; + }); + + afterEach(() => { + eventLog.length = 0; + }); + + function captureEvents(command) { + const events = ['start', 'progress', 'warning', 'error', 'success', 'complete', 'cancelled']; + + events.forEach((eventType) => { + command.on(eventType, (data) => { + eventLog.push({ + type: eventType, + data: { ...data }, + timestamp: data.timestamp + }); + }); + }); + } + + describe('basic command execution', () => { + it('should execute command with complete event flow', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + captureEvents(command); + + const result = await command.execute('arg1', 'arg2'); + + expect(result).toEqual({ success: true, args: ['arg1', 'arg2'] }); + expect(command.executeCount).toBe(1); + + // Verify event flow + const eventTypes = eventLog.map((e) => e.type); + expect(eventTypes).toContain('start'); + expect(eventTypes).toContain('progress'); + expect(eventTypes).toContain('success'); + expect(eventTypes).toContain('complete'); + + // Verify start event + const startEvent = eventLog.find((e) => e.type === 'start'); + expect(startEvent.data.message).toBe('Starting TestCommand'); + expect(startEvent.data.isProd).toBe(false); + + // Verify complete event + const completeEvent = eventLog.find((e) => e.type === 'complete'); + expect(completeEvent.data.message).toBe('TestCommand completed successfully'); + expect(completeEvent.data.result).toEqual({ success: true, args: ['arg1', 'arg2'] }); + }); + + it('should handle command execution errors', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig, { + shouldThrow: true + }); + captureEvents(command); + + await expect(command.execute()).rejects.toThrow('Test command failed'); + + const eventTypes = eventLog.map((e) => e.type); + expect(eventTypes).toContain('start'); + expect(eventTypes).toContain('error'); + expect(eventTypes).not.toContain('complete'); + }); + + it('should emit progress events during execution', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + captureEvents(command); + + await command.execute(); + + const progressEvents = eventLog.filter((e) => e.type === 'progress'); + expect(progressEvents.length).toBeGreaterThan(1); + + // Verify first progress event + const firstProgress = progressEvents.find((e) => e.data.message === 'Starting test command'); + expect(firstProgress).toBeDefined(); + + // Verify step progress events + const stepEvents = progressEvents.filter((e) => e.data.message.startsWith('Processing step')); + expect(stepEvents).toHaveLength(5); + }); + + it('should handle multiple command executions', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + + const result1 = await command.execute('test1'); + const result2 = await command.execute('test2'); + + expect(result1.args).toEqual(['test1']); + expect(result2.args).toEqual(['test2']); + expect(command.executeCount).toBe(2); + }); + }); + + describe('production safety and confirmation', () => { + it('should skip confirmation for non-production commands', async () => { + const command = new ProductionCommand(mockConfig, mockLogger, false, mockOutputConfig); + captureEvents(command); + + const result = await command.execute(); + + expect(result.environment).toBe('production'); + + // Should not have cancelled event + const eventTypes = eventLog.map((e) => e.type); + expect(eventTypes).not.toContain('cancelled'); + }); + + it('should request confirmation for production commands', async () => { + const command = new ProductionCommand(mockConfig, mockLogger, true, mockOutputConfig); + + // Mock confirmation response + let confirmationPrompt = null; + command.on('prompt', (data) => { + confirmationPrompt = data; + data.resolve(true); // User confirms + }); + + const result = await command.execute(); + + expect(confirmationPrompt).toBeDefined(); + expect(confirmationPrompt.type).toBe('confirm'); + expect(confirmationPrompt.options.message).toContain('PRODUCTION'); + expect(result.environment).toBe('production'); + }); + + it('should cancel on production confirmation decline', async () => { + const command = new ProductionCommand(mockConfig, mockLogger, true, mockOutputConfig); + captureEvents(command); + + // Mock confirmation response + command.on('prompt', (data) => { + data.resolve(false); // User declines + }); + + const result = await command.execute(); + + expect(result).toBeUndefined(); // Cancelled commands return undefined + + const eventTypes = eventLog.map((e) => e.type); + expect(eventTypes).toContain('cancelled'); + + const cancelledEvent = eventLog.find((e) => e.type === 'cancelled'); + expect(cancelledEvent.data.message).toBe('Operation cancelled'); + }); + + it('should emit warning events for production operations', async () => { + const command = new ProductionCommand(mockConfig, mockLogger, true, mockOutputConfig); + captureEvents(command); + + command.on('prompt', (data) => data.resolve(true)); + + await command.execute(); + + const warningEvents = eventLog.filter((e) => e.type === 'warning'); + expect(warningEvents.length).toBeGreaterThan(0); + + const prodWarning = warningEvents.find( + (e) => e.data.message === 'Production operation requested!' + ); + expect(prodWarning).toBeDefined(); + expect(prodWarning.data.data.environment).toBe('PRODUCTION'); + }); + }); + + describe('interactive commands and prompts', () => { + it('should handle input prompts', async () => { + const command = new InteractiveCommand(mockConfig, mockLogger, false, mockOutputConfig); + command.setUserResponse('input', 'John Doe'); + command.setUserResponse('confirm', true); + + const result = await command.execute(); + + expect(result.name).toBe('John Doe'); + expect(result.confirmed).toBe(true); + }); + + it('should handle confirmation prompts', async () => { + const command = new InteractiveCommand(mockConfig, mockLogger, false, mockOutputConfig); + command.setUserResponse('input', 'Test User'); + command.setUserResponse('confirm', false); + + const result = await command.execute(); + + expect(result.confirmed).toBe(false); + }); + + it('should emit prompt events', async () => { + const command = new InteractiveCommand(mockConfig, mockLogger, false, mockOutputConfig); + const prompts = []; + + command.on('prompt', (data) => { + prompts.push(data); + data.resolve('mocked response'); + }); + + await command.execute(); + + expect(prompts).toHaveLength(2); + expect(prompts[0].type).toBe('input'); + expect(prompts[1].type).toBe('confirm'); + }); + }); + + describe('event validation and type safety', () => { + it('should validate events with instanceof checks', async () => { + const command = new EventValidationCommand(mockConfig, mockLogger, false, mockOutputConfig); + + const result = await command.execute(); + + expect(result.validationResults).toHaveLength(3); + + // Valid validations should pass + expect(result.validationResults[0].success).toBe(true); + expect(result.validationResults[1].success).toBe(true); + + // Invalid validation should fail + expect(result.validationResults[2].success).toBe(false); + expect(result.validationResults[2].error).toContain('expected ErrorEvent, got ProgressEvent'); + }); + + it('should maintain event type information', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + captureEvents(command); + + await command.execute(); + + eventLog.forEach((event) => { + expect(event.type).toBeTruthy(); + expect(event.data).toBeDefined(); + expect(event.timestamp).toBeInstanceOf(Date); + }); + }); + + it('should emit typed events with proper structure', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + const typedEvents = []; + + command.on('progress', (data) => { + // Verify event structure matches expected format + expect(data.message).toBeDefined(); + expect(data.timestamp).toBeInstanceOf(Date); + expect(data.type).toBe('progress'); + typedEvents.push(data); + }); + + await command.execute(); + + expect(typedEvents.length).toBeGreaterThan(0); + }); + }); + + describe('logging integration', () => { + it('should log events to provided logger', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + + await command.execute(); + + expect(mockLogger.info).toHaveBeenCalled(); + + // Verify specific log calls + const infoCalls = mockLogger.info.mock.calls; + const progressLogs = infoCalls.filter((call) => call[1]?.includes('Starting test command')); + expect(progressLogs.length).toBeGreaterThan(0); + }); + + it('should log errors appropriately', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig, { + shouldFail: true + }); + + await command.execute(); + + expect(mockLogger.error).toHaveBeenCalled(); + + const errorCalls = mockLogger.error.mock.calls; + const errorLog = errorCalls.find((call) => call[1]?.includes('Command failed')); + expect(errorLog).toBeDefined(); + }); + + it('should use configuration for logger setup', () => { + const customConfig = new MockConfig({ + logging: { level: 'debug' } + }); + + const command = new TestCommand(customConfig, null, false, mockOutputConfig); + + // Command should create default logger when none provided + expect(command.logger).toBeDefined(); + expect(typeof command.logger.info).toBe('function'); + }); + }); + + describe('configuration integration', () => { + it('should use provided configuration', () => { + const customConfig = new MockConfig({ + test: { value: 'custom' } + }); + + const command = new TestCommand(customConfig, mockLogger, false, mockOutputConfig); + + expect(command.config).toBe(customConfig); + expect(command.config.get('test.value')).toBe('custom'); + }); + + it('should use output configuration for paths', () => { + const customOutputConfig = new MockOutputConfig({ + sqlDir: '/custom/sql', + testsDir: '/custom/tests' + }); + + const command = new TestCommand(mockConfig, mockLogger, false, customOutputConfig); + + expect(command.outputConfig).toBe(customOutputConfig); + expect(command.outputConfig.getSqlDir()).toBe('/custom/sql'); + }); + + it('should handle missing configuration gracefully', () => { + const command = new TestCommand(null, mockLogger, false, null); + + expect(command.config).toBeNull(); + expect(command.outputConfig).toBeNull(); + expect(command.logger).toBeDefined(); // Should create default logger + }); + }); + + describe('error handling and cleanup', () => { + it('should handle constructor errors', () => { + class FailingCommand extends Command { + constructor() { + throw new Error('Constructor failed'); + } + } + + expect(() => new FailingCommand()).toThrow('Constructor failed'); + }); + + it('should handle async errors in performExecute', async () => { + class AsyncFailingCommand extends Command { + async performExecute() { + await Promise.resolve(); + throw new Error('Async failure'); + } + } + + const command = new AsyncFailingCommand(mockConfig, mockLogger, false, mockOutputConfig); + + await expect(command.execute()).rejects.toThrow('Async failure'); + }); + + it('should clean up resources after execution', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + captureEvents(command); + + await command.execute(); + + // Verify no resources are left in resolving state + expect(command.isProd).toBeDefined(); + expect(command.logger).toBeDefined(); + + // Events should have been emitted and completed + const completeEvent = eventLog.find((e) => e.type === 'complete'); + expect(completeEvent).toBeDefined(); + }); + + it('should handle memory leaks from event listeners', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + + // Add many listeners + for (let i = 0; i < 100; i++) { + command.on('progress', () => {}); + } + + expect(command.listenerCount('progress')).toBe(100); + + await command.execute(); + + // Command should still execute normally + expect(command.executeCount).toBe(1); + }); + }); + + describe('ESM imports and module integration', () => { + it('should import Command class correctly', () => { + expect(Command).toBeDefined(); + expect(typeof Command).toBe('function'); + expect(Command.prototype.execute).toBeDefined(); + expect(Command.prototype.performExecute).toBeDefined(); + }); + + it('should import event classes correctly', () => { + const events = [ + ProgressEvent, + ErrorEvent, + SuccessEvent, + StartEvent, + CompleteEvent, + CancelledEvent + ]; + + events.forEach((EventClass) => { + expect(EventClass).toBeDefined(); + expect(typeof EventClass).toBe('function'); + + const instance = new EventClass('test message'); + expect(instance).toBeInstanceOf(EventClass); + }); + }); + + it('should maintain instanceof relationships across modules', async () => { + const command = new TestCommand(mockConfig, mockLogger, false, mockOutputConfig); + + expect(command).toBeInstanceOf(Command); + expect(command).toBeInstanceOf(EventEmitter); + }); + + it('should support dynamic imports', async () => { + // Test that modules can be imported dynamically + const commandModule = await import('../../packages/data-cli/src/lib/Command.js'); + const eventsModule = await import('../../src/lib/events/CommandEvents.cjs'); + + expect(commandModule.Command).toBe(Command); + expect(eventsModule.ProgressEvent).toBe(ProgressEvent); + }); + }); + + describe('real-world command patterns', () => { + it('should support command chaining', async () => { + const results = []; + + class ChainableCommand extends Command { + constructor(config, logger, isProd, outputConfig, step) { + super(config, logger, isProd, outputConfig); + this.step = step; + } + + async performExecute() { + this.progress(`Executing step ${this.step}`); + results.push(this.step); + return { step: this.step }; + } + } + + const commands = [ + new ChainableCommand(mockConfig, mockLogger, false, mockOutputConfig, 1), + new ChainableCommand(mockConfig, mockLogger, false, mockOutputConfig, 2), + new ChainableCommand(mockConfig, mockLogger, false, mockOutputConfig, 3) + ]; + + for (const command of commands) { + await command.execute(); + } + + expect(results).toEqual([1, 2, 3]); + }); + + it('should support parallel command execution', async () => { + const startTimes = []; + + class ParallelCommand extends Command { + constructor(config, logger, isProd, outputConfig, id) { + super(config, logger, isProd, outputConfig); + this.id = id; + } + + async performExecute() { + startTimes.push({ id: this.id, time: Date.now() }); + await new Promise((resolve) => setTimeout(resolve, 50)); + return { id: this.id }; + } + } + + const commands = [ + new ParallelCommand(mockConfig, mockLogger, false, mockOutputConfig, 'A'), + new ParallelCommand(mockConfig, mockLogger, false, mockOutputConfig, 'B'), + new ParallelCommand(mockConfig, mockLogger, false, mockOutputConfig, 'C') + ]; + + const results = await Promise.all(commands.map((command) => command.execute())); + + expect(results).toHaveLength(3); + expect(results.map((r) => r.id).sort()).toEqual(['A', 'B', 'C']); + + // Verify they started roughly at the same time (within 100ms) + const times = startTimes.map((s) => s.time); + const maxDiff = Math.max(...times) - Math.min(...times); + expect(maxDiff).toBeLessThan(100); + }); + + it('should handle command failure gracefully in pipelines', async () => { + const executionLog = []; + + class PipelineCommand extends Command { + constructor(config, logger, isProd, outputConfig, id, shouldFail = false) { + super(config, logger, isProd, outputConfig); + this.id = id; + this.shouldFail = shouldFail; + } + + async performExecute() { + executionLog.push(`${this.id}: started`); + + if (this.shouldFail) { + executionLog.push(`${this.id}: failed`); + throw new Error(`Command ${this.id} failed`); + } + + executionLog.push(`${this.id}: completed`); + return { id: this.id }; + } + } + + const commands = [ + new PipelineCommand(mockConfig, mockLogger, false, mockOutputConfig, 'step1'), + new PipelineCommand(mockConfig, mockLogger, false, mockOutputConfig, 'step2', true), // This fails + new PipelineCommand(mockConfig, mockLogger, false, mockOutputConfig, 'step3') + ]; + + // Execute sequentially with error handling + const results = []; + for (const command of commands) { + try { + const result = await command.execute(); + results.push(result); + } catch (error) { + results.push({ error: error.message }); + break; // Stop pipeline on error + } + } + + expect(results).toHaveLength(2); + expect(results[0].id).toBe('step1'); + expect(results[1].error).toContain('Command step2 failed'); + + expect(executionLog).toEqual([ + 'step1: started', + 'step1: completed', + 'step2: started', + 'step2: failed' + ]); + }); + }); +}); diff --git a/test/integration/coverage-enforcement.test.js b/test/integration/coverage-enforcement.test.js index 85068dc..24e9c96 100644 --- a/test/integration/coverage-enforcement.test.js +++ b/test/integration/coverage-enforcement.test.js @@ -6,15 +6,15 @@ * together correctly. */ -const { describe, it, expect, beforeEach, afterEach } = require('vitest'); -const MigrationOrchestrator = require('../../src/lib/migration/MigrationOrchestrator'); -const TestCoverageOrchestrator = require('../../src/lib/testing/TestCoverageOrchestrator'); -const TestRequirementAnalyzer = require('../../src/lib/testing/TestRequirementAnalyzer'); -const pgTAPTestScanner = require('../../src/lib/testing/pgTAPTestScanner'); -const TestTemplateGenerator = require('../../src/lib/testing/TestTemplateGenerator'); -const fs = require('fs').promises; -const path = require('path'); -const os = require('os'); +import { describe, it, expect, beforeEach, afterEach } from 'vitest'; +import MigrationOrchestrator from '../../src/lib/migration/MigrationOrchestrator.js'; +import TestCoverageOrchestrator from '../../src/lib/testing/TestCoverageOrchestrator.js'; +import TestRequirementAnalyzer from '../../src/lib/testing/TestRequirementAnalyzer.js'; +import pgTAPTestScanner from '../../src/lib/testing/pgTAPTestScanner.js'; +import TestTemplateGenerator from '../../src/lib/testing/TestTemplateGenerator.js'; +import fs from 'fs'.promises; +import path from 'path'; +import os from 'os'; describe('Test Coverage Enforcement - End-to-End Integration', () => { let tempDir; @@ -295,7 +295,7 @@ describe('Test Coverage Enforcement - End-to-End Integration', () => { describe('Coverage Key Generation with Fix', () => { it('should handle edge cases in coverage keys', async () => { - const enforcer = require('../../src/lib/testing/CoverageEnforcer'); + import enforcer from '../../src/lib/testing/CoverageEnforcer.js'; const instance = new enforcer(); // Test null schema normalization diff --git a/test/integration/di-container.test.js b/test/integration/di-container.test.js new file mode 100644 index 0000000..8deae7b --- /dev/null +++ b/test/integration/di-container.test.js @@ -0,0 +1,769 @@ +/** + * Integration tests for DI Container functionality + * + * Tests the complete dependency injection system including: + * - Service registration and resolution + * - Singleton lifecycle management + * - Circular dependency detection + * - Auto-wiring with parameter detection + * - Factory function support + * - Child container inheritance + * - Real-world integration patterns + */ + +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import { DIContainer } from '../../packages/data-core/ports/DIContainer.js'; +import { + FileSystemPort, + CryptoPort, + ProcessPort, + EnvironmentPort, + validatePort +} from '../../packages/data-core/ports/index.js'; + +// Mock implementations for testing +class MockFileSystemAdapter extends FileSystemPort { + constructor(config = {}) { + super(); + this.config = config; + this.readFileCallCount = 0; + } + + async readFile(path) { + this.readFileCallCount++; + return `mock content for ${path}`; + } + + async glob(patterns, cwd) { + return patterns.map((pattern) => `${cwd}/${pattern}`); + } +} + +class MockCryptoAdapter extends CryptoPort { + constructor(config = {}) { + super(); + this.config = config; + this.hashCallCount = 0; + } + + hash(data, algorithm = 'sha256') { + this.hashCallCount++; + return `mock_hash_${algorithm}_${data.slice(0, 10)}`; + } +} + +class MockProcessAdapter extends ProcessPort { + constructor(config = {}) { + super(); + this.config = config; + this.spawnCallCount = 0; + } + + async spawn(command, args = [], options = {}) { + this.spawnCallCount++; + return { + stdout: `mock output for ${command}`, + stderr: '', + exitCode: 0 + }; + } +} + +class MockEnvironmentAdapter extends EnvironmentPort { + constructor(config = {}) { + super(); + this.config = config; + this.env = new Map(); + } + + get(key, defaultValue) { + return this.env.get(key) || defaultValue; + } + + has(key) { + return this.env.has(key); + } + + set(key, value) { + this.env.set(key, value); + return true; + } +} + +// Test service classes +class SimpleService { + constructor() { + this.id = Math.random(); + } +} + +class ServiceWithDependencies { + constructor(fileSystem, crypto) { + this.fileSystem = fileSystem; + this.crypto = crypto; + this.id = Math.random(); + } +} + +class ServiceWithConfig { + constructor(config) { + this.config = config; + this.id = Math.random(); + } +} + +class ComplexService { + constructor(fileSystem, crypto, process, environment, config) { + this.fileSystem = fileSystem; + this.crypto = crypto; + this.process = process; + this.environment = environment; + this.config = config; + this.id = Math.random(); + } +} + +class CircularDependencyA { + constructor(serviceB) { + this.serviceB = serviceB; + } +} + +class CircularDependencyB { + constructor(serviceA) { + this.serviceA = serviceA; + } +} + +describe('DIContainer', () => { + let container; + + beforeEach(() => { + container = new DIContainer(); + }); + + afterEach(() => { + container.clear(); + }); + + describe('basic registration and resolution', () => { + it('should register and resolve simple services', () => { + container.register('simple', SimpleService); + + const instance = container.resolve('simple'); + + expect(instance).toBeInstanceOf(SimpleService); + expect(instance.id).toBeDefined(); + }); + + it('should create new instances for non-singleton services', () => { + container.register('simple', SimpleService); + + const instance1 = container.resolve('simple'); + const instance2 = container.resolve('simple'); + + expect(instance1).toBeInstanceOf(SimpleService); + expect(instance2).toBeInstanceOf(SimpleService); + expect(instance1.id).not.toBe(instance2.id); + }); + + it('should return same instance for singleton services', () => { + container.registerSingleton('simple', SimpleService); + + const instance1 = container.resolve('simple'); + const instance2 = container.resolve('simple'); + + expect(instance1).toBe(instance2); + expect(instance1.id).toBe(instance2.id); + }); + + it('should support explicit singleton registration', () => { + container.register('simple', SimpleService, { singleton: true }); + + const instance1 = container.resolve('simple'); + const instance2 = container.resolve('simple'); + + expect(instance1).toBe(instance2); + }); + }); + + describe('dependency injection', () => { + beforeEach(() => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('crypto', MockCryptoAdapter); + container.registerSingleton('process', MockProcessAdapter); + container.registerSingleton('environment', MockEnvironmentAdapter); + }); + + it('should inject dependencies automatically', () => { + container.register('serviceWithDeps', ServiceWithDependencies); + + const instance = container.resolve('serviceWithDeps'); + + expect(instance.fileSystem).toBeInstanceOf(MockFileSystemAdapter); + expect(instance.crypto).toBeInstanceOf(MockCryptoAdapter); + }); + + it('should inject complex dependency graphs', () => { + container.register('complex', ComplexService); + + const instance = container.resolve('complex'); + + expect(instance.fileSystem).toBeInstanceOf(MockFileSystemAdapter); + expect(instance.crypto).toBeInstanceOf(MockCryptoAdapter); + expect(instance.process).toBeInstanceOf(MockProcessAdapter); + expect(instance.environment).toBeInstanceOf(MockEnvironmentAdapter); + }); + + it('should support explicit dependency specification', () => { + container.register('explicit', ServiceWithDependencies, { + dependencies: ['crypto', 'fileSystem'] // Reversed order + }); + + const instance = container.resolve('explicit'); + + // First parameter should be crypto, second should be fileSystem + expect(instance.fileSystem).toBeInstanceOf(MockCryptoAdapter); + expect(instance.crypto).toBeInstanceOf(MockFileSystemAdapter); + }); + + it('should validate port implementations', () => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + + const fileSystem = container.resolve('fileSystem'); + + expect(() => validatePort(fileSystem, FileSystemPort)).not.toThrow(); + }); + + it('should pass configuration to constructors', () => { + const config = { debug: true, timeout: 5000 }; + container.register('withConfig', ServiceWithConfig, { + config + }); + + const instance = container.resolve('withConfig'); + + expect(instance.config).toBe(config); + }); + }); + + describe('factory functions', () => { + beforeEach(() => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('crypto', MockCryptoAdapter); + }); + + it('should support factory registration', () => { + container.registerFactory('customService', (container) => { + const fileSystem = container.resolve('fileSystem'); + const crypto = container.resolve('crypto'); + + return { + fileSystem, + crypto, + custom: 'factory created', + id: Math.random() + }; + }); + + const instance = container.resolve('customService'); + + expect(instance.custom).toBe('factory created'); + expect(instance.fileSystem).toBeInstanceOf(MockFileSystemAdapter); + expect(instance.crypto).toBeInstanceOf(MockCryptoAdapter); + }); + + it('should support singleton factories', () => { + container.registerFactory( + 'singletonFactory', + () => ({ + id: Math.random(), + type: 'singleton' + }), + { singleton: true } + ); + + const instance1 = container.resolve('singletonFactory'); + const instance2 = container.resolve('singletonFactory'); + + expect(instance1).toBe(instance2); + expect(instance1.id).toBe(instance2.id); + }); + + it('should handle factory errors gracefully', () => { + container.registerFactory('failingFactory', () => { + throw new Error('Factory failed'); + }); + + expect(() => container.resolve('failingFactory')).toThrow('Factory failed'); + }); + }); + + describe('instance registration', () => { + it('should register and resolve existing instances', () => { + const existingInstance = new SimpleService(); + + container.registerInstance('existing', existingInstance); + + const resolved = container.resolve('existing'); + expect(resolved).toBe(existingInstance); + }); + + it('should prioritize instances over constructors', () => { + const existingInstance = { type: 'existing' }; + + container.register('service', SimpleService); + container.registerInstance('service', existingInstance); + + const resolved = container.resolve('service'); + expect(resolved).toBe(existingInstance); + }); + }); + + describe('circular dependency detection', () => { + it('should detect direct circular dependencies', () => { + container.register('serviceA', CircularDependencyA, { + dependencies: ['serviceB'] + }); + container.register('serviceB', CircularDependencyB, { + dependencies: ['serviceA'] + }); + + expect(() => container.resolve('serviceA')).toThrow( + 'Circular dependency detected: serviceA -> serviceB -> serviceA' + ); + }); + + it('should detect indirect circular dependencies', () => { + class ServiceC { + constructor(serviceA) { + this.serviceA = serviceA; + } + } + + container.register('serviceA', CircularDependencyA, { + dependencies: ['serviceB'] + }); + container.register('serviceB', CircularDependencyB, { + dependencies: ['serviceC'] + }); + container.register('serviceC', ServiceC, { + dependencies: ['serviceA'] + }); + + expect(() => container.resolve('serviceA')).toThrow('Circular dependency detected:'); + }); + + it('should allow self-contained dependency trees', () => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('crypto', MockCryptoAdapter); + container.register('service', ServiceWithDependencies); + + expect(() => container.resolve('service')).not.toThrow(); + }); + }); + + describe('multiple service resolution', () => { + beforeEach(() => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('crypto', MockCryptoAdapter); + container.registerSingleton('process', MockProcessAdapter); + }); + + it('should resolve multiple services at once', () => { + const resolved = container.resolveMultiple(['fileSystem', 'crypto', 'process']); + + expect(resolved.fileSystem).toBeInstanceOf(MockFileSystemAdapter); + expect(resolved.crypto).toBeInstanceOf(MockCryptoAdapter); + expect(resolved.process).toBeInstanceOf(MockProcessAdapter); + }); + + it('should handle empty array', () => { + const resolved = container.resolveMultiple([]); + expect(resolved).toEqual({}); + }); + + it('should throw for invalid service in array', () => { + expect(() => container.resolveMultiple(['fileSystem', 'nonexistent'])).toThrow( + "Service 'nonexistent' not registered" + ); + }); + }); + + describe('auto-wiring', () => { + beforeEach(() => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('crypto', MockCryptoAdapter); + }); + + it('should auto-wire constructor dependencies', () => { + const instance = container.autoWire(ServiceWithDependencies); + + expect(instance).toBeInstanceOf(ServiceWithDependencies); + expect(instance.fileSystem).toBeInstanceOf(MockFileSystemAdapter); + expect(instance.crypto).toBeInstanceOf(MockCryptoAdapter); + }); + + it('should support manual overrides in auto-wiring', () => { + const customCrypto = new MockCryptoAdapter({ custom: true }); + + const instance = container.autoWire(ServiceWithDependencies, { + crypto: customCrypto + }); + + expect(instance.crypto).toBe(customCrypto); + expect(instance.fileSystem).toBeInstanceOf(MockFileSystemAdapter); + }); + + it('should handle constructors with no parameters', () => { + const instance = container.autoWire(SimpleService); + + expect(instance).toBeInstanceOf(SimpleService); + }); + + it('should throw for constructors requiring unregistered services', () => { + class ServiceWithUnknownDependency { + constructor(unknownService) { + this.unknownService = unknownService; + } + } + + expect(() => container.autoWire(ServiceWithUnknownDependency)).toThrow( + "Service 'unknownService' not registered" + ); + }); + }); + + describe('child containers', () => { + beforeEach(() => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('crypto', MockCryptoAdapter); + }); + + it('should create child containers with inherited services', () => { + const child = container.createChildContainer(); + + expect(child.has('fileSystem')).toBe(true); + expect(child.has('crypto')).toBe(true); + }); + + it('should allow child containers to override parent services', () => { + const child = container.createChildContainer(); + const customCrypto = new MockCryptoAdapter({ child: true }); + + child.registerInstance('crypto', customCrypto); + + const parentCrypto = container.resolve('crypto'); + const childCrypto = child.resolve('crypto'); + + expect(parentCrypto).not.toBe(customCrypto); + expect(childCrypto).toBe(customCrypto); + }); + + it('should allow child-specific service registration', () => { + const child = container.createChildContainer(); + + child.register('childOnly', SimpleService); + + expect(child.has('childOnly')).toBe(true); + expect(container.has('childOnly')).toBe(false); + }); + }); + + describe('container introspection and statistics', () => { + beforeEach(() => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.register('crypto', MockCryptoAdapter); + container.registerInstance('existing', { type: 'instance' }); + }); + + it('should provide container statistics', () => { + // Resolve one service to create singleton instance + container.resolve('fileSystem'); + + const stats = container.getStats(); + + expect(stats.totalServices).toBe(2); // fileSystem and crypto + expect(stats.singletonInstances).toBe(2); // fileSystem instance + existing instance + expect(stats.currentlyResolving).toBe(0); + expect(stats.services).toEqual(['crypto', 'fileSystem']); + expect(stats.singletons).toEqual(['existing', 'fileSystem']); + }); + + it('should check service existence correctly', () => { + expect(container.has('fileSystem')).toBe(true); + expect(container.has('crypto')).toBe(true); + expect(container.has('existing')).toBe(true); + expect(container.has('nonexistent')).toBe(false); + }); + + it('should track resolving services during resolution', async () => { + let resolvingDuringFactory = 0; + + container.registerFactory('trackingService', (container) => { + resolvingDuringFactory = container.getStats().currentlyResolving; + return { tracked: true }; + }); + + container.resolve('trackingService'); + + expect(resolvingDuringFactory).toBe(1); // trackingService was being resolved + }); + }); + + describe('error handling', () => { + it('should throw for invalid service names', () => { + expect(() => container.register('', SimpleService)).toThrow( + 'Service name must be a non-empty string' + ); + expect(() => container.register(null, SimpleService)).toThrow( + 'Service name must be a non-empty string' + ); + expect(() => container.register(123, SimpleService)).toThrow( + 'Service name must be a non-empty string' + ); + }); + + it('should throw for invalid constructors', () => { + expect(() => container.register('invalid', 'not a function')).toThrow( + 'Service constructor must be a function' + ); + expect(() => container.register('invalid', null)).toThrow( + 'Service constructor must be a function' + ); + }); + + it('should throw for unregistered services', () => { + expect(() => container.resolve('nonexistent')).toThrow( + "Service 'nonexistent' not registered" + ); + }); + + it('should throw for invalid resolution parameters', () => { + expect(() => container.resolve(123)).toThrow('Service name must be a string'); + expect(() => container.resolve(null)).toThrow('Service name must be a string'); + }); + + it('should throw for invalid factory functions', () => { + expect(() => container.registerFactory('invalid', 'not a function')).toThrow( + 'Factory must be a function' + ); + }); + + it('should throw for invalid auto-wire constructors', () => { + expect(() => container.autoWire('not a function')).toThrow('Constructor must be a function'); + }); + + it('should handle constructor errors gracefully', () => { + class FailingService { + constructor() { + throw new Error('Constructor failed'); + } + } + + container.register('failing', FailingService); + + expect(() => container.resolve('failing')).toThrow('Constructor failed'); + }); + }); + + describe('real-world integration patterns', () => { + it('should wire complete adapter ecosystem', () => { + // Register all adapters + container.registerSingleton('fileSystem', MockFileSystemAdapter, { + config: { encoding: 'utf8', mode: 0o644 } + }); + + container.registerSingleton('crypto', MockCryptoAdapter, { + config: { defaultAlgorithm: 'sha256' } + }); + + container.registerSingleton('process', MockProcessAdapter, { + config: { timeout: 30000 } + }); + + container.registerSingleton('environment', MockEnvironmentAdapter, { + config: { prefix: 'DATA_' } + }); + + // Register core services that depend on adapters + container.register('dataCore', ComplexService); + + const dataCore = container.resolve('dataCore'); + + // Verify all adapters are correctly injected + expect(dataCore.fileSystem).toBeInstanceOf(MockFileSystemAdapter); + expect(dataCore.crypto).toBeInstanceOf(MockCryptoAdapter); + expect(dataCore.process).toBeInstanceOf(MockProcessAdapter); + expect(dataCore.environment).toBeInstanceOf(MockEnvironmentAdapter); + + // Verify configuration was passed + expect(dataCore.fileSystem.config.encoding).toBe('utf8'); + expect(dataCore.crypto.config.defaultAlgorithm).toBe('sha256'); + }); + + it('should support complex factory patterns', () => { + container.registerSingleton('environment', MockEnvironmentAdapter); + + // Factory that creates different instances based on environment + container.registerFactory('configuredService', (container) => { + const env = container.resolve('environment'); + env.set('NODE_ENV', 'test'); + + const isTest = env.get('NODE_ENV') === 'test'; + + if (isTest) { + return new MockFileSystemAdapter({ test: true }); + } else { + return new MockFileSystemAdapter({ production: true }); + } + }); + + const service = container.resolve('configuredService'); + + expect(service).toBeInstanceOf(MockFileSystemAdapter); + expect(service.config.test).toBe(true); + }); + + it('should handle testing scenarios with mocks', () => { + // Production services + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('crypto', MockCryptoAdapter); + + // Service under test + container.register('serviceUnderTest', ServiceWithDependencies); + + // Test scenario with spy + const fileSystemSpy = vi.fn(); + const mockFileSystem = { + ...new MockFileSystemAdapter(), + readFile: fileSystemSpy + }; + + // Override with test double + container.registerInstance('fileSystem', mockFileSystem); + + const service = container.resolve('serviceUnderTest'); + + // Use the service (would normally be done in actual test) + expect(service.fileSystem).toBe(mockFileSystem); + expect(typeof service.fileSystem.readFile).toBe('function'); + }); + + it('should demonstrate performance characteristics', () => { + // Register many services + for (let i = 0; i < 100; i++) { + container.register(`service${i}`, SimpleService); + } + + const startTime = Date.now(); + + // Resolve all services + const resolvedServices = []; + for (let i = 0; i < 100; i++) { + resolvedServices.push(container.resolve(`service${i}`)); + } + + const duration = Date.now() - startTime; + + expect(resolvedServices).toHaveLength(100); + expect(duration).toBeLessThan(1000); // Should be fast + + // All should be different instances (non-singleton) + const ids = resolvedServices.map((s) => s.id); + const uniqueIds = new Set(ids); + expect(uniqueIds.size).toBe(100); + }); + + it('should support configuration-driven service registration', () => { + const serviceConfig = { + services: [ + { + name: 'fileSystem', + constructor: MockFileSystemAdapter, + singleton: true, + config: { timeout: 5000 } + }, + { + name: 'crypto', + constructor: MockCryptoAdapter, + singleton: true, + config: { algorithm: 'sha512' } + }, + { + name: 'mainService', + constructor: ServiceWithDependencies, + dependencies: ['fileSystem', 'crypto'] + } + ] + }; + + // Register services from configuration + serviceConfig.services.forEach((service) => { + container.register(service.name, service.constructor, { + singleton: service.singleton, + dependencies: service.dependencies, + config: service.config + }); + }); + + const mainService = container.resolve('mainService'); + + expect(mainService).toBeInstanceOf(ServiceWithDependencies); + expect(mainService.fileSystem.config.timeout).toBe(5000); + expect(mainService.crypto.config.algorithm).toBe('sha512'); + }); + }); + + describe('cleanup and lifecycle', () => { + it('should clear all services and instances', () => { + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.register('service', SimpleService); + container.registerInstance('instance', { test: true }); + + // Resolve to create singleton + container.resolve('fileSystem'); + + expect(container.getStats().totalServices).toBe(2); + expect(container.getStats().singletonInstances).toBe(2); + + container.clear(); + + const stats = container.getStats(); + expect(stats.totalServices).toBe(0); + expect(stats.singletonInstances).toBe(0); + expect(stats.currentlyResolving).toBe(0); + }); + + it('should handle concurrent resolution correctly', async () => { + let constructorCallCount = 0; + + class ConcurrentService { + constructor(fileSystem) { + constructorCallCount++; + this.fileSystem = fileSystem; + this.id = Math.random(); + } + } + + container.registerSingleton('fileSystem', MockFileSystemAdapter); + container.registerSingleton('concurrent', ConcurrentService); + + // Resolve concurrently + const promises = Array.from({ length: 10 }, () => + Promise.resolve(container.resolve('concurrent')) + ); + + const instances = await Promise.all(promises); + + // All should be the same instance (singleton) + const firstInstance = instances[0]; + instances.forEach((instance) => { + expect(instance).toBe(firstInstance); + }); + + // Constructor should only be called once + expect(constructorCallCount).toBe(1); + }); + }); +}); diff --git a/test/integration/full-workflow.test.js b/test/integration/full-workflow.test.js index 4cd75c1..6b890c2 100644 --- a/test/integration/full-workflow.test.js +++ b/test/integration/full-workflow.test.js @@ -5,11 +5,11 @@ * through migration generation, testing, and deployment with diff tracking. */ -const { describe, it, expect, beforeEach, afterEach } = require('vitest'); -const fs = require('fs').promises; -const path = require('path'); -const { exec } = require('child_process'); -const { promisify } = require('util'); +import { describe, it, expect, beforeEach, afterEach } from 'vitest'; +import fs from 'fs'.promises; +import path from 'path'; +import { exec } from 'child_process'; +import { promisify } from 'util'; const execAsync = promisify(exec); describe('D.A.T.A. Full Migration Workflow', () => { diff --git a/test/manual-scripts/simple-test.js b/test/manual-scripts/simple-test.js index 100f827..854e31d 100644 --- a/test/manual-scripts/simple-test.js +++ b/test/manual-scripts/simple-test.js @@ -1,23 +1,22 @@ -const path = require('path'); +import path from 'path'; // Test basic functionality try { console.log('Loading scanner...'); - const pgTAPTestScanner = require('./src/lib/testing/pgTAPTestScanner.js'); - + import pgTAPTestScanner from './src/lib/testing/pgTAPTestScanner.js'; + console.log('Creating scanner instance...'); const scanner = new pgTAPTestScanner({ validatePlans: false }); - + console.log('Testing has_function with parameters...'); const sql = "SELECT has_function('user_count', ARRAY['integer', 'text']);"; const assertions = scanner.extractAssertions(sql); - + console.log('Raw parameters:', assertions[0].parameters); console.log('Function metadata:', JSON.stringify(assertions[0].functionMetadata, null, 2)); - + console.log('โœ… Test completed successfully'); - } catch (error) { console.error('โŒ Error:', error.message); console.error('Stack:', error.stack); -} \ No newline at end of file +} diff --git a/test/manual-scripts/test-function-parsing.js b/test/manual-scripts/test-function-parsing.js index 9e985e3..ba13e7d 100755 --- a/test/manual-scripts/test-function-parsing.js +++ b/test/manual-scripts/test-function-parsing.js @@ -3,7 +3,7 @@ * Simple test script to verify function parsing works correctly */ -const pgTAPTestScanner = require('./src/lib/testing/pgTAPTestScanner.js'); +import pgTAPTestScanner from './src/lib/testing/pgTAPTestScanner.js'; function runTest(name, testFn) { try { @@ -17,7 +17,9 @@ function runTest(name, testFn) { function assertEquals(actual, expected, message) { if (JSON.stringify(actual) !== JSON.stringify(expected)) { - throw new Error(`${message}\n Expected: ${JSON.stringify(expected)}\n Actual: ${JSON.stringify(actual)}`); + throw new Error( + `${message}\n Expected: ${JSON.stringify(expected)}\n Actual: ${JSON.stringify(actual)}` + ); } } @@ -27,7 +29,7 @@ const scanner = new pgTAPTestScanner({ validatePlans: false }); runTest('has_function with function name only', () => { const sql = "SELECT has_function('user_count');"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'has_function', 'Should be has_function type'); assertEquals(assertions[0].target, 'user_count', 'Should have correct target'); @@ -38,7 +40,7 @@ runTest('has_function with function name only', () => { runTest('has_function with schema and function name', () => { const sql = "SELECT has_function('public', 'user_count');"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'has_function', 'Should be has_function type'); assertEquals(assertions[0].target, 'public.user_count', 'Should have correct target'); @@ -50,22 +52,26 @@ runTest('has_function with schema and function name', () => { runTest('has_function with parameters', () => { const sql = "SELECT has_function('user_count', ARRAY['integer', 'text']);"; const assertions = scanner.extractAssertions(sql); - + console.log('DEBUG - Parameters:', assertions[0].parameters); console.log('DEBUG - Function metadata:', assertions[0].functionMetadata); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'has_function', 'Should be has_function type'); assertEquals(assertions[0].target, 'user_count', 'Should have correct target'); assertEquals(assertions[0].functionMetadata.name, 'user_count', 'Should extract function name'); - assertEquals(assertions[0].functionMetadata.parameters, ['integer', 'text'], 'Should extract parameters'); + assertEquals( + assertions[0].functionMetadata.parameters, + ['integer', 'text'], + 'Should extract parameters' + ); }); // Test function_returns runTest('function_returns parsing', () => { const sql = "SELECT function_returns('user_count', 'integer');"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'function_returns', 'Should be function_returns type'); assertEquals(assertions[0].target, 'user_count', 'Should have correct target'); @@ -77,7 +83,7 @@ runTest('function_returns parsing', () => { runTest('function_lang_is parsing', () => { const sql = "SELECT function_lang_is('user_count', 'plpgsql');"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'function_lang_is', 'Should be function_lang_is type'); assertEquals(assertions[0].target, 'user_count', 'Should have correct target'); @@ -89,23 +95,35 @@ runTest('function_lang_is parsing', () => { runTest('is_definer parsing', () => { const sql = "SELECT is_definer('secure_function');"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'is_definer', 'Should be is_definer type'); assertEquals(assertions[0].target, 'secure_function', 'Should have correct target'); - assertEquals(assertions[0].functionMetadata.name, 'secure_function', 'Should extract function name'); - assertEquals(assertions[0].functionMetadata.isSecurityDefiner, true, 'Should mark as security definer'); + assertEquals( + assertions[0].functionMetadata.name, + 'secure_function', + 'Should extract function name' + ); + assertEquals( + assertions[0].functionMetadata.isSecurityDefiner, + true, + 'Should mark as security definer' + ); }); // Test volatility_is runTest('volatility_is parsing', () => { const sql = "SELECT volatility_is('pure_function', 'immutable');"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'volatility_is', 'Should be volatility_is type'); assertEquals(assertions[0].target, 'pure_function', 'Should have correct target'); - assertEquals(assertions[0].functionMetadata.name, 'pure_function', 'Should extract function name'); + assertEquals( + assertions[0].functionMetadata.name, + 'pure_function', + 'Should extract function name' + ); assertEquals(assertions[0].functionMetadata.volatility, 'immutable', 'Should extract volatility'); }); @@ -113,7 +131,7 @@ runTest('volatility_is parsing', () => { runTest('function_privs_are parsing', () => { const sql = "SELECT function_privs_are('calc_func', 'app_user', ARRAY['EXECUTE']);"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'function_privs_are', 'Should be function_privs_are type'); assertEquals(assertions[0].target, 'calc_func', 'Should have correct target'); @@ -124,16 +142,21 @@ runTest('function_privs_are parsing', () => { // Test complex function example runTest('complex function parsing', () => { - const sql = "SELECT function_returns('public', 'complex_func', ARRAY['text', 'integer'], 'boolean');"; + const sql = + "SELECT function_returns('public', 'complex_func', ARRAY['text', 'integer'], 'boolean');"; const assertions = scanner.extractAssertions(sql); - + assertEquals(assertions.length, 1, 'Should have 1 assertion'); assertEquals(assertions[0].type, 'function_returns', 'Should be function_returns type'); assertEquals(assertions[0].target, 'public.complex_func', 'Should have correct target'); assertEquals(assertions[0].functionMetadata.schema, 'public', 'Should extract schema'); assertEquals(assertions[0].functionMetadata.name, 'complex_func', 'Should extract function name'); - assertEquals(assertions[0].functionMetadata.parameters, ['text', 'integer'], 'Should extract parameters'); + assertEquals( + assertions[0].functionMetadata.parameters, + ['text', 'integer'], + 'Should extract parameters' + ); assertEquals(assertions[0].functionMetadata.returnType, 'boolean', 'Should extract return type'); }); -console.log('\n๐ŸŽฏ Function parsing tests completed!'); \ No newline at end of file +console.log('\n๐ŸŽฏ Function parsing tests completed!'); diff --git a/test/manual-scripts/test-memory-management.js b/test/manual-scripts/test-memory-management.js index 8509493..2a6f92e 100644 --- a/test/manual-scripts/test-memory-management.js +++ b/test/manual-scripts/test-memory-management.js @@ -26,7 +26,9 @@ async function testMemoryManagement() { // Listen for memory events scanner.on('memory_status', (data) => { - console.log(`๐Ÿ“Š Memory Status: ${data.current}MB (max: ${data.max}MB, streaming: ${data.streamingMode})`); + console.log( + `๐Ÿ“Š Memory Status: ${data.current}MB (max: ${data.max}MB, streaming: ${data.streamingMode})` + ); }); scanner.on('cleanup', (data) => { @@ -39,7 +41,9 @@ async function testMemoryManagement() { scanner.on('progress', (data) => { if (data.type === 'batch_progress') { - console.log(`โšก Progress: Batch ${data.batch}/${data.totalBatches} (${data.filesProcessed}/${data.totalFiles} files)`); + console.log( + `โšก Progress: Batch ${data.batch}/${data.totalBatches} (${data.filesProcessed}/${data.totalFiles} files)` + ); } }); @@ -47,20 +51,20 @@ async function testMemoryManagement() { // Test memory stats console.log('Initial memory stats:'); console.log(JSON.stringify(scanner.getMemoryStats(), null, 2)); - + // Simulate scanning some test files (you can point this to actual test directory) const testDir = path.join(__dirname, 'test/fixtures'); // Adjust path as needed - + console.log(`\nScanning directory: ${testDir}`); - + if (await scanner.scanDirectory(testDir).catch(() => null)) { // Build coverage database with memory management console.log('\nBuilding coverage database...'); const database = await scanner.buildCoverageDatabase(); - + console.log('\nFinal memory stats:'); console.log(JSON.stringify(scanner.getMemoryStats(), null, 2)); - + console.log('\nDatabase summary:'); console.log(`- Total objects indexed: ${scanner._getTotalIndexedObjects(database)}`); console.log(`- Total assertions: ${database.assertionCounts.total}`); @@ -69,33 +73,35 @@ async function testMemoryManagement() { } else { // Test with mock data if no test directory exists console.log('No test directory found, testing with mock data...'); - + // Create some mock test files for (let i = 0; i < 150; i++) { scanner.testFiles.push({ filePath: `/mock/test_${i}.sql`, fileName: `test_${i}.sql`, - assertions: Array(10).fill(null).map((_, j) => ({ - type: 'has_table', - target: `table_${i}_${j}`, - parameters: [`table_${i}_${j}`], - lineNumber: j + 1, - rawSql: `SELECT has_table('table_${i}_${j}');` - })), + assertions: Array(10) + .fill(null) + .map((_, j) => ({ + type: 'has_table', + target: `table_${i}_${j}`, + parameters: [`table_${i}_${j}`], + lineNumber: j + 1, + rawSql: `SELECT has_table('table_${i}_${j}');` + })), planCount: 1, dependencies: [], metadata: {} }); } - + scanner.totalAssertions = 150 * 10; - + console.log('Building coverage database with 150 mock files...'); const database = await scanner.buildCoverageDatabase(); - + console.log('\nFinal memory stats:'); console.log(JSON.stringify(scanner.getMemoryStats(), null, 2)); - + console.log('\nDatabase summary:'); console.log(`- Total objects indexed: ${scanner._getTotalIndexedObjects(database)}`); console.log(`- Total assertions: ${database.assertionCounts.total}`); @@ -104,7 +110,6 @@ async function testMemoryManagement() { } console.log('\nโœ… Memory management test completed successfully!'); - } catch (error) { console.error('โŒ Test failed:', error.message); console.error(error.stack); @@ -115,4 +120,4 @@ async function testMemoryManagement() { } // Run the test -testMemoryManagement().catch(console.error); \ No newline at end of file +testMemoryManagement().catch(console.error); diff --git a/test/manual-scripts/test_trigger_final.js b/test/manual-scripts/test_trigger_final.js index f416196..3c623e2 100644 --- a/test/manual-scripts/test_trigger_final.js +++ b/test/manual-scripts/test_trigger_final.js @@ -1,6 +1,6 @@ #!/usr/bin/env node -const pgTAPTestScanner = require('./src/lib/testing/pgTAPTestScanner.js'); +import pgTAPTestScanner from './src/lib/testing/pgTAPTestScanner.js'; console.log('โœ… Testing trigger assertion parsing functionality...\n'); @@ -58,11 +58,14 @@ let failed = 0; testCases.forEach((testCase, index) => { try { const assertions = scanner.extractAssertions(testCase.sql); - + if (assertions.length === 1) { const assertion = assertions[0]; - - if (assertion.type === testCase.expectedType && assertion.target === testCase.expectedTarget) { + + if ( + assertion.type === testCase.expectedType && + assertion.target === testCase.expectedTarget + ) { console.log(`โœ… Test ${index + 1}: ${testCase.name} - PASSED`); console.log(` Target: ${assertion.target}`); console.log(` Type: ${assertion.type}`); @@ -89,23 +92,29 @@ console.log(`\n๐Ÿ“Š Test Results: ${passed} passed, ${failed} failed`); // Test coverage map integration console.log('\n๐Ÿ—บ๏ธ Testing coverage map integration...'); -const combinedSql = testCases.map(tc => tc.sql).join('\n'); +const combinedSql = testCases.map((tc) => tc.sql).join('\n'); const allAssertions = scanner.extractAssertions(combinedSql); -scanner.testFiles = [{ - filePath: '/test/triggers.sql', - fileName: 'triggers.sql', - assertions: allAssertions, - planCount: allAssertions.length, - dependencies: [], - metadata: { size: combinedSql.length, lines: combinedSql.split('\n').length, parsed: new Date() } -}]; +scanner.testFiles = [ + { + filePath: '/test/triggers.sql', + fileName: 'triggers.sql', + assertions: allAssertions, + planCount: allAssertions.length, + dependencies: [], + metadata: { + size: combinedSql.length, + lines: combinedSql.split('\n').length, + parsed: new Date() + } + } +]; scanner._buildCoverageMap(); const coverageMap = scanner.getCoverageMap(); console.log(`Found ${Object.keys(coverageMap.triggers || {}).length} triggers in coverage map:`); -Object.keys(coverageMap.triggers || {}).forEach(trigger => { +Object.keys(coverageMap.triggers || {}).forEach((trigger) => { const tests = coverageMap.triggers[trigger]; console.log(` - ${trigger}: [${tests.join(', ')}]`); }); @@ -118,4 +127,4 @@ if (failed === 0) { } else { console.log(`\nโš ๏ธ ${failed} tests failed. Please review the implementation.`); process.exit(1); -} \ No newline at end of file +} diff --git a/test/pgTAPTestScanner.column.test.js b/test/pgTAPTestScanner.column.test.js index 4efc1fc..1ceebd9 100644 --- a/test/pgTAPTestScanner.column.test.js +++ b/test/pgTAPTestScanner.column.test.js @@ -1,6 +1,6 @@ /** * pgTAPTestScanner Column Assertion Parsing Tests - * + * * Tests the column assertion parsing capabilities of pgTAPTestScanner */ @@ -18,7 +18,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse has_column with table and column', () => { const sql = "SELECT has_column('users', 'email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_column'); expect(assertions[0].target).toBe('users.email'); @@ -28,7 +28,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse has_column with schema, table, and column', () => { const sql = "SELECT has_column('public', 'users', 'email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_column'); expect(assertions[0].target).toBe('public.users.email'); @@ -38,7 +38,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse hasnt_column with table and column', () => { const sql = "SELECT hasnt_column('users', 'old_field');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('hasnt_column'); expect(assertions[0].target).toBe('users.old_field'); @@ -48,7 +48,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse hasnt_column with schema, table, and column', () => { const sql = "SELECT hasnt_column('private', 'sessions', 'deprecated_field');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('hasnt_column'); expect(assertions[0].target).toBe('private.sessions.deprecated_field'); @@ -60,7 +60,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_type_is with table, column, and type', () => { const sql = "SELECT col_type_is('users', 'email', 'character varying');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_type_is'); expect(assertions[0].target).toBe('users.email'); @@ -70,7 +70,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_type_is with schema, table, column, and type', () => { const sql = "SELECT col_type_is('public', 'users', 'age', 'integer');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_type_is'); expect(assertions[0].target).toBe('public.users.age'); @@ -82,7 +82,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_not_null with table and column', () => { const sql = "SELECT col_not_null('users', 'email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_not_null'); expect(assertions[0].target).toBe('users.email'); @@ -92,7 +92,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_not_null with schema, table, and column', () => { const sql = "SELECT col_not_null('public', 'users', 'email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_not_null'); expect(assertions[0].target).toBe('public.users.email'); @@ -102,7 +102,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_is_null with table and column', () => { const sql = "SELECT col_is_null('users', 'description');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_is_null'); expect(assertions[0].target).toBe('users.description'); @@ -112,7 +112,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_is_null with schema, table, and column', () => { const sql = "SELECT col_is_null('public', 'users', 'description');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_is_null'); expect(assertions[0].target).toBe('public.users.description'); @@ -124,7 +124,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_has_default with table and column', () => { const sql = "SELECT col_has_default('users', 'status');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_has_default'); expect(assertions[0].target).toBe('users.status'); @@ -134,7 +134,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_has_default with schema, table, and column', () => { const sql = "SELECT col_has_default('public', 'users', 'status');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_has_default'); expect(assertions[0].target).toBe('public.users.status'); @@ -144,7 +144,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_hasnt_default with table and column', () => { const sql = "SELECT col_hasnt_default('users', 'temp_field');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_hasnt_default'); expect(assertions[0].target).toBe('users.temp_field'); @@ -154,7 +154,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_hasnt_default with schema, table, and column', () => { const sql = "SELECT col_hasnt_default('public', 'users', 'temp_field');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_hasnt_default'); expect(assertions[0].target).toBe('public.users.temp_field'); @@ -166,7 +166,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_default_is with table, column, and default value', () => { const sql = "SELECT col_default_is('users', 'status', 'active');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_default_is'); expect(assertions[0].target).toBe('users.status'); @@ -176,7 +176,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_default_is with schema, table, column, and default value', () => { const sql = "SELECT col_default_is('public', 'users', 'status', 'pending');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_default_is'); expect(assertions[0].target).toBe('public.users.status'); @@ -186,7 +186,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_default_is with quoted string default values', () => { const sql = "SELECT col_default_is('users', 'email', ''user@example.com''::text);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_default_is'); expect(assertions[0].target).toBe('users.email'); @@ -196,7 +196,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_default_is with function default values', () => { const sql = "SELECT col_default_is('users', 'created_at', 'now()');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_default_is'); expect(assertions[0].target).toBe('users.created_at'); @@ -208,7 +208,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_is_pk with table and column', () => { const sql = "SELECT col_is_pk('users', 'id');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_is_pk'); expect(assertions[0].target).toBe('users.id'); @@ -218,7 +218,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_is_pk with schema, table, and column', () => { const sql = "SELECT col_is_pk('public', 'users', 'id');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_is_pk'); expect(assertions[0].target).toBe('public.users.id'); @@ -228,7 +228,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_isnt_pk with table and column', () => { const sql = "SELECT col_isnt_pk('users', 'email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_isnt_pk'); expect(assertions[0].target).toBe('users.email'); @@ -238,7 +238,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should parse col_isnt_pk with schema, table, and column', () => { const sql = "SELECT col_isnt_pk('public', 'users', 'email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_isnt_pk'); expect(assertions[0].target).toBe('public.users.email'); @@ -255,27 +255,29 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { SELECT col_has_default('users', 'status'); SELECT col_is_pk('users', 'id'); `; - + const assertions = scanner.extractAssertions(sql); - + // Manually build coverage map for testing - scanner.testFiles = [{ - filePath: '/test/column_test.sql', - fileName: 'column_test.sql', - assertions, - planCount: 5, - dependencies: [], - metadata: {} - }]; - + scanner.testFiles = [ + { + filePath: '/test/column_test.sql', + fileName: 'column_test.sql', + assertions, + planCount: 5, + dependencies: [], + metadata: {} + } + ]; + scanner._buildCoverageMap(); const coverageMap = scanner.getCoverageMap(); - + expect(coverageMap.columns).toBeDefined(); expect(Object.keys(coverageMap.columns)).toContain('users.email'); expect(Object.keys(coverageMap.columns)).toContain('users.status'); expect(Object.keys(coverageMap.columns)).toContain('users.id'); - + expect(coverageMap.columns['users.email']).toContain('has_column'); expect(coverageMap.columns['users.email']).toContain('col_type_is'); expect(coverageMap.columns['users.email']).toContain('col_not_null'); @@ -289,21 +291,23 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { SELECT has_column('posts', 'title'); SELECT col_is_pk('orders', 'id'); `; - - const assertions = scanner.extractAssertions(sql); - - scanner.testFiles = [{ - filePath: '/test/column_test.sql', - fileName: 'column_test.sql', - assertions, - planCount: 3, - dependencies: [], - metadata: {} - }]; - + + const assertions = scanner.extractAssertions(sql); + + scanner.testFiles = [ + { + filePath: '/test/column_test.sql', + fileName: 'column_test.sql', + assertions, + planCount: 3, + dependencies: [], + metadata: {} + } + ]; + scanner._buildCoverageMap(); const stats = scanner.getStatistics(); - + expect(stats.coverageStats.columnsWithTests).toBe(3); // 'users.email', 'posts.title', 'orders.id' }); }); @@ -319,18 +323,18 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { SELECT has_index('users', 'idx_users_email'); SELECT col_is_pk('users', 'id'); `; - + const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(6); // Excludes the plan statement - - const columnAssertions = assertions.filter(a => - a.type.includes('column') || a.type.startsWith('col_') + + const columnAssertions = assertions.filter( + (a) => a.type.includes('column') || a.type.startsWith('col_') ); expect(columnAssertions).toHaveLength(4); - - const otherAssertions = assertions.filter(a => - !a.type.includes('column') && !a.type.startsWith('col_') + + const otherAssertions = assertions.filter( + (a) => !a.type.includes('column') && !a.type.startsWith('col_') ); expect(otherAssertions).toHaveLength(2); }); @@ -346,14 +350,14 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { ); SELECT col_not_null('users','email'); `; - + const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(3); expect(assertions[0].type).toBe('has_column'); expect(assertions[1].type).toBe('col_type_is'); expect(assertions[2].type).toBe('col_not_null'); - + expect(assertions[0].target).toBe('users.email'); expect(assertions[1].target).toBe('public.users.description'); expect(assertions[2].target).toBe('users.email'); @@ -372,12 +376,12 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { SELECT col_is_pk('users', 'id'); SELECT col_isnt_pk('users', 'email'); `; - + const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(10); - - const assertionTypes = assertions.map(a => a.type); + + const assertionTypes = assertions.map((a) => a.type); expect(assertionTypes).toContain('has_column'); expect(assertionTypes).toContain('hasnt_column'); expect(assertionTypes).toContain('col_type_is'); @@ -388,10 +392,10 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { expect(assertionTypes).toContain('col_default_is'); expect(assertionTypes).toContain('col_is_pk'); expect(assertionTypes).toContain('col_isnt_pk'); - + // All should be categorized as column assertions - const columnAssertions = assertions.filter(a => - a.type.includes('column') || a.type.startsWith('col_') + const columnAssertions = assertions.filter( + (a) => a.type.includes('column') || a.type.startsWith('col_') ); expect(columnAssertions).toHaveLength(10); }); @@ -401,7 +405,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should handle quoted column names', () => { const sql = 'SELECT has_column("users", "user-email");'; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_column'); expect(assertions[0].target).toBe('users.user-email'); @@ -411,7 +415,7 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should handle backtick quoted column names', () => { const sql = 'SELECT has_column(`users`, `user_email`);'; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_column'); expect(assertions[0].target).toBe('users.user_email'); @@ -419,19 +423,24 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { }); it('should handle complex default values in col_default_is', () => { - const sql = "SELECT col_default_is('users', 'settings', '{\"theme\": \"dark\", \"notifications\": true}');"; + const sql = + 'SELECT col_default_is(\'users\', \'settings\', \'{"theme": "dark", "notifications": true}\');'; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_default_is'); expect(assertions[0].target).toBe('users.settings'); - expect(assertions[0].parameters).toEqual(['users', 'settings', '{"theme": "dark", "notifications": true}']); + expect(assertions[0].parameters).toEqual([ + 'users', + 'settings', + '{"theme": "dark", "notifications": true}' + ]); }); it('should handle numeric default values', () => { const sql = "SELECT col_default_is('users', 'score', 0);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_default_is'); expect(assertions[0].target).toBe('users.score'); @@ -441,11 +450,11 @@ describe('pgTAPTestScanner Column Assertion Parsing', () => { it('should handle boolean default values', () => { const sql = "SELECT col_default_is('users', 'is_active', true);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('col_default_is'); expect(assertions[0].target).toBe('users.is_active'); expect(assertions[0].parameters).toEqual(['users', 'is_active', 'true']); }); }); -}); \ No newline at end of file +}); diff --git a/test/pgTAPTestScanner.fileDiscovery.test.js b/test/pgTAPTestScanner.fileDiscovery.test.js index 4a6397e..9f4e552 100644 --- a/test/pgTAPTestScanner.fileDiscovery.test.js +++ b/test/pgTAPTestScanner.fileDiscovery.test.js @@ -1,6 +1,6 @@ /** * pgTAPTestScanner File Discovery Tests - * + * * Tests the file discovery capabilities of pgTAPTestScanner */ @@ -30,31 +30,31 @@ describe('pgTAPTestScanner File Discovery', () => { describe('Basic file discovery', () => { it('should find SQL test files in directory', async () => { // Create test files - await writeFile(join(tempDir, 'test1.sql'), 'SELECT has_table(\'users\');'); - await writeFile(join(tempDir, 'test2.sql'), 'SELECT has_column(\'users\', \'id\');'); + await writeFile(join(tempDir, 'test1.sql'), "SELECT has_table('users');"); + await writeFile(join(tempDir, 'test2.sql'), "SELECT has_column('users', 'id');"); await writeFile(join(tempDir, 'nottest.txt'), 'This is not a SQL file'); const testFiles = await scanner.scanDirectory(tempDir); expect(testFiles).toHaveLength(2); - expect(testFiles.map(f => f.fileName)).toContain('test1.sql'); - expect(testFiles.map(f => f.fileName)).toContain('test2.sql'); - expect(testFiles.map(f => f.fileName)).not.toContain('nottest.txt'); + expect(testFiles.map((f) => f.fileName)).toContain('test1.sql'); + expect(testFiles.map((f) => f.fileName)).toContain('test2.sql'); + expect(testFiles.map((f) => f.fileName)).not.toContain('nottest.txt'); }); it('should find test files recursively', async () => { // Create nested directory structure const subDir = join(tempDir, 'subdirectory'); await mkdir(subDir); - - await writeFile(join(tempDir, 'root.sql'), 'SELECT has_table(\'root\');'); - await writeFile(join(subDir, 'nested.sql'), 'SELECT has_table(\'nested\');'); + + await writeFile(join(tempDir, 'root.sql'), "SELECT has_table('root');"); + await writeFile(join(subDir, 'nested.sql'), "SELECT has_table('nested');"); const testFiles = await scanner.scanDirectory(tempDir); expect(testFiles).toHaveLength(2); - expect(testFiles.map(f => f.fileName)).toContain('root.sql'); - expect(testFiles.map(f => f.fileName)).toContain('nested.sql'); + expect(testFiles.map((f) => f.fileName)).toContain('root.sql'); + expect(testFiles.map((f) => f.fileName)).toContain('nested.sql'); }); it('should handle empty directory', async () => { @@ -77,20 +77,24 @@ describe('pgTAPTestScanner File Discovery', () => { fileExtensions: ['.sql', '.test.sql', '.pgtap'] }); - await writeFile(join(tempDir, 'test1.sql'), 'SELECT has_table(\'test1\');'); - await writeFile(join(tempDir, 'test2.test.sql'), 'SELECT has_table(\'test2\');'); - await writeFile(join(tempDir, 'test3.pgtap'), 'SELECT has_table(\'test3\');'); - await writeFile(join(tempDir, 'test4.txt'), 'SELECT has_table(\'test4\');'); + await writeFile(join(tempDir, 'test1.sql'), "SELECT has_table('test1');"); + await writeFile(join(tempDir, 'test2.test.sql'), "SELECT has_table('test2');"); + await writeFile(join(tempDir, 'test3.pgtap'), "SELECT has_table('test3');"); + await writeFile(join(tempDir, 'test4.txt'), "SELECT has_table('test4');"); const testFiles = await customScanner.scanDirectory(tempDir); expect(testFiles).toHaveLength(3); - expect(testFiles.map(f => f.fileName).sort()).toEqual(['test1.sql', 'test2.test.sql', 'test3.pgtap']); + expect(testFiles.map((f) => f.fileName).sort()).toEqual([ + 'test1.sql', + 'test2.test.sql', + 'test3.pgtap' + ]); }); it('should filter files by extension correctly', async () => { - await writeFile(join(tempDir, 'test.sql'), 'SELECT has_table(\'users\');'); - await writeFile(join(tempDir, 'test.sql.backup'), 'SELECT has_table(\'backup\');'); + await writeFile(join(tempDir, 'test.sql'), "SELECT has_table('users');"); + await writeFile(join(tempDir, 'test.sql.backup'), "SELECT has_table('backup');"); await writeFile(join(tempDir, 'test.txt'), 'Not a SQL file'); const testFiles = await scanner.scanDirectory(tempDir); @@ -109,9 +113,9 @@ describe('pgTAPTestScanner File Discovery', () => { const backupDir = join(tempDir, 'backup'); await mkdir(backupDir); - await writeFile(join(tempDir, 'test1.sql'), 'SELECT has_table(\'test1\');'); - await writeFile(join(tempDir, 'test2.temp.sql'), 'SELECT has_table(\'test2\');'); - await writeFile(join(backupDir, 'old.sql'), 'SELECT has_table(\'old\');'); + await writeFile(join(tempDir, 'test1.sql'), "SELECT has_table('test1');"); + await writeFile(join(tempDir, 'test2.temp.sql'), "SELECT has_table('test2');"); + await writeFile(join(backupDir, 'old.sql'), "SELECT has_table('old');"); const testFiles = await customScanner.scanDirectory(tempDir); @@ -124,14 +128,14 @@ describe('pgTAPTestScanner File Discovery', () => { includePatterns: ['**/unit-*.sql'] }); - await writeFile(join(tempDir, 'unit-test1.sql'), 'SELECT has_table(\'test1\');'); - await writeFile(join(tempDir, 'integration-test.sql'), 'SELECT has_table(\'test2\');'); - await writeFile(join(tempDir, 'unit-test2.sql'), 'SELECT has_table(\'test3\');'); + await writeFile(join(tempDir, 'unit-test1.sql'), "SELECT has_table('test1');"); + await writeFile(join(tempDir, 'integration-test.sql'), "SELECT has_table('test2');"); + await writeFile(join(tempDir, 'unit-test2.sql'), "SELECT has_table('test3');"); const testFiles = await customScanner.scanDirectory(tempDir); expect(testFiles).toHaveLength(2); - expect(testFiles.map(f => f.fileName).sort()).toEqual(['unit-test1.sql', 'unit-test2.sql']); + expect(testFiles.map((f) => f.fileName).sort()).toEqual(['unit-test1.sql', 'unit-test2.sql']); }); }); @@ -145,46 +149,42 @@ describe('pgTAPTestScanner File Discovery', () => { const level1 = join(tempDir, 'level1'); const level2 = join(level1, 'level2'); const level3 = join(level2, 'level3'); - + await mkdir(level1); await mkdir(level2, { recursive: true }); await mkdir(level3, { recursive: true }); - await writeFile(join(tempDir, 'root.sql'), 'SELECT has_table(\'root\');'); - await writeFile(join(level1, 'level1.sql'), 'SELECT has_table(\'level1\');'); - await writeFile(join(level2, 'level2.sql'), 'SELECT has_table(\'level2\');'); - await writeFile(join(level3, 'level3.sql'), 'SELECT has_table(\'level3\');'); + await writeFile(join(tempDir, 'root.sql'), "SELECT has_table('root');"); + await writeFile(join(level1, 'level1.sql'), "SELECT has_table('level1');"); + await writeFile(join(level2, 'level2.sql'), "SELECT has_table('level2');"); + await writeFile(join(level3, 'level3.sql'), "SELECT has_table('level3');"); const testFiles = await customScanner.scanDirectory(tempDir); expect(testFiles).toHaveLength(2); // root and level1 only - expect(testFiles.map(f => f.fileName).sort()).toEqual(['level1.sql', 'root.sql']); + expect(testFiles.map((f) => f.fileName).sort()).toEqual(['level1.sql', 'root.sql']); }); }); describe('Error handling', () => { it('should throw error for non-existent directory', async () => { const nonExistentDir = join(tempDir, 'does-not-exist'); - - await expect(scanner.scanDirectory(nonExistentDir)) - .rejects - .toThrow('ENOENT'); + + await expect(scanner.scanDirectory(nonExistentDir)).rejects.toThrow('ENOENT'); }); it('should throw error for file instead of directory', async () => { const testFile = join(tempDir, 'test.sql'); - await writeFile(testFile, 'SELECT has_table(\'users\');'); - - await expect(scanner.scanDirectory(testFile)) - .rejects - .toThrow('Path is not a directory'); + await writeFile(testFile, "SELECT has_table('users');"); + + await expect(scanner.scanDirectory(testFile)).rejects.toThrow('Path is not a directory'); }); }); describe('Event emission', () => { it('should emit progress events during scanning', async () => { const events = []; - + scanner.on('progress', (event) => { events.push(event); }); @@ -193,24 +193,24 @@ describe('pgTAPTestScanner File Discovery', () => { events.push(event); }); - await writeFile(join(tempDir, 'test1.sql'), 'SELECT has_table(\'test1\');'); - await writeFile(join(tempDir, 'test2.sql'), 'SELECT has_table(\'test2\');'); + await writeFile(join(tempDir, 'test1.sql'), "SELECT has_table('test1');"); + await writeFile(join(tempDir, 'test2.sql'), "SELECT has_table('test2');"); await scanner.scanDirectory(tempDir); expect(events.length).toBeGreaterThan(0); - expect(events.some(e => e.type === 'progress')).toBe(true); - expect(events.some(e => e.type === 'directory')).toBe(true); + expect(events.some((e) => e.type === 'progress')).toBe(true); + expect(events.some((e) => e.type === 'directory')).toBe(true); }); it('should emit success event on completion', async () => { let successEvent = null; - + scanner.on('success', (event) => { successEvent = event; }); - await writeFile(join(tempDir, 'test.sql'), 'SELECT has_table(\'users\');'); + await writeFile(join(tempDir, 'test.sql'), "SELECT has_table('users');"); await scanner.scanDirectory(tempDir); expect(successEvent).not.toBeNull(); @@ -220,7 +220,7 @@ describe('pgTAPTestScanner File Discovery', () => { it('should emit warning for empty directory', async () => { let warningEvent = null; - + scanner.on('warning', (event) => { warningEvent = event; }); @@ -235,28 +235,34 @@ describe('pgTAPTestScanner File Discovery', () => { describe('Integration with parseTestFile', () => { it('should integrate discovered files with parsing', async () => { - await writeFile(join(tempDir, 'test1.sql'), ` + await writeFile( + join(tempDir, 'test1.sql'), + ` SELECT plan(2); SELECT has_table('users'); SELECT has_column('users', 'id'); - `); - - await writeFile(join(tempDir, 'test2.sql'), ` + ` + ); + + await writeFile( + join(tempDir, 'test2.sql'), + ` SELECT plan(1); SELECT has_function('get_user'); - `); + ` + ); const testFiles = await scanner.scanDirectory(tempDir); expect(testFiles).toHaveLength(2); - + // Check that files were parsed correctly expect(testFiles[0].assertions).toBeDefined(); expect(testFiles[1].assertions).toBeDefined(); - + const totalAssertions = testFiles.reduce((sum, file) => sum + file.assertions.length, 0); expect(totalAssertions).toBe(3); // 2 from test1 + 1 from test2 - + // Check that coverage map was built const coverageMap = scanner.getCoverageMap(); expect(Object.keys(coverageMap.tables)).toContain('public.users'); @@ -265,10 +271,10 @@ describe('pgTAPTestScanner File Discovery', () => { it('should handle files with parsing errors gracefully', async () => { // Create a valid file - await writeFile(join(tempDir, 'valid.sql'), 'SELECT has_table(\'users\');'); - + await writeFile(join(tempDir, 'valid.sql'), "SELECT has_table('users');"); + // Create an invalid file that will cause fs.readFile to fail (permission denied) - await writeFile(join(tempDir, 'invalid.sql'), 'SELECT has_table(\'test\');'); + await writeFile(join(tempDir, 'invalid.sql'), "SELECT has_table('test');"); // Make the file unreadable to cause a parsing error const fs = await import('fs/promises'); try { @@ -276,10 +282,10 @@ describe('pgTAPTestScanner File Discovery', () => { } catch (error) { // If chmod fails (e.g., on some file systems), create a different error // Write binary data that would cause encoding issues - await writeFile(join(tempDir, 'invalid.sql'), Buffer.from([0xFF, 0xFE, 0x00, 0x01])); + await writeFile(join(tempDir, 'invalid.sql'), Buffer.from([0xff, 0xfe, 0x00, 0x01])); } - let errorEvents = []; + const errorEvents = []; scanner.on('error', (event) => { errorEvents.push(event); }); @@ -288,8 +294,8 @@ describe('pgTAPTestScanner File Discovery', () => { // Should return at least the valid file, possibly both if the invalid one doesn't error expect(testFiles.length).toBeGreaterThanOrEqual(1); - expect(testFiles.map(f => f.fileName)).toContain('valid.sql'); - + expect(testFiles.map((f) => f.fileName)).toContain('valid.sql'); + // For this test, we'll just check that either we got an error event OR the scanner handled it gracefully // The exact behavior may vary by system expect(true).toBe(true); // This test mainly ensures the scanner doesn't crash @@ -301,16 +307,11 @@ describe('pgTAPTestScanner File Discovery', () => { // Create a reasonable number of test files const fileCount = 20; const promises = []; - + for (let i = 0; i < fileCount; i++) { - promises.push( - writeFile( - join(tempDir, `test${i}.sql`), - `SELECT has_table('table${i}');` - ) - ); + promises.push(writeFile(join(tempDir, `test${i}.sql`), `SELECT has_table('table${i}');`)); } - + await Promise.all(promises); const startTime = Date.now(); @@ -319,11 +320,11 @@ describe('pgTAPTestScanner File Discovery', () => { expect(testFiles).toHaveLength(fileCount); expect(duration).toBeLessThan(5000); // Should complete within 5 seconds - + // Check that all files were processed - const fileNames = testFiles.map(f => f.fileName).sort(); + const fileNames = testFiles.map((f) => f.fileName).sort(); const expectedNames = Array.from({ length: fileCount }, (_, i) => `test${i}.sql`).sort(); expect(fileNames).toEqual(expectedNames); }); }); -}); \ No newline at end of file +}); diff --git a/test/pgTAPTestScanner.index.test.js b/test/pgTAPTestScanner.index.test.js index 20ef012..38ee316 100644 --- a/test/pgTAPTestScanner.index.test.js +++ b/test/pgTAPTestScanner.index.test.js @@ -1,6 +1,6 @@ /** * pgTAPTestScanner Index Assertion Parsing Tests - * + * * Tests the index assertion parsing capabilities of pgTAPTestScanner */ @@ -18,7 +18,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse has_index with table and index', () => { const sql = "SELECT has_index('users', 'idx_users_email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_index'); expect(assertions[0].target).toBe('users.idx_users_email'); @@ -28,7 +28,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse has_index with schema, table, and index', () => { const sql = "SELECT has_index('public', 'users', 'idx_users_email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_index'); expect(assertions[0].target).toBe('public.users.idx_users_email'); @@ -38,7 +38,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse hasnt_index with table and index', () => { const sql = "SELECT hasnt_index('temp_table', 'non_existent_idx');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('hasnt_index'); expect(assertions[0].target).toBe('temp_table.non_existent_idx'); @@ -48,7 +48,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse hasnt_index with schema, table, and index', () => { const sql = "SELECT hasnt_index('private', 'sessions', 'idx_sessions_old');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('hasnt_index'); expect(assertions[0].target).toBe('private.sessions.idx_sessions_old'); @@ -60,7 +60,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse index_is_on with table, index, and single column', () => { const sql = "SELECT index_is_on('users', 'idx_users_email', ARRAY['email']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('index_is_on'); expect(assertions[0].target).toBe('users.idx_users_email'); @@ -68,23 +68,34 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { }); it('should parse index_is_on with table, index, and multiple columns', () => { - const sql = "SELECT index_is_on('orders', 'idx_orders_status_date', ARRAY['status', 'created_at']);"; + const sql = + "SELECT index_is_on('orders', 'idx_orders_status_date', ARRAY['status', 'created_at']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('index_is_on'); expect(assertions[0].target).toBe('orders.idx_orders_status_date'); - expect(assertions[0].parameters).toEqual(['orders', 'idx_orders_status_date', "'status', 'created_at'"]); + expect(assertions[0].parameters).toEqual([ + 'orders', + 'idx_orders_status_date', + "'status', 'created_at'" + ]); }); it('should parse index_is_on with schema, table, index, and columns', () => { - const sql = "SELECT index_is_on('public', 'orders', 'idx_orders_status_date', ARRAY['status', 'created_at']);"; + const sql = + "SELECT index_is_on('public', 'orders', 'idx_orders_status_date', ARRAY['status', 'created_at']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('index_is_on'); expect(assertions[0].target).toBe('public.orders.idx_orders_status_date'); - expect(assertions[0].parameters).toEqual(['public', 'orders', 'idx_orders_status_date', "'status', 'created_at'"]); + expect(assertions[0].parameters).toEqual([ + 'public', + 'orders', + 'idx_orders_status_date', + "'status', 'created_at'" + ]); }); }); @@ -92,7 +103,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse index_is_type with table, index, and type', () => { const sql = "SELECT index_is_type('users', 'idx_users_email', 'btree');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('index_is_type'); expect(assertions[0].target).toBe('users.idx_users_email'); @@ -102,7 +113,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse index_is_type with schema, table, index, and type', () => { const sql = "SELECT index_is_type('public', 'posts', 'idx_posts_content', 'gin');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('index_is_type'); expect(assertions[0].target).toBe('public.posts.idx_posts_content'); @@ -114,7 +125,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse has_unique with table and constraint', () => { const sql = "SELECT has_unique('users', 'uq_users_email');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_unique'); expect(assertions[0].target).toBe('users.uq_users_email'); @@ -124,7 +135,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse has_unique with schema, table, and constraint', () => { const sql = "SELECT has_unique('public', 'products', 'uq_products_sku');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_unique'); expect(assertions[0].target).toBe('public.products.uq_products_sku'); @@ -134,7 +145,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse hasnt_unique with table and constraint', () => { const sql = "SELECT hasnt_unique('temp_table', 'old_constraint');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('hasnt_unique'); expect(assertions[0].target).toBe('temp_table.old_constraint'); @@ -146,7 +157,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse index_is_primary with table and index', () => { const sql = "SELECT index_is_primary('users', 'idx_users_pkey');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('index_is_primary'); expect(assertions[0].target).toBe('users.idx_users_pkey'); @@ -156,7 +167,7 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { it('should parse index_is_primary with schema, table, and index', () => { const sql = "SELECT index_is_primary('public', 'users', 'users_pkey');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('index_is_primary'); expect(assertions[0].target).toBe('public.users.users_pkey'); @@ -172,26 +183,28 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { SELECT index_is_type('users', 'idx_users_email', 'btree'); SELECT has_unique('products', 'uq_products_sku'); `; - + const assertions = scanner.extractAssertions(sql); - + // Manually build coverage map for testing - scanner.testFiles = [{ - filePath: '/test/index_test.sql', - fileName: 'index_test.sql', - assertions, - planCount: 4, - dependencies: [], - metadata: {} - }]; - + scanner.testFiles = [ + { + filePath: '/test/index_test.sql', + fileName: 'index_test.sql', + assertions, + planCount: 4, + dependencies: [], + metadata: {} + } + ]; + scanner._buildCoverageMap(); const coverageMap = scanner.getCoverageMap(); - + expect(coverageMap.indexes).toBeDefined(); expect(Object.keys(coverageMap.indexes)).toContain('users.idx_users_email'); expect(Object.keys(coverageMap.indexes)).toContain('products.uq_products_sku'); - + expect(coverageMap.indexes['users.idx_users_email']).toContain('has_index'); expect(coverageMap.indexes['users.idx_users_email']).toContain('index_is_on'); expect(coverageMap.indexes['users.idx_users_email']).toContain('index_is_type'); @@ -204,21 +217,23 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { SELECT has_unique('products', 'uq_products_sku'); SELECT index_is_primary('orders', 'orders_pkey'); `; - + const assertions = scanner.extractAssertions(sql); - - scanner.testFiles = [{ - filePath: '/test/index_test.sql', - fileName: 'index_test.sql', - assertions, - planCount: 3, - dependencies: [], - metadata: {} - }]; - + + scanner.testFiles = [ + { + filePath: '/test/index_test.sql', + fileName: 'index_test.sql', + assertions, + planCount: 3, + dependencies: [], + metadata: {} + } + ]; + scanner._buildCoverageMap(); const stats = scanner.getStatistics(); - + expect(stats.coverageStats.indexesWithTests).toBe(3); // 'users.idx_users_email', 'products.uq_products_sku', 'orders.orders_pkey' }); }); @@ -233,18 +248,18 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { SELECT index_is_on('users', 'idx_users_email', ARRAY['email']); SELECT index_is_type('users', 'idx_users_email', 'btree'); `; - + const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(5); // Excludes the plan statement - - const indexAssertions = assertions.filter(a => - a.type.includes('index') || a.type.includes('unique') + + const indexAssertions = assertions.filter( + (a) => a.type.includes('index') || a.type.includes('unique') ); expect(indexAssertions).toHaveLength(3); - - const tableColumnAssertions = assertions.filter(a => - a.type.includes('table') || a.type.includes('column') + + const tableColumnAssertions = assertions.filter( + (a) => a.type.includes('table') || a.type.includes('column') ); expect(tableColumnAssertions).toHaveLength(2); }); @@ -260,14 +275,14 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { ); SELECT index_is_type('users','idx_users_email','btree'); `; - + const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(3); expect(assertions[0].type).toBe('has_index'); expect(assertions[1].type).toBe('index_is_on'); expect(assertions[2].type).toBe('index_is_type'); - + expect(assertions[0].target).toBe('users.idx_users_email'); expect(assertions[1].target).toBe('public.orders.idx_orders_composite'); expect(assertions[2].target).toBe('users.idx_users_email'); @@ -283,12 +298,12 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { SELECT hasnt_unique('users', 'old_unique'); SELECT index_is_primary('users', 'users_pkey'); `; - + const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(7); - - const assertionTypes = assertions.map(a => a.type); + + const assertionTypes = assertions.map((a) => a.type); expect(assertionTypes).toContain('has_index'); expect(assertionTypes).toContain('hasnt_index'); expect(assertionTypes).toContain('index_is_on'); @@ -296,12 +311,12 @@ describe('pgTAPTestScanner Index Assertion Parsing', () => { expect(assertionTypes).toContain('has_unique'); expect(assertionTypes).toContain('hasnt_unique'); expect(assertionTypes).toContain('index_is_primary'); - + // All should be categorized as index assertions - const indexAssertions = assertions.filter(a => - a.type.includes('index') || a.type.includes('unique') + const indexAssertions = assertions.filter( + (a) => a.type.includes('index') || a.type.includes('unique') ); expect(indexAssertions).toHaveLength(7); }); }); -}); \ No newline at end of file +}); diff --git a/test/pgTAPTestScanner.rls.test.js b/test/pgTAPTestScanner.rls.test.js index 022c558..f7df485 100644 --- a/test/pgTAPTestScanner.rls.test.js +++ b/test/pgTAPTestScanner.rls.test.js @@ -1,6 +1,6 @@ /** * pgTAPTestScanner RLS Policy Assertion Parsing Tests - * + * * Tests the RLS (Row Level Security) policy assertion parsing capabilities of pgTAPTestScanner */ @@ -18,7 +18,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse is_rls_enabled with table only', () => { const sql = "SELECT is_rls_enabled('users');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('is_rls_enabled'); expect(assertions[0].target).toBe('users'); @@ -28,7 +28,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse is_rls_enabled with schema and table', () => { const sql = "SELECT is_rls_enabled('public', 'profiles');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('is_rls_enabled'); expect(assertions[0].target).toBe('public.profiles'); @@ -42,7 +42,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT is_rls_enabled('public', 'posts'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(3); expect(assertions[0].target).toBe('users'); expect(assertions[1].target).toBe('auth.sessions'); @@ -54,7 +54,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse policy_exists with table and policy name', () => { const sql = "SELECT policy_exists('users', 'user_select_policy');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policy_exists'); expect(assertions[0].target).toBe('users.user_select_policy'); @@ -64,7 +64,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse policy_exists with schema, table, and policy name', () => { const sql = "SELECT policy_exists('public', 'users', 'user_insert_policy');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policy_exists'); expect(assertions[0].target).toBe('public.users.user_insert_policy'); @@ -78,7 +78,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_exists('posts', 'author_policy'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(3); expect(assertions[0].target).toBe('users.user_policy'); expect(assertions[1].target).toBe('auth.sessions.session_policy'); @@ -90,7 +90,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse policy_cmd_is with table, policy, and command', () => { const sql = "SELECT policy_cmd_is('users', 'user_policy', 'SELECT');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policy_cmd_is'); expect(assertions[0].target).toBe('users.user_policy'); @@ -100,7 +100,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse policy_cmd_is with schema, table, policy, and command', () => { const sql = "SELECT policy_cmd_is('public', 'users', 'user_insert_policy', 'INSERT');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policy_cmd_is'); expect(assertions[0].target).toBe('public.users.user_insert_policy'); @@ -116,7 +116,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_cmd_is('posts', 'all_policy', 'ALL'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(5); expect(assertions[0].parameters[2]).toBe('SELECT'); expect(assertions[1].parameters[2]).toBe('INSERT'); @@ -130,7 +130,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse policy_roles_are with table, policy, and role array', () => { const sql = "SELECT policy_roles_are('users', 'user_policy', ARRAY['authenticated']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policy_roles_are'); expect(assertions[0].target).toBe('users.user_policy'); @@ -138,13 +138,19 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { }); it('should parse policy_roles_are with schema, table, policy, and role array', () => { - const sql = "SELECT policy_roles_are('public', 'users', 'admin_policy', ARRAY['admin', 'moderator']);"; + const sql = + "SELECT policy_roles_are('public', 'users', 'admin_policy', ARRAY['admin', 'moderator']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policy_roles_are'); expect(assertions[0].target).toBe('public.users.admin_policy'); - expect(assertions[0].parameters).toEqual(['public', 'users', 'admin_policy', "'admin', 'moderator'"]); + expect(assertions[0].parameters).toEqual([ + 'public', + 'users', + 'admin_policy', + "'admin', 'moderator'" + ]); }); it('should parse multiple role arrays', () => { @@ -154,7 +160,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_roles_are('comments', 'public_policy', ARRAY['public', 'authenticated', 'anon']); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(3); expect(assertions[0].parameters[2]).toBe("'author'"); expect(assertions[1].parameters[2]).toBe("'editor', 'admin'"); @@ -166,7 +172,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should parse policies_are with table and policy array', () => { const sql = "SELECT policies_are('users', ARRAY['select_policy', 'insert_policy']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policies_are'); expect(assertions[0].target).toBe('users'); @@ -174,29 +180,40 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { }); it('should parse policies_are with schema, table, and policy array', () => { - const sql = "SELECT policies_are('public', 'users', ARRAY['user_select', 'user_insert', 'user_update']);"; + const sql = + "SELECT policies_are('public', 'users', ARRAY['user_select', 'user_insert', 'user_update']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policies_are'); expect(assertions[0].target).toBe('public.users'); - expect(assertions[0].parameters).toEqual(['public', 'users', "'user_select', 'user_insert', 'user_update'"]); + expect(assertions[0].parameters).toEqual([ + 'public', + 'users', + "'user_select', 'user_insert', 'user_update'" + ]); }); it('should parse policies_are with optional description', () => { - const sql = "SELECT policies_are('public', 'users', ARRAY['select_policy', 'insert_policy'], 'All user policies');"; + const sql = + "SELECT policies_are('public', 'users', ARRAY['select_policy', 'insert_policy'], 'All user policies');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policies_are'); expect(assertions[0].target).toBe('public.users'); - expect(assertions[0].parameters).toEqual(['public', 'users', "'select_policy', 'insert_policy'", 'All user policies']); + expect(assertions[0].parameters).toEqual([ + 'public', + 'users', + "'select_policy', 'insert_policy'", + 'All user policies' + ]); }); it('should parse single policy in array', () => { const sql = "SELECT policies_are('posts', ARRAY['author_only_policy']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('policies_are'); expect(assertions[0].target).toBe('posts'); @@ -227,12 +244,12 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policies_are('public', 'posts', ARRAY['author_policy', 'admin_policy'], 'Post policies'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(9); - expect(assertions.map(a => a.type)).toEqual([ + expect(assertions.map((a) => a.type)).toEqual([ 'is_rls_enabled', 'policy_exists', - 'policy_exists', + 'policy_exists', 'policy_cmd_is', 'policy_cmd_is', 'policy_roles_are', @@ -249,11 +266,11 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { /* SELECT policy_cmd_is('users', 'commented_policy', 'SELECT'); */ SELECT policies_are('users', ARRAY['active_policy']); `; - + const assertions = scanner.extractAssertions(sql); // Note: The /* */ multiline comment might not be filtered out by the simple comment pattern expect(assertions.length).toBeGreaterThanOrEqual(2); // At least uncommented assertions - + // Test with includeCommented = true const scannerWithComments = new pgTAPTestScanner({ includeCommented: true }); const assertionsWithComments = scannerWithComments.extractAssertions(sql); @@ -270,26 +287,28 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_roles_are('public', 'posts', 'admin_policy', ARRAY['admin']); SELECT policies_are('comments', ARRAY['public_policy', 'auth_policy']); `; - + const assertions = scanner.extractAssertions(sql); - + // Simulate building coverage map - scanner.testFiles = [{ - filePath: '/test/rls.sql', - fileName: 'rls.sql', - assertions, - planCount: assertions.length, - dependencies: [], - metadata: {} - }]; - + scanner.testFiles = [ + { + filePath: '/test/rls.sql', + fileName: 'rls.sql', + assertions, + planCount: assertions.length, + dependencies: [], + metadata: {} + } + ]; + scanner._buildCoverageMap(); const coverageMap = scanner.getCoverageMap(); - + // Check that policies are properly tracked expect(coverageMap.policies).toBeDefined(); expect(Object.keys(coverageMap.policies)).toHaveLength(4); - + expect(coverageMap.policies['users']).toContain('is_rls_enabled'); expect(coverageMap.policies['users.user_policy']).toContain('policy_exists'); expect(coverageMap.policies['users.user_policy']).toContain('policy_cmd_is'); @@ -302,28 +321,31 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT is_rls_enabled('users'); SELECT policy_exists('posts', 'author_policy'); `; - + const assertions = scanner.extractAssertions(sql); - - scanner.testFiles = [{ - filePath: '/test/user_rls.sql', - fileName: 'user_rls.sql', - assertions: [assertions[0]], - planCount: 1, - dependencies: [], - metadata: {} - }, { - filePath: '/test/post_rls.sql', - fileName: 'post_rls.sql', - assertions: [assertions[1]], - planCount: 1, - dependencies: [], - metadata: {} - }]; - + + scanner.testFiles = [ + { + filePath: '/test/user_rls.sql', + fileName: 'user_rls.sql', + assertions: [assertions[0]], + planCount: 1, + dependencies: [], + metadata: {} + }, + { + filePath: '/test/post_rls.sql', + fileName: 'post_rls.sql', + assertions: [assertions[1]], + planCount: 1, + dependencies: [], + metadata: {} + } + ]; + scanner._buildCoverageMap(); const coverageMap = scanner.getCoverageMap(); - + expect(coverageMap.filesByTarget['users']).toHaveLength(1); expect(coverageMap.filesByTarget['users'][0].fileName).toBe('user_rls.sql'); expect(coverageMap.filesByTarget['posts.author_policy']).toHaveLength(1); @@ -338,7 +360,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_exists('users'); -- missing policy name SELECT policy_cmd_is('users', 'policy'); -- missing command `; - + // Should not throw errors, but may not match patterns expect(() => scanner.extractAssertions(sql)).not.toThrow(); }); @@ -354,7 +376,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { ); SELECT policy_cmd_is('posts','author_policy','SELECT'); `; - + const assertions = scanner.extractAssertions(sql); expect(assertions).toHaveLength(3); expect(assertions[0].type).toBe('is_rls_enabled'); @@ -365,7 +387,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { it('should preserve original SQL in rawSql property', () => { const sql = "SELECT policy_exists('users', 'user_policy');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions[0].rawSql).toBe("SELECT policy_exists('users', 'user_policy')"); }); @@ -375,7 +397,7 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_exists('posts', 'author_policy'); -- Line 4 `; - + const assertions = scanner.extractAssertions(sql); expect(assertions).toHaveLength(2); expect(assertions[0].lineNumber).toBe(2); @@ -390,14 +412,14 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT is_rls_enabled('public', 'profiles'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(2); - + expect(assertions[0].policyMetadata).toEqual({ schema: 'public', tableName: 'users' }); - + expect(assertions[1].policyMetadata).toEqual({ schema: 'public', tableName: 'profiles' @@ -410,15 +432,15 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_exists('auth', 'sessions', 'session_policy'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(2); - + expect(assertions[0].policyMetadata).toEqual({ schema: 'public', tableName: 'users', policyName: 'user_select_policy' }); - + expect(assertions[1].policyMetadata).toEqual({ schema: 'auth', tableName: 'sessions', @@ -432,16 +454,16 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_cmd_is('public', 'comments', 'moderator_policy', 'DELETE'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(2); - + expect(assertions[0].policyMetadata).toEqual({ schema: 'public', tableName: 'posts', policyName: 'author_policy', command: 'SELECT' }); - + expect(assertions[1].policyMetadata).toEqual({ schema: 'public', tableName: 'comments', @@ -456,16 +478,16 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_roles_are('public', 'posts', 'admin_policy', ARRAY['admin', 'moderator']); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(2); - + expect(assertions[0].policyMetadata).toEqual({ schema: 'public', tableName: 'users', policyName: 'user_policy', roles: ['authenticated'] }); - + expect(assertions[1].policyMetadata).toEqual({ schema: 'public', tableName: 'posts', @@ -480,15 +502,15 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policies_are('public', 'posts', ARRAY['author_policy', 'admin_policy'], 'Post access policies'); `; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(2); - + expect(assertions[0].policyMetadata).toEqual({ schema: 'public', tableName: 'users', policies: ['select_policy', 'insert_policy'] }); - + expect(assertions[1].policyMetadata).toEqual({ schema: 'public', tableName: 'posts', @@ -507,24 +529,26 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { SELECT policy_cmd_is('users', 'policy1', 'SELECT'); SELECT policies_are('comments', ARRAY['policy1']); `; - + const assertions = scanner.extractAssertions(sql); - scanner.testFiles = [{ - filePath: '/test/rls.sql', - fileName: 'rls.sql', - assertions, - planCount: assertions.length, - dependencies: [], - metadata: {} - }]; - + scanner.testFiles = [ + { + filePath: '/test/rls.sql', + fileName: 'rls.sql', + assertions, + planCount: assertions.length, + dependencies: [], + metadata: {} + } + ]; + // Need to set totalAssertions manually or via processing scanner.totalAssertions = assertions.length; scanner.filesProcessed = 1; - + scanner._buildCoverageMap(); const stats = scanner.getStatistics(); - + expect(stats.totalAssertions).toBe(5); expect(stats.assertionTypes['is_rls_enabled']).toBe(1); expect(stats.assertionTypes['policy_exists']).toBe(2); @@ -533,4 +557,4 @@ describe('pgTAPTestScanner RLS Policy Assertion Parsing', () => { expect(stats.coverageStats.policiesWithTests).toBe(4); // users, users.policy1, posts.policy2, comments }); }); -}); \ No newline at end of file +}); diff --git a/test/pgTAPTestScanner.trigger.test.js b/test/pgTAPTestScanner.trigger.test.js index c27de27..32c4634 100644 --- a/test/pgTAPTestScanner.trigger.test.js +++ b/test/pgTAPTestScanner.trigger.test.js @@ -8,7 +8,7 @@ import pgTAPTestScanner from '../src/lib/testing/pgTAPTestScanner.js'; describe('pgTAPTestScanner Trigger Assertion Parsing', () => { let scanner; - + beforeEach(() => { scanner = new pgTAPTestScanner(); }); @@ -17,7 +17,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse has_trigger with table and trigger name', () => { const sql = "SELECT has_trigger('users', 'update_timestamp_trigger');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_trigger'); expect(assertions[0].target).toBe('public.users.update_timestamp_trigger'); @@ -27,7 +27,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse has_trigger with schema, table, and trigger name', () => { const sql = "SELECT has_trigger('public', 'posts', 'audit_trigger');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('has_trigger'); expect(assertions[0].target).toBe('public.posts.audit_trigger'); @@ -39,7 +39,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse hasnt_trigger with table and trigger name', () => { const sql = "SELECT hasnt_trigger('temp_table', 'old_trigger');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('hasnt_trigger'); expect(assertions[0].target).toBe('public.temp_table.old_trigger'); @@ -51,7 +51,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse trigger_is with table, trigger, and function', () => { const sql = "SELECT trigger_is('users', 'update_trigger', 'set_timestamp');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('trigger_is'); expect(assertions[0].target).toBe('public.users.update_trigger'); @@ -61,11 +61,17 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse trigger_is with schema, table, trigger, func_schema, and function', () => { const sql = "SELECT trigger_is('public', 'posts', 'audit_trigger', 'audit', 'log_changes');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('trigger_is'); expect(assertions[0].target).toBe('public.posts.audit_trigger'); - expect(assertions[0].parameters).toEqual(['public', 'posts', 'audit_trigger', 'audit', 'log_changes']); + expect(assertions[0].parameters).toEqual([ + 'public', + 'posts', + 'audit_trigger', + 'audit', + 'log_changes' + ]); }); }); @@ -73,7 +79,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse is_trigger_on with table, trigger, and events', () => { const sql = "SELECT is_trigger_on('posts', 'audit_trigger', 'UPDATE');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('is_trigger_on'); expect(assertions[0].target).toBe('public.posts.audit_trigger'); @@ -83,7 +89,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse is_trigger_on with schema, table, trigger, and events', () => { const sql = "SELECT is_trigger_on('public', 'users', 'validation_trigger', 'INSERT');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('is_trigger_on'); expect(assertions[0].target).toBe('public.users.validation_trigger'); @@ -95,7 +101,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse trigger_fires_on with timing', () => { const sql = "SELECT trigger_fires_on('users', 'update_trigger', 'BEFORE');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('trigger_fires_on'); expect(assertions[0].target).toBe('public.users.update_trigger'); @@ -107,7 +113,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse trigger_is_for with level', () => { const sql = "SELECT trigger_is_for('users', 'update_trigger', 'ROW');"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('trigger_is_for'); expect(assertions[0].target).toBe('public.users.update_trigger'); @@ -119,7 +125,7 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { it('should parse triggers_are with table and trigger array', () => { const sql = "SELECT triggers_are('users', ARRAY['update_trigger', 'validation_trigger']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('triggers_are'); expect(assertions[0].target).toBe('public.users'); @@ -127,13 +133,18 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { }); it('should parse triggers_are with schema, table, and trigger array', () => { - const sql = "SELECT triggers_are('public', 'posts', ARRAY['audit_trigger', 'notify_trigger']);"; + const sql = + "SELECT triggers_are('public', 'posts', ARRAY['audit_trigger', 'notify_trigger']);"; const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(1); expect(assertions[0].type).toBe('triggers_are'); expect(assertions[0].target).toBe('public.posts'); - expect(assertions[0].parameters).toEqual(['public', 'posts', "'audit_trigger', 'notify_trigger'"]); + expect(assertions[0].parameters).toEqual([ + 'public', + 'posts', + "'audit_trigger', 'notify_trigger'" + ]); }); }); @@ -145,35 +156,35 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { SELECT trigger_fires_on('users', 'update_trigger', 'BEFORE'); SELECT is_trigger_on('posts', 'audit_trigger', 'INSERT'); `; - + const assertions = scanner.extractAssertions(sql); - + // Mock test file structure - scanner.testFiles = [{ - filePath: '/test/triggers.sql', - fileName: 'triggers.sql', - assertions, - planCount: assertions.length, - dependencies: [], - metadata: { size: sql.length, lines: sql.split('\n').length, parsed: new Date() } - }]; - + scanner.testFiles = [ + { + filePath: '/test/triggers.sql', + fileName: 'triggers.sql', + assertions, + planCount: assertions.length, + dependencies: [], + metadata: { size: sql.length, lines: sql.split('\n').length, parsed: new Date() } + } + ]; + scanner._buildCoverageMap(); const coverageMap = scanner.getCoverageMap(); - + expect(coverageMap.triggers).toBeDefined(); expect(Object.keys(coverageMap.triggers)).toContain('public.users.update_trigger'); expect(Object.keys(coverageMap.triggers)).toContain('public.posts.audit_trigger'); - + expect(coverageMap.triggers['public.users.update_trigger']).toEqual([ 'has_trigger', 'trigger_is', 'trigger_fires_on' ]); - - expect(coverageMap.triggers['public.posts.audit_trigger']).toEqual([ - 'is_trigger_on' - ]); + + expect(coverageMap.triggers['public.posts.audit_trigger']).toEqual(['is_trigger_on']); }); it('should include trigger statistics in coverage stats', () => { @@ -181,21 +192,23 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { SELECT has_trigger('users', 'update_trigger'); SELECT has_trigger('posts', 'audit_trigger'); `; - + const assertions = scanner.extractAssertions(sql); - - scanner.testFiles = [{ - filePath: '/test/triggers.sql', - fileName: 'triggers.sql', - assertions, - planCount: assertions.length, - dependencies: [], - metadata: { size: sql.length, lines: sql.split('\n').length, parsed: new Date() } - }]; - + + scanner.testFiles = [ + { + filePath: '/test/triggers.sql', + fileName: 'triggers.sql', + assertions, + planCount: assertions.length, + dependencies: [], + metadata: { size: sql.length, lines: sql.split('\n').length, parsed: new Date() } + } + ]; + scanner._buildCoverageMap(); const stats = scanner.getStatistics(); - + expect(stats.coverageStats.triggersWithTests).toBe(2); }); }); @@ -214,25 +227,25 @@ describe('pgTAPTestScanner Trigger Assertion Parsing', () => { SELECT has_trigger('posts', 'audit_trigger'); SELECT trigger_is('posts', 'audit_trigger', 'audit_changes'); `; - + const assertions = scanner.extractAssertions(sql); - + expect(assertions).toHaveLength(7); - + // Verify all assertions are properly categorized - const triggerAssertions = assertions.filter(a => a.type.includes('trigger')); + const triggerAssertions = assertions.filter((a) => a.type.includes('trigger')); expect(triggerAssertions).toHaveLength(7); - + // Verify target extraction works correctly - const updateTriggerAssertions = assertions.filter(a => - a.target === 'public.users.update_timestamp_trigger' + const updateTriggerAssertions = assertions.filter( + (a) => a.target === 'public.users.update_timestamp_trigger' ); expect(updateTriggerAssertions).toHaveLength(5); - - const auditTriggerAssertions = assertions.filter(a => - a.target === 'public.posts.audit_trigger' + + const auditTriggerAssertions = assertions.filter( + (a) => a.target === 'public.posts.audit_trigger' ); expect(auditTriggerAssertions).toHaveLength(2); }); }); -}); \ No newline at end of file +}); diff --git a/test/setup.js b/test/setup.js index d67e142..90a6311 100644 --- a/test/setup.js +++ b/test/setup.js @@ -19,7 +19,7 @@ afterEach(async () => { } } globalConnections.clear(); - + // Clear any remaining timers if (typeof global.clearAllTimers === 'function') { global.clearAllTimers(); @@ -33,12 +33,12 @@ afterAll(async () => { if (global.dbConnection) { await global.dbConnection.end(); } - + // Close any Supabase clients if (global.supabaseClient) { global.supabaseClient = null; } - + // Close any remaining connections for (const connection of globalConnections) { try { @@ -49,7 +49,6 @@ afterAll(async () => { console.warn('Failed to close connection in afterAll:', error.message); } } - } finally { // Force exit after longer timeout to prevent hanging setTimeout(() => { @@ -63,4 +62,4 @@ afterAll(async () => { export function trackConnection(connection) { globalConnections.add(connection); return connection; -} \ No newline at end of file +} diff --git a/test/test-cache-performance.js b/test/test-cache-performance.js deleted file mode 100644 index 22b52fc..0000000 --- a/test/test-cache-performance.js +++ /dev/null @@ -1,361 +0,0 @@ -#!/usr/bin/env node - -/** - * Test Cache Performance Validation Script - * - * Validates that the TestCache provides >50% performance improvement - * on repeat test runs as required by P1.T015 - */ - -const path = require('path'); -const { performance } = require('perf_hooks'); -const RunCommand = require('../src/commands/test/RunCommand'); -const CacheCommand = require('../src/commands/test/CacheCommand'); - -/** - * Performance validation test suite - */ -class CachePerformanceValidator { - constructor() { - this.results = { - firstRun: null, - secondRun: null, - improvement: null, - cacheStats: null, - passed: false - }; - } - - /** - * Run performance validation - */ - async validate() { - console.log('๐Ÿš€ data Test Cache Performance Validation'); - console.log('=' .repeat(50)); - - try { - // Setup test environment - await this.setup(); - - // Clear existing cache to ensure clean test - console.log('\n1. Clearing existing cache...'); - await this.clearCache(); - - // First run (cache miss - baseline) - console.log('\n2. Running first test execution (building cache)...'); - const firstRunTime = await this.runTests('First run (cache miss)'); - this.results.firstRun = { - executionTime: firstRunTime, - cacheHits: 0 - }; - - // Second run (cache hit - optimized) - console.log('\n3. Running second test execution (using cache)...'); - const secondRunTime = await this.runTests('Second run (cache hit)'); - this.results.secondRun = { - executionTime: secondRunTime, - cacheHits: 1 // Assuming at least one cache hit - }; - - // Calculate performance improvement - console.log('\n4. Analyzing performance improvement...'); - await this.analyzePerformance(); - - // Get cache statistics - console.log('\n5. Gathering cache statistics...'); - await this.getCacheStats(); - - // Display results - console.log('\n6. Performance Validation Results:'); - this.displayResults(); - - return this.results.passed; - - } catch (error) { - console.error(`โŒ Validation failed: ${error.message}`); - console.error(error.stack); - return false; - } - } - - /** - * Setup test environment - */ - async setup() { - // Mock database URL for testing - this.databaseUrl = process.env.DATABASE_URL || 'postgresql://postgres:postgres@localhost:54332/postgres'; - - // Create run command instance - this.runCommand = new RunCommand( - this.databaseUrl, - null, // serviceRoleKey - './tests', // testsDir - './test-results', // outputDir - console, // logger - false // isProd - ); - - // Create cache command instance - this.cacheCommand = new CacheCommand( - this.databaseUrl, - null, - './tests', - './test-results', - console, - false - ); - } - - /** - * Clear cache before testing - */ - async clearCache() { - try { - await this.cacheCommand.performExecute({ action: 'clear' }); - console.log(' โœ“ Cache cleared successfully'); - } catch (error) { - console.log(' โ„น No existing cache to clear'); - } - } - - /** - * Run test with timing - * @param {string} label - Run label - * @returns {number} Execution time in milliseconds - */ - async runTests(label) { - console.log(` Running ${label}...`); - - const startTime = performance.now(); - - try { - // Mock test execution for performance measurement - // In a real scenario, this would run actual pgTAP tests - const results = await this.simulateTestExecution(); - - const endTime = performance.now(); - const executionTime = Math.round(endTime - startTime); - - console.log(` โœ“ ${label} completed in ${executionTime}ms`); - - return executionTime; - - } catch (error) { - const endTime = performance.now(); - const executionTime = Math.round(endTime - startTime); - - console.log(` โš  ${label} completed with warnings in ${executionTime}ms`); - return executionTime; - } - } - - /** - * Simulate test execution for performance measurement - * This simulates the performance difference between cached and uncached execution - * @returns {Promise} Mock test results - */ - async simulateTestExecution() { - const TestCache = require('../src/lib/test/TestCache'); - const cache = new TestCache('.data-cache/test-results'); - - // Mock test function - const testFunction = 'run_admin_delete_pet_tests'; - const mockTapOutput = `1..5 -ok 1 - Test admin can delete pet -ok 2 - Test orphaned applications are cleaned up -ok 3 - Test audit log is created -ok 4 - Test RLS policies prevent unauthorized access -ok 5 - Test cascade deletions work correctly`; - - try { - // Calculate hash for this test - const hash = await cache.calculateHash(testFunction, this.databaseUrl, {}); - - // Check if we have cached results - const cachedResult = await cache.getCachedResult(hash); - - if (cachedResult && cachedResult.tapOutput) { - // Cache hit - much faster execution - await new Promise(resolve => setTimeout(resolve, 25)); // Fast cache retrieval - - return { - total: 5, - passed: 5, - failed: 0, - skipped: 0, - tests: [], - fromCache: true, - performance: { - totalExecutionTime: 25, - cacheEnabled: true, - cacheHits: 1, - cacheMisses: 0, - testsExecuted: 1, - testsFromCache: 1, - cacheHitRate: '100.0' - } - }; - } else { - // Cache miss - slower execution (simulate database operations) - const executionTime = 150 + Math.random() * 100; // 150-250ms - await new Promise(resolve => setTimeout(resolve, executionTime)); - - // Store result in cache - await cache.storeResult(hash, { - tapOutput: mockTapOutput, - originalDuration: executionTime - }, { - testFunction: testFunction, - duration: executionTime, - databaseUrl: this.databaseUrl, - options: {} - }); - - return { - total: 5, - passed: 5, - failed: 0, - skipped: 0, - tests: [], - fromCache: false, - performance: { - totalExecutionTime: Math.round(executionTime), - cacheEnabled: true, - cacheHits: 0, - cacheMisses: 1, - testsExecuted: 1, - testsFromCache: 0, - cacheHitRate: '0.0' - } - }; - } - } catch (error) { - console.warn(`Cache simulation error: ${error.message}`); - // Fallback to normal execution timing - const executionTime = 200 + Math.random() * 50; - await new Promise(resolve => setTimeout(resolve, executionTime)); - - return { - total: 5, - passed: 5, - failed: 0, - skipped: 0, - tests: [], - fromCache: false, - performance: { - totalExecutionTime: Math.round(executionTime), - cacheEnabled: false, - cacheHits: 0, - cacheMisses: 1, - testsExecuted: 1, - testsFromCache: 0, - cacheHitRate: '0.0' - } - }; - } - } - - /** - * Analyze performance improvement - */ - async analyzePerformance() { - const firstTime = this.results.firstRun.executionTime; - const secondTime = this.results.secondRun.executionTime; - - const improvement = ((firstTime - secondTime) / firstTime) * 100; - this.results.improvement = Math.max(0, improvement); // Ensure non-negative - - // Check if improvement meets requirement (>50%) - this.results.passed = this.results.improvement > 50; - - console.log(` First run: ${firstTime}ms`); - console.log(` Second run: ${secondTime}ms`); - console.log(` Improvement: ${this.results.improvement.toFixed(1)}%`); - console.log(` Requirement: >50% improvement`); - console.log(` Status: ${this.results.passed ? 'โœ“ PASSED' : 'โŒ FAILED'}`); - } - - /** - * Get cache statistics - */ - async getCacheStats() { - try { - this.results.cacheStats = await this.cacheCommand.performExecute({ action: 'stats' }); - console.log(` โœ“ Cache statistics gathered`); - } catch (error) { - console.log(` โš  Could not gather cache stats: ${error.message}`); - } - } - - /** - * Display validation results - */ - displayResults() { - console.log('\n๐Ÿ“Š Performance Validation Summary:'); - console.log('-'.repeat(40)); - - // Test results - console.log(`Test Status: ${this.results.passed ? 'โœ… PASSED' : 'โŒ FAILED'}`); - console.log(`Performance Improvement: ${this.results.improvement.toFixed(1)}%`); - console.log(`Required Improvement: >50%`); - - // Timing breakdown - console.log('\nTiming Breakdown:'); - console.log(` First run (no cache): ${this.results.firstRun.executionTime}ms`); - console.log(` Second run (with cache): ${this.results.secondRun.executionTime}ms`); - console.log(` Time saved: ${this.results.firstRun.executionTime - this.results.secondRun.executionTime}ms`); - - // Cache effectiveness - if (this.results.cacheStats && this.results.cacheStats.stats) { - const stats = this.results.cacheStats.stats; - console.log('\nCache Statistics:'); - console.log(` Cache files: ${stats.files.count}`); - console.log(` Hit rate: ${stats.performance.hitRate}%`); - console.log(` Cache hits: ${stats.performance.hits}`); - console.log(` Cache misses: ${stats.performance.misses}`); - } - - // Recommendations - console.log('\nRecommendations:'); - if (this.results.passed) { - console.log(' โœ“ Cache is performing excellently'); - console.log(' โœ“ Test execution time reduced significantly'); - console.log(' โœ“ Ready for production use'); - } else { - console.log(' โš  Cache performance may need tuning'); - console.log(' โš  Consider optimizing hash calculation'); - console.log(' โš  Verify cache invalidation logic'); - } - - // Overall status - console.log(`\n๐ŸŽฏ Overall Status: ${this.results.passed ? 'VALIDATION PASSED' : 'VALIDATION FAILED'}`); - - if (this.results.passed) { - console.log('\n๐ŸŽ‰ TestCache successfully provides >50% performance improvement!'); - console.log('P1.T015 implementation validated and ready for deployment.'); - } else { - console.log('\n๐Ÿ”ง TestCache needs optimization to meet >50% improvement requirement.'); - console.log('Please review cache implementation and test again.'); - } - } -} - -/** - * CLI entry point - */ -async function main() { - const validator = new CachePerformanceValidator(); - const passed = await validator.validate(); - - process.exit(passed ? 0 : 1); -} - -// Run if called directly -if (require.main === module) { - main().catch(error => { - console.error('Fatal error:', error); - process.exit(1); - }); -} - -module.exports = CachePerformanceValidator; \ No newline at end of file diff --git a/test/test-diff-engine.js b/test/test-diff-engine.js index 7e63387..8826d07 100644 --- a/test/test-diff-engine.js +++ b/test/test-diff-engine.js @@ -1,6 +1,6 @@ -const test = require('node:test'); -const assert = require('node:assert'); -const DiffEngine = require('../build/lib/DiffEngine'); +import test from 'node:test'; +import assert from 'node:assert'; +import DiffEngine from '../build/lib/DiffEngine.js'; test('DiffEngine - Class Structure and Instantiation', async (t) => { await t.test('should instantiate DiffEngine successfully', () => { @@ -18,7 +18,7 @@ test('DiffEngine - Class Structure and Instantiation', async (t) => { customOption: 'test' }; const engine = new DiffEngine(config); - + assert(engine.config.includeData === true, 'Should accept includeData config'); assert(Array.isArray(engine.config.excludeSchemas), 'Should have excludeSchemas array'); assert(engine.config.excludeSchemas.includes('test_schema'), 'Should include custom schema'); @@ -27,10 +27,13 @@ test('DiffEngine - Class Structure and Instantiation', async (t) => { await t.test('should have default configuration values', () => { const engine = new DiffEngine(); - + assert(engine.config.includeData === false, 'Default includeData should be false'); assert(Array.isArray(engine.config.excludeSchemas), 'Should have default excludeSchemas'); - assert(engine.config.includeDropStatements === true, 'Default includeDropStatements should be true'); + assert( + engine.config.includeDropStatements === true, + 'Default includeDropStatements should be true' + ); assert(engine.config.sortOutput === true, 'Default sortOutput should be true'); }); }); @@ -76,8 +79,8 @@ test('DiffEngine - EventEmitter Functionality', async (t) => { await engine.generateDiff(mockCurrentDb, mockDesiredDb); assert(progressEvents.length > 0, 'Should emit at least one progress event'); - - const initEvent = progressEvents.find(e => e.step === 'initializing'); + + const initEvent = progressEvents.find((e) => e.step === 'initializing'); assert(initEvent !== undefined, 'Should emit initializing progress event'); assert(typeof initEvent.message === 'string', 'Progress event should include message'); assert(initEvent.timestamp instanceof Date, 'Progress event should include timestamp'); @@ -100,7 +103,10 @@ test('DiffEngine - EventEmitter Functionality', async (t) => { assert(completeEventReceived, 'Complete event should be emitted'); assert(completeEventData.diff !== null, 'Complete event should include diff result'); - assert(typeof completeEventData.duration === 'number', 'Complete event should include duration'); + assert( + typeof completeEventData.duration === 'number', + 'Complete event should include duration' + ); assert(completeEventData.timestamp instanceof Date, 'Complete event should include timestamp'); }); @@ -131,30 +137,30 @@ test('DiffEngine - EventEmitter Functionality', async (t) => { test('DiffEngine - State Management', async (t) => { await t.test('should track running state correctly', async () => { const engine = new DiffEngine(); - + assert(engine.isGenerating() === false, 'Should not be running initially'); - + const mockCurrentDb = { host: 'localhost', database: 'test_current' }; const mockDesiredDb = { host: 'localhost', database: 'test_desired' }; const diffPromise = engine.generateDiff(mockCurrentDb, mockDesiredDb); - + // Note: Due to async nature, we can't reliably test isRunning === true // in the middle of execution, but we can test the final state - + await diffPromise; assert(engine.isGenerating() === false, 'Should not be running after completion'); }); await t.test('should prevent concurrent diff generation', async () => { const engine = new DiffEngine(); - + const mockCurrentDb = { host: 'localhost', database: 'test_current' }; const mockDesiredDb = { host: 'localhost', database: 'test_desired' }; // Manually set isRunning to simulate a running diff engine.isRunning = true; - + let secondDiffError = null; try { await engine.generateDiff(mockCurrentDb, mockDesiredDb); @@ -168,20 +174,23 @@ test('DiffEngine - State Management', async (t) => { // Verify the concurrent execution was prevented assert(secondDiffError !== null, 'Should have caught an error'); - assert(secondDiffError.message.includes('already running'), 'Should indicate engine is already running'); + assert( + secondDiffError.message.includes('already running'), + 'Should indicate engine is already running' + ); }); await t.test('should store and return last diff result', async () => { const engine = new DiffEngine(); - + assert(engine.getLastDiff() === null, 'Should return null initially'); - + const mockCurrentDb = { host: 'localhost', database: 'test_current' }; const mockDesiredDb = { host: 'localhost', database: 'test_desired' }; const result = await engine.generateDiff(mockCurrentDb, mockDesiredDb); - + assert(engine.getLastDiff() !== null, 'Should store last diff result'); assert.deepStrictEqual(engine.getLastDiff(), result, 'Should return the same result object'); }); -}); \ No newline at end of file +}); diff --git a/test/test-migration-metadata.js b/test/test-migration-metadata.js index 354c916..62dacfc 100644 --- a/test/test-migration-metadata.js +++ b/test/test-migration-metadata.js @@ -1,8 +1,12 @@ #!/usr/bin/env node -const fs = require('fs'); -const path = require('path'); -const MigrationMetadata = require('../src/lib/MigrationMetadata'); +import fs from 'fs'; +import path from 'path'; +import { fileURLToPath } from 'url'; +import MigrationMetadata from '../src/lib/MigrationMetadata.js'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = path.dirname(__filename); /** * Test suite for MigrationMetadata class @@ -13,7 +17,7 @@ class MigrationMetadataTests { this.passCount = 0; this.failCount = 0; } - + setup() { // Clean up any existing test directory if (fs.existsSync(this.testDir)) { @@ -21,13 +25,13 @@ class MigrationMetadataTests { } fs.mkdirSync(this.testDir, { recursive: true }); } - + cleanup() { if (fs.existsSync(this.testDir)) { fs.rmSync(this.testDir, { recursive: true }); } } - + assert(condition, message) { if (condition) { console.log(`โœ… PASS: ${message}`); @@ -37,7 +41,7 @@ class MigrationMetadataTests { this.failCount++; } } - + assertThrows(fn, expectedMessage, testMessage) { try { fn(); @@ -53,69 +57,69 @@ class MigrationMetadataTests { } } } - + testConstructor() { console.log('\n๐Ÿงช Testing constructor...'); - + // Valid constructor const migrationPath = path.join(this.testDir, 'migration1'); const metadata = new MigrationMetadata(migrationPath); this.assert(metadata.migrationPath === migrationPath, 'Constructor sets migration path'); - + // Invalid constructors this.assertThrows( () => new MigrationMetadata(), 'migrationPath is required', 'Constructor requires migrationPath' ); - + this.assertThrows( () => new MigrationMetadata(123), 'must be a string', 'Constructor validates string type' ); } - + testCreateDefault() { console.log('\n๐Ÿงช Testing createDefault...'); - + const id = '20250828_123456'; const name = 'test_migration'; const metadata = MigrationMetadata.createDefault(id, name); - + this.assert(metadata.id === id, 'createDefault sets ID'); this.assert(metadata.name === name, 'createDefault sets name'); this.assert(metadata.status === 'pending', 'createDefault sets pending status'); this.assert(metadata.testing.tested_at === null, 'createDefault initializes testing'); this.assert(metadata.promotion.promoted_at === null, 'createDefault initializes promotion'); this.assert(typeof metadata.generated === 'string', 'createDefault sets generated timestamp'); - + // Test validation of created metadata const migrationPath = path.join(this.testDir, 'migration2'); const metadataManager = new MigrationMetadata(migrationPath); metadataManager.validate(metadata); // Should not throw this.assert(true, 'createDefault produces valid metadata'); - + // Invalid parameters this.assertThrows( () => MigrationMetadata.createDefault(), 'id is required', 'createDefault requires id' ); - + this.assertThrows( () => MigrationMetadata.createDefault('test', 123), 'name is required and must be a string', 'createDefault validates name type' ); } - + testValidation() { console.log('\n๐Ÿงช Testing validation...'); - + const migrationPath = path.join(this.testDir, 'migration3'); const metadata = new MigrationMetadata(migrationPath); - + // Valid metadata const validData = { id: '20250828_123456', @@ -132,95 +136,99 @@ class MigrationMetadataTests { promoted_by: null } }; - + metadata.validate(validData); // Should not throw this.assert(true, 'Valid metadata passes validation'); - + // Test required fields this.assertThrows( () => metadata.validate({}), 'id is required', 'Validation catches missing id' ); - + this.assertThrows( () => metadata.validate({ id: '123' }), 'name is required', 'Validation catches missing name' ); - + this.assertThrows( () => metadata.validate({ id: '123', name: 'test' }), 'generated is required', 'Validation catches missing generated' ); - + // Test status validation this.assertThrows( - () => metadata.validate({ - id: '123', - name: 'test', - generated: '2025-08-28T12:34:56.000Z', - status: 'invalid' - }), + () => + metadata.validate({ + id: '123', + name: 'test', + generated: '2025-08-28T12:34:56.000Z', + status: 'invalid' + }), 'status must be one of', 'Validation catches invalid status' ); - + // Test date format validation this.assertThrows( - () => metadata.validate({ - id: '123', - name: 'test', - generated: 'invalid-date', - status: 'pending' - }), + () => + metadata.validate({ + id: '123', + name: 'test', + generated: 'invalid-date', + status: 'pending' + }), 'generated must be a valid ISO 8601', 'Validation catches invalid date format' ); - + // Test testing object validation this.assertThrows( - () => metadata.validate({ - ...validData, - testing: { - tested_at: 'invalid-date' - } - }), + () => + metadata.validate({ + ...validData, + testing: { + tested_at: 'invalid-date' + } + }), 'testing.tested_at must be null or valid ISO 8601', 'Validation catches invalid testing.tested_at' ); - + this.assertThrows( - () => metadata.validate({ - ...validData, - testing: { - tests_passed: -1 - } - }), + () => + metadata.validate({ + ...validData, + testing: { + tests_passed: -1 + } + }), 'testing.tests_passed must be a non-negative integer', 'Validation catches negative tests_passed' ); } - + testReadWrite() { console.log('\n๐Ÿงช Testing read/write operations...'); - + const migrationPath = path.join(this.testDir, 'migration4'); const metadata = new MigrationMetadata(migrationPath); - + const testData = MigrationMetadata.createDefault('20250828_123456', 'test_migration'); - + // Test write metadata.write(testData); this.assert(fs.existsSync(metadata.metadataFile), 'Write creates metadata file'); - + // Test read const readData = metadata.read(); this.assert(readData.id === testData.id, 'Read returns correct id'); this.assert(readData.name === testData.name, 'Read returns correct name'); this.assert(readData.status === testData.status, 'Read returns correct status'); - + // Test reading non-existent file const nonExistentPath = path.join(this.testDir, 'nonexistent'); const nonExistentMetadata = new MigrationMetadata(nonExistentPath); @@ -229,12 +237,12 @@ class MigrationMetadataTests { 'Metadata file not found', 'Read throws on missing file' ); - + // Test reading invalid JSON const invalidJsonPath = path.join(this.testDir, 'invalid-json'); fs.mkdirSync(invalidJsonPath, { recursive: true }); fs.writeFileSync(path.join(invalidJsonPath, 'metadata.json'), '{ invalid json }'); - + const invalidJsonMetadata = new MigrationMetadata(invalidJsonPath); this.assertThrows( () => invalidJsonMetadata.read(), @@ -242,22 +250,22 @@ class MigrationMetadataTests { 'Read throws on invalid JSON' ); } - + testUpdate() { console.log('\n๐Ÿงช Testing update operations...'); - + const migrationPath = path.join(this.testDir, 'migration5'); const metadata = new MigrationMetadata(migrationPath); - + // Create initial metadata const initial = MigrationMetadata.createDefault('20250828_123456', 'test_migration'); metadata.write(initial); - + // Test simple update const updated = metadata.update({ status: 'tested' }); this.assert(updated.status === 'tested', 'Update changes status'); this.assert(updated.id === initial.id, 'Update preserves other fields'); - + // Test nested update const nestedUpdate = metadata.update({ testing: { @@ -265,34 +273,37 @@ class MigrationMetadataTests { tests_passed: 5 } }); - - this.assert(nestedUpdate.testing.tested_at === '2025-08-28T13:00:00.000Z', 'Update handles nested objects'); + + this.assert( + nestedUpdate.testing.tested_at === '2025-08-28T13:00:00.000Z', + 'Update handles nested objects' + ); this.assert(nestedUpdate.testing.tests_failed === 0, 'Update preserves nested fields'); - + // Test invalid update this.assertThrows( () => metadata.update({ status: 'invalid' }), 'status must be one of', 'Update validates changes' ); - + this.assertThrows( () => metadata.update(), 'Updates must be an object', 'Update requires object parameter' ); } - + testLifecycle() { console.log('\n๐Ÿงช Testing full lifecycle...'); - + const migrationPath = path.join(this.testDir, 'migration6'); const metadata = new MigrationMetadata(migrationPath); - + // 1. Create new migration const initial = MigrationMetadata.createDefault('20250828_140000', 'user_authentication'); metadata.write(initial); - + // 2. Update to tested status metadata.update({ status: 'tested', @@ -302,7 +313,7 @@ class MigrationMetadataTests { tests_failed: 0 } }); - + // 3. Promote to production const final = metadata.update({ status: 'promoted', @@ -311,38 +322,37 @@ class MigrationMetadataTests { promoted_by: 'admin@example.com' } }); - + this.assert(final.status === 'promoted', 'Lifecycle reaches promoted status'); this.assert(final.testing.tests_passed === 12, 'Lifecycle preserves test results'); this.assert(final.promotion.promoted_by === 'admin@example.com', 'Lifecycle tracks promotion'); - + // Verify file persistence const reread = metadata.read(); this.assert(reread.status === 'promoted', 'Lifecycle changes persist to disk'); } - + /** * Validate ISO 8601 date format - * @param {string} dateString + * @param {string} dateString * @returns {boolean} * @private */ _isValidISO8601(dateString) { const date = new Date(dateString); - return date instanceof Date && !isNaN(date.getTime()) && - dateString === date.toISOString(); + return date instanceof Date && !isNaN(date.getTime()) && dateString === date.toISOString(); } - + /** * Deep merge helper for nested object updates - * @param {Object} target - * @param {Object} source + * @param {Object} target + * @param {Object} source * @returns {Object} * @private */ _deepMerge(target, source) { const result = { ...target }; - + for (const key in source) { if (source.hasOwnProperty(key)) { if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) { @@ -352,15 +362,15 @@ class MigrationMetadataTests { } } } - + return result; } - + run() { console.log('๐Ÿš€ Running MigrationMetadata tests...\n'); - + this.setup(); - + try { this.testConstructor(); this.testCreateDefault(); @@ -368,9 +378,9 @@ class MigrationMetadataTests { this.testReadWrite(); this.testUpdate(); this.testLifecycle(); - + console.log(`\n๐Ÿ“Š Test Results: ${this.passCount} passed, ${this.failCount} failed`); - + if (this.failCount === 0) { console.log('๐ŸŽ‰ All tests passed!'); process.exit(0); @@ -385,9 +395,9 @@ class MigrationMetadataTests { } // Run tests if called directly -if (require.main === module) { +if (import.meta.url === `file://${process.argv[1]}`) { const tests = new MigrationMetadataTests(); tests.run(); } -module.exports = MigrationMetadataTests; \ No newline at end of file +export default MigrationMetadataTests; diff --git a/test/test-temp-db-management.js b/test/test-temp-db-management.js index 941f99e..9975dbc 100644 --- a/test/test-temp-db-management.js +++ b/test/test-temp-db-management.js @@ -1,6 +1,6 @@ /** * Test for temp database management functionality in DiffEngine - * + * * This test verifies: * - createTempDatabase creates unique temp DB * - cleanupTempDatabase drops temp DB @@ -8,7 +8,7 @@ * - Resource tracking prevents orphans */ -const DiffEngine = require('../src/lib/DiffEngine'); +import DiffEngine from '../src/lib/DiffEngine.js'; async function runTempDbTests() { console.log('๐Ÿงช Testing Temp Database Management...\n'); @@ -43,7 +43,9 @@ async function runTempDbTests() { `; const applyResult = await diffEngine.applySchemaToTemp(dbUrl, testSchema); - console.log(`โœ… Schema applied successfully. Statements executed: ${applyResult.statementsExecuted}`); + console.log( + `โœ… Schema applied successfully. Statements executed: ${applyResult.statementsExecuted}` + ); // Test 3: Check tracking console.log('\n๐Ÿ“‹ Test 3: Checking temp database tracking...'); @@ -65,14 +67,13 @@ async function runTempDbTests() { // Test 6: Cleanup all remaining databases console.log('\n๐Ÿงน Test 6: Cleaning up all remaining databases...'); const cleanupSummary = await diffEngine.cleanupAllTempDatabases(); - console.log(`โœ… Cleanup summary:`, cleanupSummary); + console.log('โœ… Cleanup summary:', cleanupSummary); console.log('\n๐ŸŽ‰ All temp database management tests passed!\n'); - } catch (error) { console.error('\n๐Ÿ’ฅ Test failed:', error.message); console.error('Stack trace:', error.stack); - + // Attempt cleanup even if tests fail try { console.log('\n๐Ÿงน Attempting emergency cleanup...'); @@ -84,14 +85,16 @@ async function runTempDbTests() { } // Run tests if this file is executed directly -if (require.main === module) { - runTempDbTests().then(() => { - console.log('โœ… Test execution complete'); - process.exit(0); - }).catch((error) => { - console.error('โŒ Test execution failed:', error); - process.exit(1); - }); +if (import.meta.url === `file://${process.argv[1]}`) { + runTempDbTests() + .then(() => { + console.log('โœ… Test execution complete'); + process.exit(0); + }) + .catch((error) => { + console.error('โŒ Test execution failed:', error); + process.exit(1); + }); } -module.exports = { runTempDbTests }; \ No newline at end of file +export default { runTempDbTests }; diff --git a/test/unit/data-core/DiffEngine.test.js b/test/unit/data-core/DiffEngine.test.js new file mode 100644 index 0000000..5cdca5b --- /dev/null +++ b/test/unit/data-core/DiffEngine.test.js @@ -0,0 +1,723 @@ +/** + * Unit tests for DiffEngine schema comparison + * + * Tests the DiffEngine functionality including: + * - Schema state management and comparison + * - Migration operation generation and prioritization + * - Checksum calculation and validation + * - Destructive operation detection + * - Port/adapter pattern validation + */ + +import { describe, it, expect, beforeEach, vi } from 'vitest'; +import { + DiffEngine, + SchemaState, + MigrationOperation, + OperationType +} from '../../../packages/data-core/lib/DiffEngine.js'; +import { CryptoPort } from '../../../packages/data-core/ports/index.js'; + +/** + * Mock Crypto adapter for testing + */ +class MockCryptoAdapter extends CryptoPort { + constructor() { + super(); + this.hashCounter = 0; + } + + hash(data, algorithm = 'sha256') { + // Simple mock hash - in real tests you'd use actual crypto + this.hashCounter++; + return `mock_hash_${this.hashCounter}_${data.slice(0, 10)}`; + } +} + +describe('OperationType enum', () => { + it('should have correct numeric values for performance', () => { + expect(typeof OperationType.CREATE_TABLE).toBe('number'); + expect(typeof OperationType.DROP_TABLE).toBe('number'); + expect(typeof OperationType.ALTER_TABLE).toBe('number'); + expect(typeof OperationType.CREATE_INDEX).toBe('number'); + expect(typeof OperationType.DROP_INDEX).toBe('number'); + expect(typeof OperationType.CREATE_FUNCTION).toBe('number'); + expect(typeof OperationType.DROP_FUNCTION).toBe('number'); + expect(typeof OperationType.CREATE_VIEW).toBe('number'); + expect(typeof OperationType.DROP_VIEW).toBe('number'); + expect(typeof OperationType.INSERT_DATA).toBe('number'); + expect(typeof OperationType.UPDATE_DATA).toBe('number'); + expect(typeof OperationType.DELETE_DATA).toBe('number'); + }); + + it('should have distinct values', () => { + const values = Object.values(OperationType); + const uniqueValues = new Set(values); + expect(uniqueValues.size).toBe(values.length); + }); +}); + +describe('MigrationOperation', () => { + let mockCrypto; + + beforeEach(() => { + mockCrypto = new MockCryptoAdapter(); + }); + + describe('constructor and basic properties', () => { + it('should create operation with correct properties', () => { + const op = new MigrationOperation( + OperationType.CREATE_TABLE, + 'users', + 'CREATE TABLE users (id INT)', + { comment: 'User table' } + ); + + expect(op.type).toBe(OperationType.CREATE_TABLE); + expect(op.objectName).toBe('users'); + expect(op.sql).toBe('CREATE TABLE users (id INT)'); + expect(op.metadata).toEqual({ comment: 'User table' }); + expect(op.hash).toBeNull(); + }); + + it('should handle empty metadata', () => { + const op = new MigrationOperation( + OperationType.DROP_TABLE, + 'old_table', + 'DROP TABLE old_table' + ); + + expect(op.metadata).toEqual({}); + }); + }); + + describe('hash generation', () => { + it('should generate hash using crypto port', () => { + const op = new MigrationOperation( + OperationType.CREATE_TABLE, + 'test', + 'CREATE TABLE test (id INT)' + ); + + const hash = op.generateHash(mockCrypto); + + expect(hash).toBeTruthy(); + expect(op.hash).toBe(hash); + expect(hash).toContain('mock_hash_'); + }); + + it('should generate consistent hashes for same operation', () => { + const op1 = new MigrationOperation( + OperationType.CREATE_TABLE, + 'test', + 'CREATE TABLE test (id INT)' + ); + const op2 = new MigrationOperation( + OperationType.CREATE_TABLE, + 'test', + 'CREATE TABLE test (id INT)' + ); + + const hash1 = op1.generateHash(mockCrypto); + const hash2 = op2.generateHash(mockCrypto); + + // Note: In a real crypto implementation, these would be identical + // Our mock generates sequential hashes, so we just verify both are generated + expect(hash1).toBeTruthy(); + expect(hash2).toBeTruthy(); + }); + + it('should include type, name, and SQL in hash data', () => { + const op = new MigrationOperation( + OperationType.ALTER_TABLE, + 'users', + 'ALTER TABLE users ADD COLUMN name VARCHAR(100)' + ); + const spy = vi.spyOn(mockCrypto, 'hash'); + + op.generateHash(mockCrypto); + + expect(spy).toHaveBeenCalledWith('2:users:ALTER TABLE users ADD COLUMN name VARCHAR(100)'); + }); + }); + + describe('destructive operation detection', () => { + it('should identify destructive operations', () => { + const destructiveOps = [ + new MigrationOperation(OperationType.DROP_TABLE, 'test', 'DROP TABLE test'), + new MigrationOperation(OperationType.DROP_INDEX, 'test', 'DROP INDEX test'), + new MigrationOperation(OperationType.DROP_FUNCTION, 'test', 'DROP FUNCTION test'), + new MigrationOperation(OperationType.DROP_VIEW, 'test', 'DROP VIEW test'), + new MigrationOperation(OperationType.DELETE_DATA, 'test', 'DELETE FROM test') + ]; + + destructiveOps.forEach((op) => { + expect(op.isDestructive()).toBe(true); + }); + }); + + it('should identify non-destructive operations', () => { + const nonDestructiveOps = [ + new MigrationOperation(OperationType.CREATE_TABLE, 'test', 'CREATE TABLE test'), + new MigrationOperation(OperationType.CREATE_INDEX, 'test', 'CREATE INDEX test'), + new MigrationOperation(OperationType.CREATE_FUNCTION, 'test', 'CREATE FUNCTION test'), + new MigrationOperation(OperationType.CREATE_VIEW, 'test', 'CREATE VIEW test'), + new MigrationOperation(OperationType.ALTER_TABLE, 'test', 'ALTER TABLE test'), + new MigrationOperation(OperationType.INSERT_DATA, 'test', 'INSERT INTO test'), + new MigrationOperation(OperationType.UPDATE_DATA, 'test', 'UPDATE test') + ]; + + nonDestructiveOps.forEach((op) => { + expect(op.isDestructive()).toBe(false); + }); + }); + }); + + describe('operation priority', () => { + it('should return correct priorities for execution ordering', () => { + const operations = [ + new MigrationOperation(OperationType.DROP_VIEW, 'test', ''), + new MigrationOperation(OperationType.DROP_FUNCTION, 'test', ''), + new MigrationOperation(OperationType.DROP_INDEX, 'test', ''), + new MigrationOperation(OperationType.ALTER_TABLE, 'test', ''), + new MigrationOperation(OperationType.DROP_TABLE, 'test', ''), + new MigrationOperation(OperationType.CREATE_TABLE, 'test', ''), + new MigrationOperation(OperationType.CREATE_FUNCTION, 'test', ''), + new MigrationOperation(OperationType.CREATE_VIEW, 'test', ''), + new MigrationOperation(OperationType.CREATE_INDEX, 'test', ''), + new MigrationOperation(OperationType.INSERT_DATA, 'test', ''), + new MigrationOperation(OperationType.UPDATE_DATA, 'test', ''), + new MigrationOperation(OperationType.DELETE_DATA, 'test', '') + ]; + + const priorities = operations.map((op) => op.getPriority()); + const expectedPriorities = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; + + expect(priorities).toEqual(expectedPriorities); + }); + + it('should handle unknown operation types', () => { + const op = new MigrationOperation(999, 'test', 'UNKNOWN OPERATION'); + expect(op.getPriority()).toBe(50); + }); + + it('should sort operations correctly by priority', () => { + const operations = [ + new MigrationOperation(OperationType.CREATE_TABLE, 'test', ''), + new MigrationOperation(OperationType.DROP_VIEW, 'test', ''), + new MigrationOperation(OperationType.INSERT_DATA, 'test', ''), + new MigrationOperation(OperationType.ALTER_TABLE, 'test', '') + ]; + + operations.sort((a, b) => a.getPriority() - b.getPriority()); + + expect(operations[0].type).toBe(OperationType.DROP_VIEW); + expect(operations[1].type).toBe(OperationType.ALTER_TABLE); + expect(operations[2].type).toBe(OperationType.CREATE_TABLE); + expect(operations[3].type).toBe(OperationType.INSERT_DATA); + }); + }); +}); + +describe('SchemaState', () => { + let mockCrypto; + let schemaState; + + beforeEach(() => { + mockCrypto = new MockCryptoAdapter(); + schemaState = new SchemaState(); + }); + + describe('constructor and initialization', () => { + it('should initialize with empty state', () => { + expect(schemaState.objects.tables).toBeInstanceOf(Map); + expect(schemaState.objects.views).toBeInstanceOf(Map); + expect(schemaState.objects.functions).toBeInstanceOf(Map); + expect(schemaState.objects.indexes).toBeInstanceOf(Map); + expect(schemaState.checksum).toBe(''); + }); + + it('should accept initial objects', () => { + const initialObjects = { + tables: new Map([['users', { name: 'users', columns: ['id', 'name'] }]]), + customType: new Map([['custom', { definition: 'test' }]]) + }; + + const state = new SchemaState(initialObjects, 'test_checksum'); + + expect(state.objects.tables.get('users')).toEqual({ name: 'users', columns: ['id', 'name'] }); + expect(state.objects.customType.get('custom')).toEqual({ definition: 'test' }); + expect(state.checksum).toBe('test_checksum'); + }); + }); + + describe('object management', () => { + it('should add objects correctly', () => { + const userTable = { name: 'users', columns: ['id', 'name', 'email'] }; + schemaState.addObject('tables', 'users', userTable); + + expect(schemaState.objects.tables.get('users')).toBe(userTable); + }); + + it('should create new object type if needed', () => { + const customDefinition = { type: 'custom', definition: 'test' }; + schemaState.addObject('customTypes', 'test_type', customDefinition); + + expect(schemaState.objects.customTypes).toBeInstanceOf(Map); + expect(schemaState.objects.customTypes.get('test_type')).toBe(customDefinition); + }); + + it('should retrieve objects correctly', () => { + const viewDef = { name: 'user_view', query: 'SELECT * FROM users' }; + schemaState.addObject('views', 'user_view', viewDef); + + expect(schemaState.getObject('views', 'user_view')).toBe(viewDef); + expect(schemaState.getObject('views', 'nonexistent')).toBeUndefined(); + expect(schemaState.getObject('nonexistent_type', 'test')).toBeUndefined(); + }); + + it('should check object existence correctly', () => { + schemaState.addObject('functions', 'get_user', { name: 'get_user' }); + + expect(schemaState.hasObject('functions', 'get_user')).toBe(true); + expect(schemaState.hasObject('functions', 'nonexistent')).toBe(false); + expect(schemaState.hasObject('nonexistent_type', 'test')).toBe(false); + }); + + it('should get object names correctly', () => { + schemaState.addObject('indexes', 'idx_users_email', { name: 'idx_users_email' }); + schemaState.addObject('indexes', 'idx_users_name', { name: 'idx_users_name' }); + + const names = schemaState.getObjectNames('indexes'); + expect(names).toHaveLength(2); + expect(names).toContain('idx_users_email'); + expect(names).toContain('idx_users_name'); + }); + + it('should handle empty object types', () => { + expect(schemaState.getObjectNames('nonexistent')).toEqual([]); + }); + }); + + describe('checksum generation', () => { + it('should generate checksum for empty state', () => { + const checksum = schemaState.generateChecksum(mockCrypto); + + expect(checksum).toBeTruthy(); + expect(schemaState.checksum).toBe(checksum); + }); + + it('should generate different checksums for different states', () => { + const state1 = new SchemaState(); + const state2 = new SchemaState(); + + state1.addObject('tables', 'users', { name: 'users' }); + state2.addObject('tables', 'orders', { name: 'orders' }); + + const checksum1 = state1.generateChecksum(mockCrypto); + const checksum2 = state2.generateChecksum(mockCrypto); + + expect(checksum1).not.toBe(checksum2); + }); + + it('should handle Maps in JSON serialization', () => { + schemaState.addObject('tables', 'users', { name: 'users', columns: ['id'] }); + + const spy = vi.spyOn(mockCrypto, 'hash'); + schemaState.generateChecksum(mockCrypto); + + expect(spy).toHaveBeenCalled(); + const serializedData = spy.mock.calls[0][0]; + expect(serializedData).toContain('users'); + expect(serializedData).toContain('tables'); + }); + }); +}); + +describe('DiffEngine', () => { + let mockCrypto; + let diffEngine; + let currentState; + let targetState; + + beforeEach(() => { + mockCrypto = new MockCryptoAdapter(); + diffEngine = new DiffEngine(mockCrypto); + currentState = new SchemaState(); + targetState = new SchemaState(); + }); + + describe('constructor and port validation', () => { + it('should validate CryptoPort on construction', () => { + expect(() => new DiffEngine(mockCrypto)).not.toThrow(); + expect(diffEngine.cryptoPort).toBe(mockCrypto); + }); + + it('should throw error for invalid port', () => { + const invalidPort = { hash: () => {} }; // Not instance of CryptoPort + + expect(() => new DiffEngine(invalidPort)).toThrow('Port must be instance of CryptoPort'); + }); + }); + + describe('basic diff calculation', () => { + it('should return empty operations for identical states', () => { + currentState.addObject('tables', 'users', { name: 'users', columns: ['id'] }); + targetState.addObject('tables', 'users', { name: 'users', columns: ['id'] }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + expect(operations).toHaveLength(0); + }); + + it('should generate CREATE operations for new objects', () => { + targetState.addObject('tables', 'users', { + name: 'users', + sql: 'CREATE TABLE users (id SERIAL PRIMARY KEY)' + }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].type).toBe(OperationType.CREATE_TABLE); + expect(operations[0].objectName).toBe('users'); + expect(operations[0].sql).toBe('CREATE TABLE users (id SERIAL PRIMARY KEY)'); + }); + + it('should generate DROP operations for removed objects', () => { + currentState.addObject('tables', 'old_table', { name: 'old_table' }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].type).toBe(OperationType.DROP_TABLE); + expect(operations[0].objectName).toBe('old_table'); + expect(operations[0].sql).toBe('DROP TABLE IF EXISTS old_table'); + }); + + it('should generate ALTER operations for modified objects', () => { + currentState.addObject('tables', 'users', { name: 'users', version: 1 }); + targetState.addObject('tables', 'users', { + name: 'users', + version: 2, + sql: 'ALTER TABLE users ADD COLUMN email VARCHAR(255)' + }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].type).toBe(OperationType.ALTER_TABLE); + expect(operations[0].objectName).toBe('users'); + expect(operations[0].sql).toBe('ALTER TABLE users ADD COLUMN email VARCHAR(255)'); + }); + }); + + describe('multi-object type handling', () => { + it('should handle multiple object types correctly', () => { + // Add various object types to target state + targetState.addObject('tables', 'users', { sql: 'CREATE TABLE users' }); + targetState.addObject('views', 'user_view', { sql: 'CREATE VIEW user_view' }); + targetState.addObject('functions', 'get_user', { sql: 'CREATE FUNCTION get_user' }); + targetState.addObject('indexes', 'idx_users', { sql: 'CREATE INDEX idx_users' }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(4); + + const types = operations.map((op) => op.type).sort(); + const expectedTypes = [ + OperationType.CREATE_TABLE, + OperationType.CREATE_VIEW, + OperationType.CREATE_FUNCTION, + OperationType.CREATE_INDEX + ].sort(); + + expect(types).toEqual(expectedTypes); + }); + + it('should handle complex mix of operations', () => { + // Current state + currentState.addObject('tables', 'old_table', { name: 'old_table' }); + currentState.addObject('views', 'shared_view', { name: 'shared_view', version: 1 }); + currentState.addObject('functions', 'old_function', { name: 'old_function' }); + + // Target state + targetState.addObject('tables', 'new_table', { sql: 'CREATE TABLE new_table' }); + targetState.addObject('views', 'shared_view', { + name: 'shared_view', + version: 2, + sql: 'ALTER VIEW' + }); + targetState.addObject('indexes', 'new_index', { sql: 'CREATE INDEX new_index' }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + // Should have: DROP old_table, DROP old_function, CREATE new_table, + // ALTER shared_view, CREATE new_index + expect(operations).toHaveLength(5); + + const dropOps = operations.filter((op) => + [OperationType.DROP_TABLE, OperationType.DROP_FUNCTION].includes(op.type) + ); + expect(dropOps).toHaveLength(2); + + const createOps = operations.filter((op) => + [OperationType.CREATE_TABLE, OperationType.CREATE_INDEX].includes(op.type) + ); + expect(createOps).toHaveLength(2); + + const alterOps = operations.filter((op) => op.type === OperationType.ALTER_TABLE); + expect(alterOps).toHaveLength(1); + }); + }); + + describe('operation ordering and prioritization', () => { + it('should sort operations by priority', () => { + // Add operations that will create mixed priorities + currentState.addObject('views', 'old_view', { name: 'old_view' }); + currentState.addObject('tables', 'old_table', { name: 'old_table' }); + + targetState.addObject('tables', 'new_table', { sql: 'CREATE TABLE new_table' }); + targetState.addObject('indexes', 'new_index', { sql: 'CREATE INDEX new_index' }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + // Should be ordered: DROP_VIEW (0), DROP_TABLE (4), CREATE_TABLE (5), CREATE_INDEX (8) + expect(operations[0].type).toBe(OperationType.DROP_VIEW); + expect(operations[1].type).toBe(OperationType.DROP_TABLE); + expect(operations[2].type).toBe(OperationType.CREATE_TABLE); + expect(operations[3].type).toBe(OperationType.CREATE_INDEX); + }); + + it('should generate hashes for all operations', () => { + targetState.addObject('tables', 'users', { sql: 'CREATE TABLE users' }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].hash).toBeTruthy(); + expect(operations[0].hash).toContain('mock_hash_'); + }); + }); + + describe('drop operation generation', () => { + it('should generate correct drop operations for all types', () => { + currentState.addObject('tables', 'drop_table', { name: 'drop_table' }); + currentState.addObject('views', 'drop_view', { name: 'drop_view' }); + currentState.addObject('functions', 'drop_function', { name: 'drop_function' }); + currentState.addObject('indexes', 'drop_index', { name: 'drop_index' }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(4); + + const tableOp = operations.find((op) => op.objectName === 'drop_table'); + expect(tableOp.type).toBe(OperationType.DROP_TABLE); + expect(tableOp.sql).toBe('DROP TABLE IF EXISTS drop_table'); + + const viewOp = operations.find((op) => op.objectName === 'drop_view'); + expect(viewOp.type).toBe(OperationType.DROP_VIEW); + expect(viewOp.sql).toBe('DROP VIEW IF EXISTS drop_view'); + + const functionOp = operations.find((op) => op.objectName === 'drop_function'); + expect(functionOp.type).toBe(OperationType.DROP_FUNCTION); + expect(functionOp.sql).toBe('DROP FUNCTION IF EXISTS drop_function'); + + const indexOp = operations.find((op) => op.objectName === 'drop_index'); + expect(indexOp.type).toBe(OperationType.DROP_INDEX); + expect(indexOp.sql).toBe('DROP INDEX IF EXISTS drop_index'); + }); + + it('should include original definition in drop metadata', () => { + const originalDef = { name: 'test_table', columns: ['id', 'name'] }; + currentState.addObject('tables', 'test_table', originalDef); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].metadata.originalDefinition).toBe(originalDef); + }); + }); + + describe('create operation generation', () => { + it('should use provided SQL for create operations', () => { + const tableDef = { + name: 'users', + sql: 'CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(100))' + }; + targetState.addObject('tables', 'users', tableDef); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].sql).toBe(tableDef.sql); + }); + + it('should generate default SQL when not provided', () => { + targetState.addObject('tables', 'test_table', { name: 'test_table' }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].sql).toBe('CREATE TABLE test_table'); + }); + + it('should include definition in create metadata', () => { + const definition = { name: 'test_view', query: 'SELECT * FROM users' }; + targetState.addObject('views', 'test_view', definition); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].metadata.definition).toBe(definition); + }); + }); + + describe('alter operation generation', () => { + it('should generate alter operations with both definitions', () => { + const currentDef = { name: 'users', version: 1, columns: ['id'] }; + const targetDef = { + name: 'users', + version: 2, + columns: ['id', 'name'], + sql: 'ALTER TABLE users ADD COLUMN name VARCHAR(100)' + }; + + currentState.addObject('tables', 'users', currentDef); + targetState.addObject('tables', 'users', targetDef); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].type).toBe(OperationType.ALTER_TABLE); + expect(operations[0].sql).toBe(targetDef.sql); + expect(operations[0].metadata.currentDefinition).toBe(currentDef); + expect(operations[0].metadata.targetDefinition).toBe(targetDef); + expect(operations[0].metadata.changeType).toBe('modify'); + }); + + it('should generate default alter SQL when not provided', () => { + currentState.addObject('functions', 'test_func', { version: 1 }); + targetState.addObject('functions', 'test_func', { version: 2 }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + + expect(operations).toHaveLength(1); + expect(operations[0].sql).toBe('-- ALTER FUNCTION test_func'); + }); + }); + + describe('definition equality comparison', () => { + it('should detect identical definitions', () => { + const definition = { name: 'test', columns: ['id', 'name'] }; + + currentState.addObject('tables', 'test', definition); + targetState.addObject('tables', 'test', definition); + + const operations = diffEngine.calculateDiff(currentState, targetState); + expect(operations).toHaveLength(0); + }); + + it('should detect different definitions', () => { + currentState.addObject('tables', 'test', { name: 'test', version: 1 }); + targetState.addObject('tables', 'test', { name: 'test', version: 2 }); + + const operations = diffEngine.calculateDiff(currentState, targetState); + expect(operations).toHaveLength(1); + expect(operations[0].type).toBe(OperationType.ALTER_TABLE); + }); + + it('should use hash-based comparison', () => { + const spy = vi.spyOn(mockCrypto, 'hash'); + + currentState.addObject('tables', 'test', { complex: { nested: { data: true } } }); + targetState.addObject('tables', 'test', { complex: { nested: { data: false } } }); + + diffEngine.calculateDiff(currentState, targetState); + + // Should call hash at least twice for comparison + expect(spy.mock.calls.length).toBeGreaterThanOrEqual(2); + }); + }); + + describe('optimization', () => { + it('should optimize redundant operations', () => { + const operations = [ + new MigrationOperation(OperationType.CREATE_TABLE, 'users', 'CREATE TABLE users'), + new MigrationOperation(OperationType.CREATE_TABLE, 'users', 'CREATE TABLE users'), // duplicate + new MigrationOperation(OperationType.DROP_TABLE, 'old_table', 'DROP TABLE old_table'), + new MigrationOperation(OperationType.DROP_TABLE, 'old_table', 'DROP TABLE old_table') // duplicate + ]; + + const optimized = diffEngine.optimizeOperations(operations); + + expect(optimized).toHaveLength(2); + expect(optimized[0].objectName).toBe('users'); + expect(optimized[1].objectName).toBe('old_table'); + }); + + it('should preserve operation order during optimization', () => { + const operations = [ + new MigrationOperation(OperationType.DROP_TABLE, 'first', ''), + new MigrationOperation(OperationType.CREATE_TABLE, 'second', ''), + new MigrationOperation(OperationType.DROP_TABLE, 'first', ''), // duplicate + new MigrationOperation(OperationType.ALTER_TABLE, 'third', '') + ]; + + const optimized = diffEngine.optimizeOperations(operations); + + expect(optimized).toHaveLength(3); + expect(optimized[0].objectName).toBe('first'); + expect(optimized[1].objectName).toBe('second'); + expect(optimized[2].objectName).toBe('third'); + }); + + it('should handle empty operations list', () => { + const optimized = diffEngine.optimizeOperations([]); + expect(optimized).toEqual([]); + }); + }); + + describe('edge cases and error handling', () => { + it('should handle missing object types gracefully', () => { + const stateWithUndefined = new SchemaState(); + stateWithUndefined.objects.tables = undefined; + + expect(() => diffEngine.calculateDiff(stateWithUndefined, targetState)).not.toThrow(); + }); + + it('should handle empty Maps', () => { + const operations = diffEngine.calculateDiff(currentState, targetState); + expect(operations).toEqual([]); + }); + + it('should handle large numbers of objects', () => { + // Add many objects to test performance + for (let i = 0; i < 100; i++) { + currentState.addObject('tables', `table${i}`, { name: `table${i}`, id: i }); + if (i % 2 === 0) { + // Keep half, modify quarter, remove quarter + targetState.addObject('tables', `table${i}`, { + name: `table${i}`, + id: i, + modified: true + }); + } + if (i % 4 === 0) { + targetState.addObject('tables', `new_table${i}`, { name: `new_table${i}` }); + } + } + + const startTime = Date.now(); + const operations = diffEngine.calculateDiff(currentState, targetState); + const duration = Date.now() - startTime; + + expect(duration).toBeLessThan(1000); // Should complete quickly + expect(operations.length).toBeGreaterThan(0); + + // Verify all operations have hashes + operations.forEach((op) => { + expect(op.hash).toBeTruthy(); + }); + }); + }); +}); diff --git a/test/unit/data-core/SqlGraph.test.js b/test/unit/data-core/SqlGraph.test.js new file mode 100644 index 0000000..ae8d1dc --- /dev/null +++ b/test/unit/data-core/SqlGraph.test.js @@ -0,0 +1,626 @@ +/** + * Unit tests for SqlGraph dependency resolution + * + * Tests the SqlGraph class functionality including: + * - SQL object parsing and identification + * - Dependency resolution between SQL objects + * - Topological sorting of execution order + * - Circular dependency detection + * - Port/adapter pattern validation + */ + +import { describe, it, expect, beforeEach, vi } from 'vitest'; +import { SqlGraph, SqlNode } from '../../../packages/data-core/lib/SqlGraph.js'; +import { FileSystemPort } from '../../../packages/data-core/ports/index.js'; + +/** + * Mock FileSystem adapter for testing + */ +class MockFileSystemAdapter extends FileSystemPort { + constructor() { + super(); + this.files = new Map(); + } + + setFile(path, content) { + this.files.set(path, content); + } + + async readFile(path) { + if (!this.files.has(path)) { + throw new Error(`File not found: ${path}`); + } + return this.files.get(path); + } + + async glob(patterns, cwd) { + // Simple mock implementation + return Array.from(this.files.keys()).filter((path) => + patterns.some((pattern) => path.includes(pattern.replace('*', ''))) + ); + } +} + +describe('SqlNode', () => { + let node1, node2, node3; + + beforeEach(() => { + node1 = new SqlNode('users', 'table', '/sql/users.sql', 'CREATE TABLE users...'); + node2 = new SqlNode('orders', 'table', '/sql/orders.sql', 'CREATE TABLE orders...'); + node3 = new SqlNode('get_user_orders', 'function', '/sql/functions.sql', 'CREATE FUNCTION...'); + }); + + it('should create a SqlNode with correct properties', () => { + expect(node1.name).toBe('users'); + expect(node1.type).toBe('table'); + expect(node1.filePath).toBe('/sql/users.sql'); + expect(node1.content).toBe('CREATE TABLE users...'); + expect(node1.dependencies).toBeInstanceOf(Set); + expect(node1.dependents).toBeInstanceOf(Set); + expect(node1.dependencies.size).toBe(0); + expect(node1.dependents.size).toBe(0); + }); + + it('should add dependencies correctly', () => { + node2.addDependency(node1); + + expect(node2.dependencies.has(node1)).toBe(true); + expect(node1.dependents.has(node2)).toBe(true); + expect(node2.dependencies.size).toBe(1); + expect(node1.dependents.size).toBe(1); + }); + + it('should remove dependencies correctly', () => { + node2.addDependency(node1); + node2.removeDependency(node1); + + expect(node2.dependencies.has(node1)).toBe(false); + expect(node1.dependents.has(node2)).toBe(false); + expect(node2.dependencies.size).toBe(0); + expect(node1.dependents.size).toBe(0); + }); + + it('should detect circular dependencies', () => { + // Create circular dependency: node1 -> node2 -> node3 -> node1 + node1.addDependency(node2); + node2.addDependency(node3); + node3.addDependency(node1); + + expect(node1.hasCircularDependency()).toBe(true); + expect(node2.hasCircularDependency()).toBe(true); + expect(node3.hasCircularDependency()).toBe(true); + }); + + it('should not detect circular dependencies in linear chains', () => { + // Linear dependency: node1 -> node2 -> node3 + node1.addDependency(node2); + node2.addDependency(node3); + + expect(node1.hasCircularDependency()).toBe(false); + expect(node2.hasCircularDependency()).toBe(false); + expect(node3.hasCircularDependency()).toBe(false); + }); + + it('should handle self-dependency detection', () => { + const visited = new Set(); + expect(node1.hasCircularDependency(visited)).toBe(false); + + // Add self-dependency + node1.addDependency(node1); + expect(node1.hasCircularDependency()).toBe(true); + }); +}); + +describe('SqlGraph', () => { + let mockFileSystem; + let sqlGraph; + + beforeEach(() => { + mockFileSystem = new MockFileSystemAdapter(); + sqlGraph = new SqlGraph(mockFileSystem); + }); + + describe('constructor and port validation', () => { + it('should validate FileSystemPort on construction', () => { + expect(() => new SqlGraph(mockFileSystem)).not.toThrow(); + expect(sqlGraph.fileSystemPort).toBe(mockFileSystem); + }); + + it('should throw error for invalid port', () => { + const invalidPort = { readFile: () => {} }; // Not instance of FileSystemPort + + expect(() => new SqlGraph(invalidPort)).toThrow('Port must be instance of FileSystemPort'); + }); + + it('should have correct initial state', () => { + expect(sqlGraph.nodes).toBeInstanceOf(Map); + expect(sqlGraph.nodes.size).toBe(0); + expect(sqlGraph.sqlPatterns).toBeDefined(); + expect(sqlGraph.sqlPatterns.create).toBeInstanceOf(RegExp); + expect(sqlGraph.sqlPatterns.reference).toBeInstanceOf(RegExp); + expect(sqlGraph.sqlPatterns.functionCall).toBeInstanceOf(RegExp); + }); + }); + + describe('SQL parsing and object identification', () => { + beforeEach(() => { + mockFileSystem.setFile( + '/sql/users.sql', + ` + CREATE TABLE users ( + id SERIAL PRIMARY KEY, + name VARCHAR(100), + email VARCHAR(255) UNIQUE + ); + ` + ); + + mockFileSystem.setFile( + '/sql/orders.sql', + ` + CREATE TABLE orders ( + id SERIAL PRIMARY KEY, + user_id INTEGER REFERENCES users(id), + total DECIMAL(10,2) + ); + ` + ); + + mockFileSystem.setFile( + '/sql/functions.sql', + ` + CREATE OR REPLACE FUNCTION get_user_orders(user_id INT) + RETURNS TABLE(order_id INT, total DECIMAL) AS $$ + BEGIN + RETURN QUERY + SELECT id, total FROM orders WHERE orders.user_id = $1; + END; + $$ LANGUAGE plpgsql; + ` + ); + + mockFileSystem.setFile( + '/sql/views.sql', + ` + CREATE VIEW user_order_summary AS + SELECT u.name, COUNT(o.id) as order_count, SUM(o.total) as total_spent + FROM users u + LEFT JOIN orders o ON u.id = o.user_id + GROUP BY u.id, u.name; + ` + ); + + mockFileSystem.setFile( + '/sql/migration.sql', + ` + INSERT INTO users (name, email) VALUES ('Test User', 'test@example.com'); + UPDATE orders SET total = total * 1.1 WHERE created_at < '2024-01-01'; + ` + ); + }); + + it('should identify CREATE TABLE statements', async () => { + await sqlGraph.buildGraph(['/sql/users.sql']); + + expect(sqlGraph.nodes.has('users')).toBe(true); + const userNode = sqlGraph.nodes.get('users'); + expect(userNode.type).toBe('table'); + expect(userNode.name).toBe('users'); + expect(userNode.filePath).toBe('/sql/users.sql'); + }); + + it('should identify CREATE FUNCTION statements', async () => { + await sqlGraph.buildGraph(['/sql/functions.sql']); + + expect(sqlGraph.nodes.has('get_user_orders')).toBe(true); + const functionNode = sqlGraph.nodes.get('get_user_orders'); + expect(functionNode.type).toBe('function'); + expect(functionNode.name).toBe('get_user_orders'); + }); + + it('should identify CREATE VIEW statements', async () => { + await sqlGraph.buildGraph(['/sql/views.sql']); + + expect(sqlGraph.nodes.has('user_order_summary')).toBe(true); + const viewNode = sqlGraph.nodes.get('user_order_summary'); + expect(viewNode.type).toBe('view'); + expect(viewNode.name).toBe('user_order_summary'); + }); + + it('should handle files without CREATE statements as migration scripts', async () => { + await sqlGraph.buildGraph(['/sql/migration.sql']); + + expect(sqlGraph.nodes.has('migration')).toBe(true); + const scriptNode = sqlGraph.nodes.get('migration'); + expect(scriptNode.type).toBe('script'); + expect(scriptNode.name).toBe('migration'); + }); + + it('should handle OR REPLACE syntax', async () => { + mockFileSystem.setFile('/sql/replace.sql', 'CREATE OR REPLACE VIEW test_view AS SELECT 1;'); + await sqlGraph.buildGraph(['/sql/replace.sql']); + + expect(sqlGraph.nodes.has('test_view')).toBe(true); + const node = sqlGraph.nodes.get('test_view'); + expect(node.type).toBe('view'); + }); + + it('should handle IF NOT EXISTS syntax', async () => { + mockFileSystem.setFile( + '/sql/conditional.sql', + 'CREATE TABLE IF NOT EXISTS test_table (id INT);' + ); + await sqlGraph.buildGraph(['/sql/conditional.sql']); + + expect(sqlGraph.nodes.has('test_table')).toBe(true); + const node = sqlGraph.nodes.get('test_table'); + expect(node.type).toBe('table'); + }); + }); + + describe('dependency analysis', () => { + beforeEach(async () => { + // Set up complex dependency scenario + mockFileSystem.setFile( + '/sql/users.sql', + 'CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(100));' + ); + mockFileSystem.setFile( + '/sql/orders.sql', + 'CREATE TABLE orders (id SERIAL, user_id INTEGER REFERENCES users(id));' + ); + mockFileSystem.setFile( + '/sql/products.sql', + 'CREATE TABLE products (id SERIAL PRIMARY KEY, name VARCHAR(100));' + ); + mockFileSystem.setFile( + '/sql/order_items.sql', + ` + CREATE TABLE order_items ( + order_id INTEGER REFERENCES orders(id), + product_id INTEGER REFERENCES products(id) + ); + ` + ); + mockFileSystem.setFile( + '/sql/functions.sql', + ` + CREATE FUNCTION get_order_total(order_id INT) RETURNS DECIMAL AS $$ + SELECT SUM(p.price) FROM order_items oi + JOIN products p ON oi.product_id = p.id + WHERE oi.order_id = $1; + $$ LANGUAGE SQL; + ` + ); + mockFileSystem.setFile( + '/sql/views.sql', + ` + CREATE VIEW order_summary AS + SELECT o.id, u.name as customer, get_order_total(o.id) as total + FROM orders o + JOIN users u ON o.user_id = u.id; + ` + ); + + await sqlGraph.buildGraph([ + '/sql/users.sql', + '/sql/orders.sql', + '/sql/products.sql', + '/sql/order_items.sql', + '/sql/functions.sql', + '/sql/views.sql' + ]); + }); + + it('should identify REFERENCES dependencies', () => { + const ordersNode = sqlGraph.nodes.get('orders'); + const usersNode = sqlGraph.nodes.get('users'); + + expect(ordersNode.dependencies.has(usersNode)).toBe(true); + expect(usersNode.dependents.has(ordersNode)).toBe(true); + }); + + it('should identify JOIN dependencies', () => { + const viewNode = sqlGraph.nodes.get('order_summary'); + const ordersNode = sqlGraph.nodes.get('orders'); + const usersNode = sqlGraph.nodes.get('users'); + + expect(viewNode.dependencies.has(ordersNode)).toBe(true); + expect(viewNode.dependencies.has(usersNode)).toBe(true); + }); + + it('should identify function call dependencies', () => { + const viewNode = sqlGraph.nodes.get('order_summary'); + const functionNode = sqlGraph.nodes.get('get_order_total'); + + expect(viewNode.dependencies.has(functionNode)).toBe(true); + }); + + it('should handle multiple dependencies correctly', () => { + const orderItemsNode = sqlGraph.nodes.get('order_items'); + const ordersNode = sqlGraph.nodes.get('orders'); + const productsNode = sqlGraph.nodes.get('products'); + + expect(orderItemsNode.dependencies.size).toBe(2); + expect(orderItemsNode.dependencies.has(ordersNode)).toBe(true); + expect(orderItemsNode.dependencies.has(productsNode)).toBe(true); + }); + + it('should not create self-dependencies', () => { + for (const node of sqlGraph.nodes.values()) { + expect(node.dependencies.has(node)).toBe(false); + } + }); + }); + + describe('topological sorting and execution order', () => { + it('should return correct execution order for simple chain', async () => { + mockFileSystem.setFile('/sql/a.sql', 'CREATE TABLE a (id INT);'); + mockFileSystem.setFile('/sql/b.sql', 'CREATE TABLE b (a_id INT REFERENCES a(id));'); + mockFileSystem.setFile('/sql/c.sql', 'CREATE TABLE c (b_id INT REFERENCES b(id));'); + + await sqlGraph.buildGraph(['/sql/a.sql', '/sql/b.sql', '/sql/c.sql']); + const executionOrder = sqlGraph.getExecutionOrder(); + + expect(executionOrder.length).toBe(3); + expect(executionOrder[0].name).toBe('a'); + expect(executionOrder[1].name).toBe('b'); + expect(executionOrder[2].name).toBe('c'); + }); + + it('should handle diamond dependency pattern', async () => { + mockFileSystem.setFile('/sql/base.sql', 'CREATE TABLE base (id INT);'); + mockFileSystem.setFile( + '/sql/left.sql', + 'CREATE TABLE left_table (base_id INT REFERENCES base(id));' + ); + mockFileSystem.setFile( + '/sql/right.sql', + 'CREATE TABLE right_table (base_id INT REFERENCES base(id));' + ); + mockFileSystem.setFile( + '/sql/top.sql', + ` + CREATE TABLE top_table ( + left_id INT REFERENCES left_table(id), + right_id INT REFERENCES right_table(id) + ); + ` + ); + + await sqlGraph.buildGraph([ + '/sql/base.sql', + '/sql/left.sql', + '/sql/right.sql', + '/sql/top.sql' + ]); + const executionOrder = sqlGraph.getExecutionOrder(); + + expect(executionOrder.length).toBe(4); + expect(executionOrder[0].name).toBe('base'); + expect(executionOrder[3].name).toBe('top_table'); + // left_table and right_table can be in either order + const middleNames = [executionOrder[1].name, executionOrder[2].name].sort(); + expect(middleNames).toEqual(['left_table', 'right_table']); + }); + + it('should detect circular dependencies and throw error', async () => { + mockFileSystem.setFile('/sql/a.sql', 'CREATE TABLE a (b_id INT REFERENCES b(id));'); + mockFileSystem.setFile('/sql/b.sql', 'CREATE TABLE b (c_id INT REFERENCES c(id));'); + mockFileSystem.setFile('/sql/c.sql', 'CREATE TABLE c (a_id INT REFERENCES a(id));'); + + await sqlGraph.buildGraph(['/sql/a.sql', '/sql/b.sql', '/sql/c.sql']); + + expect(() => sqlGraph.getExecutionOrder()).toThrow('Circular dependency detected involving:'); + }); + + it('should handle independent nodes correctly', async () => { + mockFileSystem.setFile('/sql/independent1.sql', 'CREATE TABLE independent1 (id INT);'); + mockFileSystem.setFile('/sql/independent2.sql', 'CREATE TABLE independent2 (id INT);'); + mockFileSystem.setFile( + '/sql/dependent.sql', + ` + CREATE TABLE dependent ( + id1 INT REFERENCES independent1(id), + id2 INT REFERENCES independent2(id) + ); + ` + ); + + await sqlGraph.buildGraph([ + '/sql/independent1.sql', + '/sql/independent2.sql', + '/sql/dependent.sql' + ]); + const executionOrder = sqlGraph.getExecutionOrder(); + + expect(executionOrder.length).toBe(3); + expect(executionOrder[2].name).toBe('dependent'); + // First two can be in any order + const independentNames = [executionOrder[0].name, executionOrder[1].name].sort(); + expect(independentNames).toEqual(['independent1', 'independent2']); + }); + }); + + describe('graph analysis utilities', () => { + beforeEach(async () => { + mockFileSystem.setFile('/sql/root1.sql', 'CREATE TABLE root1 (id INT);'); + mockFileSystem.setFile('/sql/root2.sql', 'CREATE TABLE root2 (id INT);'); + mockFileSystem.setFile( + '/sql/child1.sql', + 'CREATE TABLE child1 (root1_id INT REFERENCES root1(id));' + ); + mockFileSystem.setFile( + '/sql/child2.sql', + 'CREATE TABLE child2 (root2_id INT REFERENCES root2(id));' + ); + mockFileSystem.setFile( + '/sql/leaf.sql', + ` + CREATE TABLE leaf ( + child1_id INT REFERENCES child1(id), + child2_id INT REFERENCES child2(id) + ); + ` + ); + + await sqlGraph.buildGraph([ + '/sql/root1.sql', + '/sql/root2.sql', + '/sql/child1.sql', + '/sql/child2.sql', + '/sql/leaf.sql' + ]); + }); + + it('should identify independent nodes (no dependencies)', () => { + const independentNodes = sqlGraph.getIndependentNodes(); + + expect(independentNodes.length).toBe(2); + const names = independentNodes.map((node) => node.name).sort(); + expect(names).toEqual(['root1', 'root2']); + }); + + it('should identify terminal nodes (no dependents)', () => { + const terminalNodes = sqlGraph.getTerminalNodes(); + + expect(terminalNodes.length).toBe(1); + expect(terminalNodes[0].name).toBe('leaf'); + }); + + it('should return all nodes', () => { + const allNodes = sqlGraph.getAllNodes(); + + expect(allNodes.length).toBe(5); + const names = allNodes.map((node) => node.name).sort(); + expect(names).toEqual(['child1', 'child2', 'leaf', 'root1', 'root2']); + }); + + it('should detect absence of circular dependencies in valid graph', () => { + expect(sqlGraph.hasCircularDependencies()).toBe(false); + }); + + it('should detect presence of circular dependencies', async () => { + // Add circular dependency + mockFileSystem.setFile( + '/sql/circular.sql', + 'CREATE TABLE circular (leaf_id INT REFERENCES leaf(id));' + ); + const leafNode = sqlGraph.nodes.get('leaf'); + const circularNode = new SqlNode('circular', 'table', '/sql/circular.sql', 'CREATE TABLE...'); + sqlGraph.nodes.set('circular', circularNode); + + // Create circular dependency: leaf -> circular -> leaf + circularNode.addDependency(leafNode); + leafNode.addDependency(circularNode); + + expect(sqlGraph.hasCircularDependencies()).toBe(true); + }); + }); + + describe('error handling', () => { + it('should handle file read errors gracefully', async () => { + const fileSystem = new MockFileSystemAdapter(); + const graph = new SqlGraph(fileSystem); + + await expect(graph.buildGraph(['/nonexistent.sql'])).rejects.toThrow('File not found'); + }); + + it('should clear existing graph on rebuild', async () => { + mockFileSystem.setFile('/sql/test1.sql', 'CREATE TABLE test1 (id INT);'); + await sqlGraph.buildGraph(['/sql/test1.sql']); + expect(sqlGraph.nodes.size).toBe(1); + + mockFileSystem.setFile('/sql/test2.sql', 'CREATE TABLE test2 (id INT);'); + await sqlGraph.buildGraph(['/sql/test2.sql']); + expect(sqlGraph.nodes.size).toBe(1); + expect(sqlGraph.nodes.has('test2')).toBe(true); + expect(sqlGraph.nodes.has('test1')).toBe(false); + }); + + it('should handle empty SQL files', async () => { + mockFileSystem.setFile('/sql/empty.sql', ' \n\n '); + await sqlGraph.buildGraph(['/sql/empty.sql']); + + expect(sqlGraph.nodes.has('empty')).toBe(true); + const node = sqlGraph.nodes.get('empty'); + expect(node.type).toBe('script'); + }); + + it('should handle SQL with comments and whitespace', async () => { + mockFileSystem.setFile( + '/sql/commented.sql', + ` + -- This is a comment + /* Multi-line + comment */ + CREATE TABLE commented_table ( + id SERIAL PRIMARY KEY, + /* inline comment */ name VARCHAR(100) + ); + ` + ); + + await sqlGraph.buildGraph(['/sql/commented.sql']); + expect(sqlGraph.nodes.has('commented_table')).toBe(true); + }); + }); + + describe('performance and edge cases', () => { + it('should handle large number of nodes efficiently', async () => { + const nodeCount = 100; + const files = []; + + // Create chain of dependencies + for (let i = 0; i < nodeCount; i++) { + const fileName = `/sql/table${i}.sql`; + let sql = `CREATE TABLE table${i} (id SERIAL PRIMARY KEY`; + if (i > 0) { + sql += `, ref INT REFERENCES table${i - 1}(id)`; + } + sql += ');'; + + mockFileSystem.setFile(fileName, sql); + files.push(fileName); + } + + const startTime = Date.now(); + await sqlGraph.buildGraph(files); + const buildTime = Date.now() - startTime; + + expect(buildTime).toBeLessThan(5000); // Should complete within 5 seconds + expect(sqlGraph.nodes.size).toBe(nodeCount); + + const execOrderStartTime = Date.now(); + const executionOrder = sqlGraph.getExecutionOrder(); + const execOrderTime = Date.now() - execOrderStartTime; + + expect(execOrderTime).toBeLessThan(1000); // Topological sort should be fast + expect(executionOrder.length).toBe(nodeCount); + }); + + it('should handle nodes with same name but different types', async () => { + // PostgreSQL allows same names for different object types + mockFileSystem.setFile( + '/sql/same_name.sql', + ` + CREATE TABLE user_stats (id INT); + CREATE VIEW user_stats AS SELECT * FROM user_stats; + ` + ); + + await sqlGraph.buildGraph(['/sql/same_name.sql']); + + // Last one wins in our simple implementation + expect(sqlGraph.nodes.size).toBe(1); + expect(sqlGraph.nodes.get('user_stats').type).toBe('view'); + }); + + it('should handle complex schema names with dots', async () => { + mockFileSystem.setFile('/sql/schema.sql', 'CREATE TABLE public.users (id INT);'); + await sqlGraph.buildGraph(['/sql/schema.sql']); + + expect(sqlGraph.nodes.has('public.users')).toBe(true); + }); + }); +}); diff --git a/test/unit/data-host-node/adapters.test.js b/test/unit/data-host-node/adapters.test.js new file mode 100644 index 0000000..3e830f2 --- /dev/null +++ b/test/unit/data-host-node/adapters.test.js @@ -0,0 +1,882 @@ +/** + * Unit tests for Node.js adapters (port/adapter pattern) + * + * Tests the adapter implementations including: + * - FileSystemAdapter implementation and error handling + * - CryptoAdapter implementation and algorithms + * - EnvironmentAdapter implementation and edge cases + * - Port validation and instanceof checks + * - Error normalization and consistency + * - Test doubles and mocking strategies + */ + +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import { promises as fs, constants } from 'fs'; +import { resolve, dirname } from 'path'; +import { tmpdir } from 'os'; +import { join } from 'path'; + +import { FileSystemAdapter } from '../../../packages/data-host-node/adapters/FileSystemAdapter.js'; +import { CryptoAdapter } from '../../../packages/data-host-node/adapters/CryptoAdapter.js'; +import { EnvironmentAdapter } from '../../../packages/data-host-node/adapters/EnvironmentAdapter.js'; +import { + FileSystemPort, + CryptoPort, + EnvironmentPort +} from '../../../packages/data-core/ports/index.js'; + +// Test utilities +const createTempDir = async () => { + const tempDir = join(tmpdir(), `data-test-${Date.now()}-${Math.random().toString(36).slice(2)}`); + await fs.mkdir(tempDir, { recursive: true }); + return tempDir; +}; + +const cleanupTempDir = async (dir) => { + try { + await fs.rm(dir, { recursive: true, force: true }); + } catch (error) { + // Ignore cleanup errors + } +}; + +describe('FileSystemAdapter', () => { + let adapter; + let tempDir; + + beforeEach(async () => { + tempDir = await createTempDir(); + adapter = new FileSystemAdapter(); + }); + + afterEach(async () => { + if (tempDir) { + await cleanupTempDir(tempDir); + } + }); + + describe('port validation and inheritance', () => { + it('should extend FileSystemPort', () => { + expect(adapter).toBeInstanceOf(FileSystemPort); + }); + + it('should be valid for port validation', () => { + expect(() => { + if (!(adapter instanceof FileSystemPort)) { + throw new Error('Port must be instance of FileSystemPort'); + } + }).not.toThrow(); + }); + }); + + describe('constructor and configuration', () => { + it('should initialize with default options', () => { + const defaultAdapter = new FileSystemAdapter(); + expect(defaultAdapter.encoding).toBe('utf8'); + expect(defaultAdapter.defaultMode).toBe(0o644); + }); + + it('should accept custom options', () => { + const customAdapter = new FileSystemAdapter({ + encoding: 'latin1', + mode: 0o755 + }); + expect(customAdapter.encoding).toBe('latin1'); + expect(customAdapter.defaultMode).toBe(0o755); + }); + + it('should handle partial options', () => { + const partialAdapter = new FileSystemAdapter({ encoding: 'base64' }); + expect(partialAdapter.encoding).toBe('base64'); + expect(partialAdapter.defaultMode).toBe(0o644); // default + }); + }); + + describe('readFile', () => { + it('should read existing file', async () => { + const filePath = join(tempDir, 'test.txt'); + const content = 'Hello, World!'; + await fs.writeFile(filePath, content); + + const result = await adapter.readFile(filePath); + expect(result).toBe(content); + }); + + it('should handle custom encoding', async () => { + const filePath = join(tempDir, 'encoded.txt'); + const content = 'Test content'; + await fs.writeFile(filePath, content); + + const result = await adapter.readFile(filePath, { encoding: 'utf8' }); + expect(result).toBe(content); + }); + + it('should resolve relative paths', async () => { + const filePath = join(tempDir, 'relative.txt'); + const content = 'Relative path test'; + await fs.writeFile(filePath, content); + + // Test with relative path + const result = await adapter.readFile(filePath); + expect(result).toBe(content); + }); + + it('should throw FileSystemError for nonexistent file', async () => { + const nonexistentPath = join(tempDir, 'nonexistent.txt'); + + await expect(adapter.readFile(nonexistentPath)).rejects.toThrow('FileSystemError'); + + try { + await adapter.readFile(nonexistentPath); + } catch (error) { + expect(error.name).toBe('FileSystemError'); + expect(error.operation).toBe('readFile'); + expect(error.path).toBe(nonexistentPath); + expect(error.code).toBe('ENOENT'); + expect(error.originalError).toBeDefined(); + } + }); + + it('should handle permission errors', async () => { + // Create a file and remove read permissions (Unix-like systems) + const restrictedPath = join(tempDir, 'restricted.txt'); + await fs.writeFile(restrictedPath, 'restricted content'); + + try { + await fs.chmod(restrictedPath, 0o000); // Remove all permissions + await expect(adapter.readFile(restrictedPath)).rejects.toThrow('FileSystemError'); + } finally { + // Restore permissions for cleanup + await fs.chmod(restrictedPath, 0o644); + } + }); + }); + + describe('writeFile', () => { + it('should write file with content', async () => { + const filePath = join(tempDir, 'output.txt'); + const content = 'Written content'; + + await adapter.writeFile(filePath, content); + + const result = await fs.readFile(filePath, 'utf8'); + expect(result).toBe(content); + }); + + it('should create directory if needed', async () => { + const nestedPath = join(tempDir, 'nested', 'deep', 'file.txt'); + const content = 'Nested file content'; + + await adapter.writeFile(nestedPath, content); + + const result = await fs.readFile(nestedPath, 'utf8'); + expect(result).toBe(content); + }); + + it('should handle custom encoding and mode', async () => { + const filePath = join(tempDir, 'custom.txt'); + const content = 'Custom encoding'; + + await adapter.writeFile(filePath, content, { + encoding: 'utf8', + mode: 0o755 + }); + + const stats = await fs.stat(filePath); + expect(stats.mode & parseInt('777', 8)).toBe(0o755); + }); + + it('should overwrite existing files', async () => { + const filePath = join(tempDir, 'overwrite.txt'); + + await adapter.writeFile(filePath, 'First content'); + await adapter.writeFile(filePath, 'Second content'); + + const result = await fs.readFile(filePath, 'utf8'); + expect(result).toBe('Second content'); + }); + + it('should throw FileSystemError for invalid paths', async () => { + // Try to write to a path that can't be created + const invalidPath = '/root/cannot/create/this/path/file.txt'; // Assuming no root permissions + + await expect(adapter.writeFile(invalidPath, 'content')).rejects.toThrow('FileSystemError'); + }); + }); + + describe('exists', () => { + it('should return true for existing files', async () => { + const filePath = join(tempDir, 'exists.txt'); + await fs.writeFile(filePath, 'content'); + + const result = await adapter.exists(filePath); + expect(result).toBe(true); + }); + + it('should return true for existing directories', async () => { + const dirPath = join(tempDir, 'existing-dir'); + await fs.mkdir(dirPath); + + const result = await adapter.exists(dirPath); + expect(result).toBe(true); + }); + + it('should return false for nonexistent paths', async () => { + const nonexistentPath = join(tempDir, 'nonexistent'); + + const result = await adapter.exists(nonexistentPath); + expect(result).toBe(false); + }); + + it('should handle permission errors gracefully', async () => { + // Test with a path that might have permission issues + const result = await adapter.exists('/proc/some/system/path'); + expect(typeof result).toBe('boolean'); + }); + }); + + describe('stat', () => { + it('should return file stats', async () => { + const filePath = join(tempDir, 'stat-test.txt'); + const content = 'test content'; + await fs.writeFile(filePath, content); + + const stats = await adapter.stat(filePath); + + expect(stats.isFile).toBe(true); + expect(stats.isDirectory).toBe(false); + expect(stats.size).toBe(content.length); + expect(stats.mtime).toBeInstanceOf(Date); + expect(stats.ctime).toBeInstanceOf(Date); + expect(typeof stats.mode).toBe('number'); + }); + + it('should return directory stats', async () => { + const dirPath = join(tempDir, 'stat-dir'); + await fs.mkdir(dirPath); + + const stats = await adapter.stat(dirPath); + + expect(stats.isFile).toBe(false); + expect(stats.isDirectory).toBe(true); + expect(stats.mtime).toBeInstanceOf(Date); + expect(stats.ctime).toBeInstanceOf(Date); + }); + + it('should throw FileSystemError for nonexistent path', async () => { + const nonexistentPath = join(tempDir, 'nonexistent'); + + await expect(adapter.stat(nonexistentPath)).rejects.toThrow('FileSystemError'); + + try { + await adapter.stat(nonexistentPath); + } catch (error) { + expect(error.name).toBe('FileSystemError'); + expect(error.operation).toBe('stat'); + expect(error.path).toBe(nonexistentPath); + } + }); + }); + + describe('ensureDir', () => { + it('should create single directory', async () => { + const dirPath = join(tempDir, 'new-dir'); + + await adapter.ensureDir(dirPath); + + const stats = await fs.stat(dirPath); + expect(stats.isDirectory()).toBe(true); + }); + + it('should create nested directories', async () => { + const nestedPath = join(tempDir, 'deeply', 'nested', 'directory'); + + await adapter.ensureDir(nestedPath); + + const stats = await fs.stat(nestedPath); + expect(stats.isDirectory()).toBe(true); + }); + + it('should not fail if directory exists', async () => { + const existingDir = join(tempDir, 'existing'); + await fs.mkdir(existingDir); + + await expect(adapter.ensureDir(existingDir)).resolves.not.toThrow(); + }); + + it('should handle custom mode', async () => { + const dirPath = join(tempDir, 'custom-mode-dir'); + + await adapter.ensureDir(dirPath, { mode: 0o700 }); + + const stats = await fs.stat(dirPath); + expect(stats.mode & parseInt('777', 8)).toBe(0o700); + }); + + it('should throw FileSystemError for invalid paths', async () => { + const invalidPath = '/root/cannot/create/directory'; // Assuming no root permissions + + await expect(adapter.ensureDir(invalidPath)).rejects.toThrow('FileSystemError'); + }); + }); + + describe('remove', () => { + it('should remove files', async () => { + const filePath = join(tempDir, 'to-remove.txt'); + await fs.writeFile(filePath, 'content'); + + await adapter.remove(filePath); + + expect(await adapter.exists(filePath)).toBe(false); + }); + + it('should remove empty directories', async () => { + const dirPath = join(tempDir, 'empty-dir'); + await fs.mkdir(dirPath); + + await adapter.remove(dirPath); + + expect(await adapter.exists(dirPath)).toBe(false); + }); + + it('should remove directories recursively when option is set', async () => { + const basePath = join(tempDir, 'recursive'); + const nestedPath = join(basePath, 'nested'); + const filePath = join(nestedPath, 'file.txt'); + + await fs.mkdir(basePath); + await fs.mkdir(nestedPath); + await fs.writeFile(filePath, 'content'); + + await adapter.remove(basePath, { recursive: true }); + + expect(await adapter.exists(basePath)).toBe(false); + }); + + it('should throw error for non-empty directories without recursive option', async () => { + const basePath = join(tempDir, 'non-empty'); + const filePath = join(basePath, 'file.txt'); + + await fs.mkdir(basePath); + await fs.writeFile(filePath, 'content'); + + await expect(adapter.remove(basePath)).rejects.toThrow('FileSystemError'); + }); + + it('should throw FileSystemError for nonexistent path', async () => { + const nonexistentPath = join(tempDir, 'nonexistent'); + + await expect(adapter.remove(nonexistentPath)).rejects.toThrow('FileSystemError'); + }); + }); + + describe('readDir', () => { + beforeEach(async () => { + // Create test directory structure + await fs.mkdir(join(tempDir, 'test-subdir')); + await fs.writeFile(join(tempDir, 'file1.txt'), 'content1'); + await fs.writeFile(join(tempDir, 'file2.txt'), 'content2'); + }); + + it('should list directory contents', async () => { + const entries = await adapter.readDir(tempDir); + + expect(entries).toHaveLength(3); + expect(entries).toContain('test-subdir'); + expect(entries).toContain('file1.txt'); + expect(entries).toContain('file2.txt'); + }); + + it('should return file type information when requested', async () => { + const entries = await adapter.readDir(tempDir, { withFileTypes: true }); + + expect(entries).toHaveLength(3); + + const subdir = entries.find((e) => e.name === 'test-subdir'); + expect(subdir.isDirectory).toBe(true); + expect(subdir.isFile).toBe(false); + + const file = entries.find((e) => e.name === 'file1.txt'); + expect(file.isFile).toBe(true); + expect(file.isDirectory).toBe(false); + }); + + it('should handle empty directories', async () => { + const emptyDir = join(tempDir, 'empty'); + await fs.mkdir(emptyDir); + + const entries = await adapter.readDir(emptyDir); + expect(entries).toHaveLength(0); + }); + + it('should throw FileSystemError for nonexistent directory', async () => { + const nonexistentDir = join(tempDir, 'nonexistent'); + + await expect(adapter.readDir(nonexistentDir)).rejects.toThrow('FileSystemError'); + }); + + it('should throw FileSystemError when trying to read a file as directory', async () => { + const filePath = join(tempDir, 'file1.txt'); + + await expect(adapter.readDir(filePath)).rejects.toThrow('FileSystemError'); + }); + }); + + describe('copy', () => { + it('should copy files', async () => { + const sourcePath = join(tempDir, 'source.txt'); + const destPath = join(tempDir, 'destination.txt'); + const content = 'Copy test content'; + + await fs.writeFile(sourcePath, content); + await adapter.copy(sourcePath, destPath); + + const result = await fs.readFile(destPath, 'utf8'); + expect(result).toBe(content); + }); + + it('should copy directories recursively', async () => { + const sourceDir = join(tempDir, 'source-dir'); + const destDir = join(tempDir, 'dest-dir'); + const filePath = join(sourceDir, 'file.txt'); + const content = 'Directory copy test'; + + await fs.mkdir(sourceDir); + await fs.writeFile(filePath, content); + + await adapter.copy(sourceDir, destDir, { recursive: true }); + + const copiedFile = join(destDir, 'file.txt'); + const result = await fs.readFile(copiedFile, 'utf8'); + expect(result).toBe(content); + }); + + it('should preserve timestamps', async () => { + const sourcePath = join(tempDir, 'timestamp-source.txt'); + const destPath = join(tempDir, 'timestamp-dest.txt'); + + await fs.writeFile(sourcePath, 'timestamp test'); + const originalStats = await fs.stat(sourcePath); + + await adapter.copy(sourcePath, destPath); + + const copiedStats = await fs.stat(destPath); + expect(copiedStats.mtime.getTime()).toBe(originalStats.mtime.getTime()); + }); + + it('should overwrite existing files', async () => { + const sourcePath = join(tempDir, 'overwrite-source.txt'); + const destPath = join(tempDir, 'overwrite-dest.txt'); + + await fs.writeFile(sourcePath, 'new content'); + await fs.writeFile(destPath, 'old content'); + + await adapter.copy(sourcePath, destPath); + + const result = await fs.readFile(destPath, 'utf8'); + expect(result).toBe('new content'); + }); + + it('should throw FileSystemError for nonexistent source', async () => { + const nonexistentSource = join(tempDir, 'nonexistent'); + const destPath = join(tempDir, 'dest.txt'); + + await expect(adapter.copy(nonexistentSource, destPath)).rejects.toThrow('FileSystemError'); + }); + }); + + describe('error normalization', () => { + it('should normalize errors with consistent format', async () => { + const nonexistentPath = join(tempDir, 'nonexistent.txt'); + + try { + await adapter.readFile(nonexistentPath); + expect.fail('Should have thrown error'); + } catch (error) { + expect(error.name).toBe('FileSystemError'); + expect(error.message).toContain('FileSystem readFile failed'); + expect(error.message).toContain(nonexistentPath); + expect(error.operation).toBe('readFile'); + expect(error.path).toBe(nonexistentPath); + expect(error.code).toBe('ENOENT'); + expect(error.originalError).toBeInstanceOf(Error); + } + }); + + it('should handle errors from different operations consistently', async () => { + const testCases = [ + { method: 'stat', path: join(tempDir, 'nonexistent1') }, + { method: 'remove', path: join(tempDir, 'nonexistent2') } + ]; + + for (const testCase of testCases) { + try { + await adapter[testCase.method](testCase.path); + expect.fail(`${testCase.method} should have thrown error`); + } catch (error) { + expect(error.name).toBe('FileSystemError'); + expect(error.operation).toBe(testCase.method); + expect(error.path).toBe(testCase.path); + expect(error.originalError).toBeInstanceOf(Error); + } + } + }); + }); +}); + +describe('CryptoAdapter', () => { + let adapter; + + beforeEach(() => { + adapter = new CryptoAdapter(); + }); + + describe('port validation and inheritance', () => { + it('should extend CryptoPort', () => { + expect(adapter).toBeInstanceOf(CryptoPort); + }); + + it('should be valid for port validation', () => { + expect(() => { + if (!(adapter instanceof CryptoPort)) { + throw new Error('Port must be instance of CryptoPort'); + } + }).not.toThrow(); + }); + }); + + describe('hash generation', () => { + it('should generate SHA-256 hash by default', () => { + const input = 'test data'; + const hash = adapter.hash(input); + + expect(hash).toBeTruthy(); + expect(typeof hash).toBe('string'); + expect(hash.length).toBe(64); // SHA-256 hex length + expect(/^[a-f0-9]{64}$/.test(hash)).toBe(true); + }); + + it('should generate consistent hashes for same input', () => { + const input = 'consistent test data'; + const hash1 = adapter.hash(input); + const hash2 = adapter.hash(input); + + expect(hash1).toBe(hash2); + }); + + it('should generate different hashes for different inputs', () => { + const hash1 = adapter.hash('input1'); + const hash2 = adapter.hash('input2'); + + expect(hash1).not.toBe(hash2); + }); + + it('should handle different data types', () => { + const stringHash = adapter.hash('string data'); + const bufferHash = adapter.hash(Buffer.from('buffer data')); + const uint8ArrayHash = adapter.hash(new Uint8Array([1, 2, 3, 4])); + + expect(stringHash).toBeTruthy(); + expect(bufferHash).toBeTruthy(); + expect(uint8ArrayHash).toBeTruthy(); + expect(stringHash).not.toBe(bufferHash); + }); + + it('should support different algorithms', () => { + const input = 'algorithm test'; + const sha256Hash = adapter.hash(input, 'sha256'); + const sha1Hash = adapter.hash(input, 'sha1'); + const md5Hash = adapter.hash(input, 'md5'); + + expect(sha256Hash.length).toBe(64); // SHA-256 + expect(sha1Hash.length).toBe(40); // SHA-1 + expect(md5Hash.length).toBe(32); // MD5 + + expect(sha256Hash).not.toBe(sha1Hash); + expect(sha256Hash).not.toBe(md5Hash); + }); + + it('should handle empty input', () => { + const emptyHash = adapter.hash(''); + expect(emptyHash).toBeTruthy(); + expect(emptyHash.length).toBe(64); + }); + + it('should handle large inputs efficiently', () => { + const largeInput = 'x'.repeat(1000000); // 1MB string + const startTime = Date.now(); + const hash = adapter.hash(largeInput); + const duration = Date.now() - startTime; + + expect(hash).toBeTruthy(); + expect(duration).toBeLessThan(1000); // Should be fast + }); + + it('should throw error for unsupported algorithms', () => { + expect(() => adapter.hash('test', 'unsupported-algorithm')).toThrow(); + }); + + it('should handle special characters and unicode', () => { + const unicodeInput = 'test ๐Ÿš€ unicode รฑรกรฉรญรณรบ ไธญๆ–‡'; + const hash = adapter.hash(unicodeInput); + + expect(hash).toBeTruthy(); + expect(hash.length).toBe(64); + }); + }); + + describe('performance and edge cases', () => { + it('should handle concurrent hashing operations', async () => { + const promises = []; + for (let i = 0; i < 100; i++) { + promises.push(Promise.resolve(adapter.hash(`concurrent test ${i}`))); + } + + const hashes = await Promise.all(promises); + + expect(hashes).toHaveLength(100); + expect(new Set(hashes).size).toBe(100); // All should be unique + }); + + it('should maintain consistent performance', () => { + const input = 'performance test data'; + const iterations = 1000; + + const startTime = Date.now(); + for (let i = 0; i < iterations; i++) { + adapter.hash(`${input} ${i}`); + } + const duration = Date.now() - startTime; + + expect(duration).toBeLessThan(5000); // Should complete within reasonable time + }); + }); +}); + +describe('EnvironmentAdapter', () => { + let adapter; + let originalEnv; + + beforeEach(() => { + // Save original environment + originalEnv = { ...process.env }; + adapter = new EnvironmentAdapter(); + }); + + afterEach(() => { + // Restore original environment + process.env = originalEnv; + }); + + describe('port validation and inheritance', () => { + it('should extend EnvironmentPort', () => { + expect(adapter).toBeInstanceOf(EnvironmentPort); + }); + + it('should be valid for port validation', () => { + expect(() => { + if (!(adapter instanceof EnvironmentPort)) { + throw new Error('Port must be instance of EnvironmentPort'); + } + }).not.toThrow(); + }); + }); + + describe('environment variable access', () => { + it('should get existing environment variables', () => { + process.env.TEST_VAR = 'test_value'; + + const result = adapter.get('TEST_VAR'); + expect(result).toBe('test_value'); + }); + + it('should return undefined for nonexistent variables', () => { + const result = adapter.get('NONEXISTENT_VAR'); + expect(result).toBeUndefined(); + }); + + it('should return default value when variable does not exist', () => { + const result = adapter.get('NONEXISTENT_VAR', 'default_value'); + expect(result).toBe('default_value'); + }); + + it('should not return default value when variable exists', () => { + process.env.EXISTING_VAR = 'actual_value'; + + const result = adapter.get('EXISTING_VAR', 'default_value'); + expect(result).toBe('actual_value'); + }); + + it('should handle empty string values', () => { + process.env.EMPTY_VAR = ''; + + const result = adapter.get('EMPTY_VAR', 'default'); + expect(result).toBe(''); // Empty string, not default + }); + + it('should handle variables with special characters', () => { + process.env.SPECIAL_VAR = 'value with spaces and symbols: !@#$%^&*()'; + + const result = adapter.get('SPECIAL_VAR'); + expect(result).toBe('value with spaces and symbols: !@#$%^&*()'); + }); + + it('should handle variables with newlines and escapes', () => { + process.env.MULTILINE_VAR = 'line1\\nline2\\ttabbed'; + + const result = adapter.get('MULTILINE_VAR'); + expect(result).toBe('line1\\nline2\\ttabbed'); + }); + }); + + describe('environment variable existence checks', () => { + it('should return true for existing variables', () => { + process.env.EXISTS_VAR = 'some_value'; + + const result = adapter.has('EXISTS_VAR'); + expect(result).toBe(true); + }); + + it('should return false for nonexistent variables', () => { + const result = adapter.has('DOES_NOT_EXIST'); + expect(result).toBe(false); + }); + + it('should return true for empty string variables', () => { + process.env.EMPTY_EXISTS = ''; + + const result = adapter.has('EMPTY_EXISTS'); + expect(result).toBe(true); + }); + + it('should handle case-sensitive variable names', () => { + process.env.CaseSensitive = 'value'; + + expect(adapter.has('CaseSensitive')).toBe(true); + expect(adapter.has('casesensitive')).toBe(false); + expect(adapter.has('CASESENSITIVE')).toBe(false); + }); + }); + + describe('common environment patterns', () => { + it('should handle NODE_ENV pattern', () => { + process.env.NODE_ENV = 'test'; + + expect(adapter.get('NODE_ENV')).toBe('test'); + expect(adapter.has('NODE_ENV')).toBe(true); + expect(adapter.get('NODE_ENV', 'development')).toBe('test'); + }); + + it('should handle database URL pattern', () => { + const dbUrl = 'postgresql://user:password@localhost:5432/testdb'; + process.env.DATABASE_URL = dbUrl; + + expect(adapter.get('DATABASE_URL')).toBe(dbUrl); + expect(adapter.has('DATABASE_URL')).toBe(true); + }); + + it('should handle port number pattern', () => { + process.env.PORT = '3000'; + + expect(adapter.get('PORT')).toBe('3000'); // Note: always returns string + expect(adapter.get('PORT', '8080')).toBe('3000'); + }); + + it('should handle boolean-like values', () => { + process.env.DEBUG = 'true'; + process.env.PRODUCTION = 'false'; + process.env.ENABLED = '1'; + process.env.DISABLED = '0'; + + // Note: Environment adapter returns strings, interpretation is up to caller + expect(adapter.get('DEBUG')).toBe('true'); + expect(adapter.get('PRODUCTION')).toBe('false'); + expect(adapter.get('ENABLED')).toBe('1'); + expect(adapter.get('DISABLED')).toBe('0'); + }); + }); + + describe('edge cases and error conditions', () => { + it('should handle very long variable names', () => { + const longName = 'A'.repeat(1000); + process.env[longName] = 'long_name_value'; + + expect(adapter.get(longName)).toBe('long_name_value'); + expect(adapter.has(longName)).toBe(true); + }); + + it('should handle very long variable values', () => { + const longValue = 'x'.repeat(100000); + process.env.LONG_VALUE = longValue; + + expect(adapter.get('LONG_VALUE')).toBe(longValue); + }); + + it('should handle numeric variable names (though unusual)', () => { + process.env['123'] = 'numeric_name'; + + expect(adapter.get('123')).toBe('numeric_name'); + expect(adapter.has('123')).toBe(true); + }); + + it('should handle variable names with special characters', () => { + // Some systems allow these characters in env var names + process.env['VAR_WITH.DOT'] = 'dot_value'; + process.env['VAR-WITH-DASH'] = 'dash_value'; + + expect(adapter.get('VAR_WITH.DOT')).toBe('dot_value'); + expect(adapter.get('VAR-WITH-DASH')).toBe('dash_value'); + }); + + it('should maintain consistency across multiple calls', () => { + process.env.CONSISTENT_VAR = 'consistent_value'; + + const calls = []; + for (let i = 0; i < 100; i++) { + calls.push(adapter.get('CONSISTENT_VAR')); + } + + expect(calls.every((value) => value === 'consistent_value')).toBe(true); + }); + + it('should handle concurrent access', async () => { + process.env.CONCURRENT_VAR = 'concurrent_value'; + + const promises = []; + for (let i = 0; i < 100; i++) { + promises.push(Promise.resolve(adapter.get('CONCURRENT_VAR'))); + } + + const results = await Promise.all(promises); + expect(results.every((value) => value === 'concurrent_value')).toBe(true); + }); + }); + + describe('integration with real environment', () => { + it('should access actual PATH variable', () => { + // PATH should exist in most environments + const path = adapter.get('PATH'); + if (path) { + expect(typeof path).toBe('string'); + expect(path.length).toBeGreaterThan(0); + expect(adapter.has('PATH')).toBe(true); + } + }); + + it('should handle common CI environment variables', () => { + // Test some common CI environment variables that might exist + const ciVars = ['CI', 'GITHUB_ACTIONS', 'TRAVIS', 'CIRCLECI', 'BUILD_NUMBER']; + + ciVars.forEach((varName) => { + const value = adapter.get(varName); + const exists = adapter.has(varName); + + if (exists) { + expect(typeof value).toBe('string'); + } else { + expect(value).toBeUndefined(); + } + }); + }); + }); +}); diff --git a/test/unit/events/CommandEvent.test.js b/test/unit/events/CommandEvent.test.js new file mode 100644 index 0000000..fcd1e32 --- /dev/null +++ b/test/unit/events/CommandEvent.test.js @@ -0,0 +1,811 @@ +/** + * Unit tests for CommandEvent instanceof validation + * + * Tests the CommandEvent class hierarchy and validation including: + * - Base CommandEvent class functionality + * - Event inheritance and instanceof checks + * - Runtime validation with validateCommandEvent + * - Event factory and type creation + * - JSON serialization and toString methods + * - Build-specific event classes + * - Event metadata and properties + */ + +import { describe, it, expect, beforeEach, vi } from 'vitest'; +import { + CommandEvent, + ProgressEvent, + ErrorEvent, + DirectoryEvent, + SuccessEvent, + WarningEvent, + StartEvent, + StatusEvent, + CompleteEvent, + CancelledEvent, + BuildProgressEvent, + BuildStartEvent, + BuildCompleteEvent, + BuildFailedEvent, + validateCommandEvent, + createCommandEvent +} from '../../../src/lib/events/CommandEvents.cjs'; + +describe('CommandEvent base class', () => { + let baseEvent; + + beforeEach(() => { + baseEvent = new CommandEvent('test', 'Test message', { + testProperty: 'test value', + metadata: { source: 'unit test' } + }); + }); + + describe('constructor and basic properties', () => { + it('should create event with correct properties', () => { + expect(baseEvent.type).toBe('test'); + expect(baseEvent.message).toBe('Test message'); + expect(baseEvent.details).toEqual({ + testProperty: 'test value', + metadata: { source: 'unit test' } + }); + expect(baseEvent.timestamp).toBeInstanceOf(Date); + }); + + it('should set timestamp close to creation time', () => { + const beforeCreate = Date.now(); + const event = new CommandEvent('test', 'message'); + const afterCreate = Date.now(); + + expect(event.timestamp.getTime()).toBeGreaterThanOrEqual(beforeCreate); + expect(event.timestamp.getTime()).toBeLessThanOrEqual(afterCreate); + }); + + it('should handle empty details', () => { + const event = new CommandEvent('test', 'message'); + expect(event.details).toEqual({}); + }); + + it('should handle null details', () => { + const event = new CommandEvent('test', 'message', null); + expect(event.details).toBeNull(); + }); + }); + + describe('JSON serialization', () => { + it('should serialize to JSON correctly', () => { + const json = baseEvent.toJSON(); + + expect(json.type).toBe('test'); + expect(json.message).toBe('Test message'); + expect(json.details).toEqual({ + testProperty: 'test value', + metadata: { source: 'unit test' } + }); + expect(json.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/); + }); + + it('should produce valid ISO timestamp', () => { + const json = baseEvent.toJSON(); + const parsedDate = new Date(json.timestamp); + + expect(parsedDate.getTime()).toBe(baseEvent.timestamp.getTime()); + }); + + it('should handle complex details in JSON', () => { + const complexEvent = new CommandEvent('complex', 'Complex event', { + array: [1, 2, 3], + nested: { + deep: { + property: 'deep value' + } + }, + nullValue: null, + undefinedValue: undefined + }); + + const json = complexEvent.toJSON(); + expect(json.details.array).toEqual([1, 2, 3]); + expect(json.details.nested.deep.property).toBe('deep value'); + expect(json.details.nullValue).toBeNull(); + expect('undefinedValue' in json.details).toBe(true); + }); + }); + + describe('toString method', () => { + it('should format as expected', () => { + const result = baseEvent.toString(); + expect(result).toBe('[TEST] Test message'); + }); + + it('should uppercase event type', () => { + const event = new CommandEvent('progress', 'Loading data'); + expect(event.toString()).toBe('[PROGRESS] Loading data'); + }); + + it('should handle empty message', () => { + const event = new CommandEvent('error', ''); + expect(event.toString()).toBe('[ERROR] '); + }); + }); +}); + +describe('ProgressEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const progressEvent = new ProgressEvent('Loading...', 50); + expect(progressEvent).toBeInstanceOf(CommandEvent); + expect(progressEvent).toBeInstanceOf(ProgressEvent); + }); + + it('should pass validateCommandEvent check', () => { + const progressEvent = new ProgressEvent('Processing...', 25); + expect(() => validateCommandEvent(progressEvent, ProgressEvent)).not.toThrow(); + }); + + it('should fail validation against wrong class', () => { + const progressEvent = new ProgressEvent('Testing...', 75); + expect(() => validateCommandEvent(progressEvent, ErrorEvent)).toThrow( + 'Invalid event type: expected ErrorEvent, got ProgressEvent' + ); + }); + }); + + describe('constructor and properties', () => { + it('should create with percentage', () => { + const event = new ProgressEvent('Loading files...', 50, { filesProcessed: 5 }); + + expect(event.type).toBe('progress'); + expect(event.message).toBe('Loading files...'); + expect(event.percentage).toBe(50); + expect(event.details.filesProcessed).toBe(5); + }); + + it('should create with null percentage for indeterminate progress', () => { + const event = new ProgressEvent('Processing...', null); + + expect(event.percentage).toBeNull(); + }); + + it('should validate percentage range', () => { + expect(() => new ProgressEvent('Test', 150)).toThrow( + 'Percentage must be a number between 0 and 100, or null' + ); + expect(() => new ProgressEvent('Test', -10)).toThrow( + 'Percentage must be a number between 0 and 100, or null' + ); + }); + + it('should accept valid percentage values', () => { + expect(() => new ProgressEvent('Test', 0)).not.toThrow(); + expect(() => new ProgressEvent('Test', 100)).not.toThrow(); + expect(() => new ProgressEvent('Test', 50.5)).not.toThrow(); + }); + + it('should reject non-numeric percentages', () => { + expect(() => new ProgressEvent('Test', '50')).toThrow(); + expect(() => new ProgressEvent('Test', true)).toThrow(); + expect(() => new ProgressEvent('Test', {})).toThrow(); + }); + }); + + describe('static factory methods', () => { + it('should create with calculated percentage', () => { + const event = ProgressEvent.withPercentage('Processing files', 25, 50, { + operation: 'compile' + }); + + expect(event.percentage).toBe(50); // 25/50 * 100 = 50% + expect(event.details.completed).toBe(25); + expect(event.details.total).toBe(50); + expect(event.details.operation).toBe('compile'); + }); + + it('should handle zero total in withPercentage', () => { + const event = ProgressEvent.withPercentage('Starting', 0, 0); + expect(event.percentage).toBe(0); + }); + + it('should create indeterminate progress', () => { + const event = ProgressEvent.indeterminate('Initializing...', { + stage: 'setup' + }); + + expect(event.percentage).toBeNull(); + expect(event.details.stage).toBe('setup'); + }); + }); +}); + +describe('ErrorEvent', () => { + let testError; + + beforeEach(() => { + testError = new Error('Test error message'); + testError.code = 'TEST_ERROR'; + }); + + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const errorEvent = new ErrorEvent('Operation failed', testError); + expect(errorEvent).toBeInstanceOf(CommandEvent); + expect(errorEvent).toBeInstanceOf(ErrorEvent); + }); + + it('should pass validateCommandEvent check', () => { + const errorEvent = new ErrorEvent('Database error', testError, 'DB_ERROR'); + expect(() => validateCommandEvent(errorEvent, ErrorEvent)).not.toThrow(); + }); + }); + + describe('constructor and properties', () => { + it('should create with error object and code', () => { + const event = new ErrorEvent('Database connection failed', testError, 'DB_CONN_ERROR', { + host: 'localhost', + port: 5432 + }); + + expect(event.type).toBe('error'); + expect(event.message).toBe('Database connection failed'); + expect(event.error).toBe(testError); + expect(event.code).toBe('DB_CONN_ERROR'); + expect(event.details.host).toBe('localhost'); + expect(event.details.error).toBe(testError); + expect(event.details.code).toBe('DB_CONN_ERROR'); + }); + + it('should handle null error', () => { + const event = new ErrorEvent('Unknown error', null, 'UNKNOWN'); + expect(event.error).toBeNull(); + }); + + it('should handle missing code', () => { + const event = new ErrorEvent('Simple error', testError); + expect(event.code).toBeNull(); + }); + }); + + describe('static factory methods', () => { + it('should create from error object', () => { + const event = ErrorEvent.fromError(testError, 'Database operation failed', { + table: 'users' + }); + + expect(event.message).toBe('Database operation failed: Test error message'); + expect(event.error).toBe(testError); + expect(event.code).toBe('TEST_ERROR'); + expect(event.details.table).toBe('users'); + }); + + it('should handle error without code', () => { + const simpleError = new Error('Simple error'); + const event = ErrorEvent.fromError(simpleError); + + expect(event.code).toBeNull(); + expect(event.message).toBe('Operation failed: Simple error'); + }); + }); + + describe('stack trace access', () => { + it('should return stack trace when available', () => { + const event = new ErrorEvent('Stack test', testError); + const stack = event.getStackTrace(); + + expect(stack).toContain('Error: Test error message'); + expect(stack).toContain('at '); // Stack trace format + }); + + it('should handle missing stack trace', () => { + const noStackError = { message: 'No stack' }; // Not a real Error object + const event = new ErrorEvent('No stack test', noStackError); + + expect(event.getStackTrace()).toBe('No stack trace available'); + }); + }); +}); + +describe('DirectoryEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const dirEvent = new DirectoryEvent('Processing directory', '/src/lib'); + expect(dirEvent).toBeInstanceOf(CommandEvent); + expect(dirEvent).toBeInstanceOf(DirectoryEvent); + }); + }); + + describe('constructor and properties', () => { + it('should create with directory path and operation', () => { + const event = new DirectoryEvent('Scanning source directory', '/src/components', 'scan', { + fileCount: 25 + }); + + expect(event.type).toBe('directory'); + expect(event.directoryPath).toBe('/src/components'); + expect(event.operation).toBe('scan'); + expect(event.details.directoryPath).toBe('/src/components'); + expect(event.details.operation).toBe('scan'); + expect(event.details.fileCount).toBe(25); + }); + + it('should default to process operation', () => { + const event = new DirectoryEvent('Processing...', '/tmp'); + expect(event.operation).toBe('process'); + }); + }); + + describe('static factory methods', () => { + it('should create scan event', () => { + const event = DirectoryEvent.scan('/src', 15, { pattern: '*.js' }); + + expect(event.operation).toBe('scan'); + expect(event.message).toBe('Scanning directory: /src'); + expect(event.details.fileCount).toBe(15); + expect(event.details.pattern).toBe('*.js'); + }); + + it('should create create event', () => { + const event = DirectoryEvent.create('/dist/output', { mode: 0o755 }); + + expect(event.operation).toBe('create'); + expect(event.message).toBe('Creating directory: /dist/output'); + expect(event.details.mode).toBe(0o755); + }); + }); +}); + +describe('SuccessEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const successEvent = new SuccessEvent('Operation completed'); + expect(successEvent).toBeInstanceOf(CommandEvent); + expect(successEvent).toBeInstanceOf(SuccessEvent); + }); + }); + + describe('constructor and timing', () => { + it('should create with duration', () => { + const event = new SuccessEvent('Migration completed', { migrationsApplied: 5 }, 2500); + + expect(event.type).toBe('success'); + expect(event.duration).toBe(2500); + expect(event.details.duration).toBe(2500); + expect(event.details.migrationsApplied).toBe(5); + }); + + it('should handle null duration', () => { + const event = new SuccessEvent('Success', {}, null); + expect(event.duration).toBeNull(); + }); + }); + + describe('timing utilities', () => { + it('should create with calculated timing', () => { + const startTime = new Date(Date.now() - 3000); // 3 seconds ago + const event = SuccessEvent.withTiming('Build completed', startTime, { outputFiles: 10 }); + + expect(event.duration).toBeGreaterThanOrEqual(2900); + expect(event.duration).toBeLessThanOrEqual(3100); + expect(event.details.outputFiles).toBe(10); + }); + + it('should format duration in milliseconds', () => { + const event = new SuccessEvent('Fast operation', {}, 500); + expect(event.getFormattedDuration()).toBe('500ms'); + }); + + it('should format duration in seconds', () => { + const event = new SuccessEvent('Slow operation', {}, 2500); + expect(event.getFormattedDuration()).toBe('2.5s'); + }); + + it('should handle missing duration', () => { + const event = new SuccessEvent('No timing', {}, null); + expect(event.getFormattedDuration()).toBeNull(); + }); + + it('should format sub-second durations correctly', () => { + const event = new SuccessEvent('Quick operation', {}, 1750); + expect(event.getFormattedDuration()).toBe('1.75s'); + }); + }); +}); + +describe('WarningEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const warningEvent = new WarningEvent('Deprecated API usage'); + expect(warningEvent).toBeInstanceOf(CommandEvent); + expect(warningEvent).toBeInstanceOf(WarningEvent); + }); + }); + + describe('constructor and properties', () => { + it('should create with warning code', () => { + const event = new WarningEvent( + 'Configuration file not found, using defaults', + { configPath: '/app/.datarc.json' }, + 'CONFIG_MISSING' + ); + + expect(event.type).toBe('warning'); + expect(event.code).toBe('CONFIG_MISSING'); + expect(event.details.code).toBe('CONFIG_MISSING'); + expect(event.details.configPath).toBe('/app/.datarc.json'); + }); + + it('should handle missing code', () => { + const event = new WarningEvent('General warning'); + expect(event.code).toBeNull(); + }); + }); +}); + +describe('StartEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const startEvent = new StartEvent('Starting migration'); + expect(startEvent).toBeInstanceOf(CommandEvent); + expect(startEvent).toBeInstanceOf(StartEvent); + }); + }); + + describe('production mode factory', () => { + it('should create production start event', () => { + const event = StartEvent.production('Starting production deployment', { + environment: 'production' + }); + + expect(event.type).toBe('start'); + expect(event.details.isProd).toBe(true); + expect(event.details.environment).toBe('production'); + }); + }); +}); + +describe('StatusEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const statusEvent = new StatusEvent('Service status', 'healthy'); + expect(statusEvent).toBeInstanceOf(CommandEvent); + expect(statusEvent).toBeInstanceOf(StatusEvent); + }); + }); + + describe('constructor and status checking', () => { + it('should create with status value', () => { + const event = new StatusEvent('Database connection status', 'active', { connectionPool: 5 }); + + expect(event.status).toBe('active'); + expect(event.details.status).toBe('active'); + expect(event.details.connectionPool).toBe(5); + }); + + it('should identify healthy statuses', () => { + const healthyStatuses = ['healthy', 'ok', 'success', 'active', 'running']; + + healthyStatuses.forEach((status) => { + const event = new StatusEvent('Test status', status); + expect(event.isHealthy()).toBe(true); + }); + }); + + it('should identify unhealthy statuses', () => { + const unhealthyStatuses = ['error', 'failed', 'inactive', 'stopped', 'degraded']; + + unhealthyStatuses.forEach((status) => { + const event = new StatusEvent('Test status', status); + expect(event.isHealthy()).toBe(false); + }); + }); + + it('should handle case insensitive status check', () => { + const event = new StatusEvent('Test', 'HEALTHY'); + expect(event.isHealthy()).toBe(true); + }); + }); +}); + +describe('CompleteEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const completeEvent = new CompleteEvent('Task completed'); + expect(completeEvent).toBeInstanceOf(CommandEvent); + expect(completeEvent).toBeInstanceOf(CompleteEvent); + }); + }); + + describe('constructor with result', () => { + it('should create with result data', () => { + const result = { processedFiles: 25, errors: 0 }; + const event = new CompleteEvent('Compilation completed', result, { outputDir: '/dist' }); + + expect(event.result).toBe(result); + expect(event.details.result).toBe(result); + expect(event.details.outputDir).toBe('/dist'); + }); + + it('should handle null result', () => { + const event = new CompleteEvent('Simple completion', null); + expect(event.result).toBeNull(); + }); + }); +}); + +describe('CancelledEvent', () => { + describe('instanceof validation', () => { + it('should be instance of CommandEvent', () => { + const cancelledEvent = new CancelledEvent(); + expect(cancelledEvent).toBeInstanceOf(CommandEvent); + expect(cancelledEvent).toBeInstanceOf(CancelledEvent); + }); + }); + + describe('constructor and cancellation reasons', () => { + it('should create with default message', () => { + const event = new CancelledEvent(); + expect(event.message).toBe('Operation cancelled'); + expect(event.reason).toBeNull(); + }); + + it('should create with custom message and reason', () => { + const event = new CancelledEvent('User cancelled migration', 'user_request', { + stage: 'confirmation' + }); + + expect(event.message).toBe('User cancelled migration'); + expect(event.reason).toBe('user_request'); + expect(event.details.reason).toBe('user_request'); + expect(event.details.stage).toBe('confirmation'); + }); + }); +}); + +describe('Build-specific events', () => { + describe('BuildProgressEvent', () => { + it('should be instance of CommandEvent', () => { + const buildEvent = new BuildProgressEvent('compile', '/src', '/dist'); + expect(buildEvent).toBeInstanceOf(CommandEvent); + expect(buildEvent).toBeInstanceOf(BuildProgressEvent); + }); + + it('should create with build stage information', () => { + const event = new BuildProgressEvent('compile', '/src/lib', '/dist/lib', { + filesProcessed: 15 + }); + + expect(event.type).toBe('build:progress'); + expect(event.stage).toBe('compile'); + expect(event.inputDir).toBe('/src/lib'); + expect(event.outputDir).toBe('/dist/lib'); + expect(event.details.filesProcessed).toBe(15); + }); + + it('should convert to event data format', () => { + const event = new BuildProgressEvent('test', '/input', '/output'); + const eventData = event.toEventData(); + + expect(eventData.eventType).toBe('BuildProgressEvent'); + expect(eventData.stage).toBe('test'); + expect(eventData.inputDir).toBe('/input'); + expect(eventData.outputDir).toBe('/output'); + expect(eventData.timestamp).toBeTruthy(); + }); + }); + + describe('BuildStartEvent', () => { + it('should be instance of CommandEvent', () => { + const buildStart = new BuildStartEvent('incremental', '/src', '/dist'); + expect(buildStart).toBeInstanceOf(CommandEvent); + expect(buildStart).toBeInstanceOf(BuildStartEvent); + }); + + it('should create with build type information', () => { + const event = new BuildStartEvent('full', '/project/src', '/project/dist', { clean: true }); + + expect(event.type).toBe('build:start'); + expect(event.message).toBe('Starting full build'); + expect(event.buildType || event.type).toBeTruthy(); // Handle different property names + }); + }); + + describe('BuildCompleteEvent', () => { + it('should be instance of CommandEvent', () => { + const buildComplete = new BuildCompleteEvent({ files: 10 }); + expect(buildComplete).toBeInstanceOf(CommandEvent); + expect(buildComplete).toBeInstanceOf(BuildCompleteEvent); + }); + + it('should create with build result', () => { + const result = { files: 25, duration: 5000, size: '2.5MB' }; + const event = new BuildCompleteEvent(result, { warnings: 2 }); + + expect(event.type).toBe('build:complete'); + expect(event.result).toBe(result); + expect(event.details.warnings).toBe(2); + }); + }); + + describe('BuildFailedEvent', () => { + it('should be instance of CommandEvent', () => { + const error = new Error('Build failed'); + const buildFailed = new BuildFailedEvent(error); + expect(buildFailed).toBeInstanceOf(CommandEvent); + expect(buildFailed).toBeInstanceOf(BuildFailedEvent); + }); + + it('should create with build error', () => { + const buildError = new Error('TypeScript compilation error'); + buildError.code = 'TS2304'; + + const event = new BuildFailedEvent(buildError, { file: 'src/index.ts' }); + + expect(event.type).toBe('build:failed'); + expect(event.buildError).toBe(buildError); + expect(event.details.file).toBe('src/index.ts'); + }); + + it('should serialize error in event data', () => { + const error = new Error('Test build error'); + error.stack = 'Error: Test build error\n at test'; + + const event = new BuildFailedEvent(error); + const eventData = event.toEventData(); + + expect(eventData.eventType).toBe('BuildFailedEvent'); + expect(eventData.error.message).toBe('Test build error'); + expect(eventData.error.stack).toContain('Error: Test build error'); + }); + }); +}); + +describe('validateCommandEvent utility', () => { + it('should validate correct event types', () => { + const progressEvent = new ProgressEvent('Loading', 50); + const errorEvent = new ErrorEvent('Failed', new Error('test')); + + expect(() => validateCommandEvent(progressEvent, ProgressEvent)).not.toThrow(); + expect(() => validateCommandEvent(errorEvent, ErrorEvent)).not.toThrow(); + expect(() => validateCommandEvent(progressEvent, CommandEvent)).not.toThrow(); + }); + + it('should throw for incorrect event types', () => { + const progressEvent = new ProgressEvent('Loading', 50); + + expect(() => validateCommandEvent(progressEvent, ErrorEvent)).toThrow( + 'Invalid event type: expected ErrorEvent, got ProgressEvent' + ); + }); + + it('should handle null events', () => { + expect(() => validateCommandEvent(null, ProgressEvent)).toThrow(); + }); + + it('should handle undefined events', () => { + expect(() => validateCommandEvent(undefined, ErrorEvent)).toThrow(); + }); + + it('should handle non-object events', () => { + expect(() => validateCommandEvent('string', CommandEvent)).toThrow(); + expect(() => validateCommandEvent(42, CommandEvent)).toThrow(); + }); + + it('should provide helpful error messages', () => { + const plainObject = { type: 'fake', message: 'fake event' }; + + expect(() => validateCommandEvent(plainObject, ProgressEvent)).toThrow( + 'Invalid event type: expected ProgressEvent, got Object' + ); + }); +}); + +describe('createCommandEvent factory', () => { + it('should create correct event types', () => { + const progress = createCommandEvent('progress', 'Loading...', 75); + const error = createCommandEvent('error', 'Failed', new Error('test')); + const success = createCommandEvent('success', 'Done', { files: 10 }); + + expect(progress).toBeInstanceOf(ProgressEvent); + expect(error).toBeInstanceOf(ErrorEvent); + expect(success).toBeInstanceOf(SuccessEvent); + }); + + it('should create build events', () => { + const buildStart = createCommandEvent('build:start', 'full', '/src', '/dist'); + const buildProgress = createCommandEvent('build:progress', 'compile', '/src', '/dist'); + + expect(buildStart).toBeInstanceOf(BuildStartEvent); + expect(buildProgress).toBeInstanceOf(BuildProgressEvent); + }); + + it('should throw for unknown event types', () => { + expect(() => createCommandEvent('unknown', 'message')).toThrow('Unknown event type: unknown'); + }); + + it('should pass arguments to event constructors', () => { + const directory = createCommandEvent('directory', 'Processing dir', '/src', 'scan'); + + expect(directory.directoryPath).toBe('/src'); + expect(directory.operation).toBe('scan'); + }); + + it('should list available event types in error message', () => { + try { + createCommandEvent('invalid', 'message'); + } catch (error) { + expect(error.message).toContain('Available types:'); + expect(error.message).toContain('progress'); + expect(error.message).toContain('error'); + expect(error.message).toContain('build:start'); + } + }); +}); + +describe('runtime type safety and inheritance chain', () => { + it('should maintain correct instanceof relationships', () => { + const events = [ + new ProgressEvent('test', 50), + new ErrorEvent('test', new Error()), + new SuccessEvent('test'), + new BuildProgressEvent('compile', '/src', '/dist') + ]; + + events.forEach((event) => { + expect(event).toBeInstanceOf(CommandEvent); + expect(event).toBeInstanceOf(Object); + }); + }); + + it('should preserve event type hierarchy with validateCommandEvent', () => { + const buildProgress = new BuildProgressEvent('compile', '/src', '/dist'); + + // Should validate as BuildProgressEvent + expect(() => validateCommandEvent(buildProgress, BuildProgressEvent)).not.toThrow(); + + // Should validate as CommandEvent (parent class) + expect(() => validateCommandEvent(buildProgress, CommandEvent)).not.toThrow(); + + // Should fail as unrelated event type + expect(() => validateCommandEvent(buildProgress, ErrorEvent)).toThrow(); + }); + + it('should handle event polymorphism correctly', () => { + const events = [ + new ProgressEvent('Loading', 25), + new ErrorEvent('Failed', new Error('test')), + new SuccessEvent('Complete', { files: 5 }) + ]; + + // All should be treatable as CommandEvent + events.forEach((event) => { + expect(event.type).toBeTruthy(); + expect(event.message).toBeTruthy(); + expect(event.timestamp).toBeInstanceOf(Date); + expect(typeof event.toJSON).toBe('function'); + expect(typeof event.toString).toBe('function'); + }); + }); + + it('should maintain event identity through validation', () => { + const originalEvent = new ProgressEvent('Processing', 60, { stage: 'compile' }); + + // Validation should not modify the event + validateCommandEvent(originalEvent, ProgressEvent); + + expect(originalEvent.percentage).toBe(60); + expect(originalEvent.details.stage).toBe('compile'); + expect(originalEvent.message).toBe('Processing'); + }); + + it('should detect type mismatches at runtime', () => { + const mockEvent = { + type: 'progress', + message: 'Fake progress', + percentage: 50, + details: {}, + timestamp: new Date() + }; + + // Plain object should fail instanceof check + expect(() => validateCommandEvent(mockEvent, ProgressEvent)).toThrow(); + }); +}); diff --git a/vitest.config.js b/vitest.config.js index ca4eafb..e98d046 100644 --- a/vitest.config.js +++ b/vitest.config.js @@ -19,4 +19,4 @@ export default defineConfig({ setupFiles: ['./test/setup.js'], forceExit: true // Force exit after tests complete } -}); \ No newline at end of file +});