hana-linter 0.1.1

package/dist/content-lint.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintFileContent = lintFileContent;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Run content-based naming lint for a file.
+ *
+ * @param filePath - Candidate file path.
+ * @param contentRuleSets - Configured content rule sets.
+ * @returns List of content-based lint issues.
+ */
+async function lintFileContent(filePath, contentRuleSets) {
+    const extension = node_path_1.default.extname(filePath);
+    const matchingRuleSets = contentRuleSets.filter((ruleSet) => ruleSet.extension === '*' || ruleSet.extension === extension);
+    if (matchingRuleSets.length === 0) {
+        return [];
+    }
+    const fileContent = await node_fs_1.promises.readFile(filePath, { encoding: 'utf-8' });
+    const extractedSubjects = extractSubjects(extension, fileContent);
+    if (extractedSubjects.length === 0) {
+        return [];
+    }
+    const issues = [];
+    for (const subject of extractedSubjects) {
+        const targetRuleSets = matchingRuleSets.filter((ruleSet) => ruleSet.target === subject.type);
+        if (targetRuleSets.length === 0) {
+            continue;
+        }
+        const allRules = targetRuleSets.flatMap((ruleSet) => ruleSet.groups.all ?? []);
+        const anyRules = targetRuleSets.flatMap((ruleSet) => ruleSet.groups.any ?? []);
+        if (allRules.length > 0) {
+            issues.push(...evaluateAllRules(filePath, extension, subject, allRules));
+        }
+        if (anyRules.length > 0) {
+            issues.push(...evaluateAnyRules(filePath, extension, subject, anyRules));
+        }
+    }
+    return issues;
+}
+function extractSubjects(extension, fileContent) {
+    if (extension === '.hdbtable') {
+        return extractTableFields(fileContent);
+    }
+    if (extension === '.hdbprocedure' || extension === '.hdbfunction') {
+        return extractProcedureFunctionParameters(fileContent);
+    }
+    return [];
+}
+function extractTableFields(fileContent) {
+    const subjects = [];
+    const seen = new Set();
+    const lines = fileContent.split(/\r?\n/);
+    const skipKeywords = new Set(['PRIMARY', 'CONSTRAINT', 'UNIQUE', 'FOREIGN', 'CHECK', 'PARTITION', 'INDEX', 'KEY']);
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.length === 0 || trimmedLine.startsWith('--')) {
+            continue;
+        }
+        const unquotedMatch = trimmedLine.match(/^([A-Za-z_][A-Za-z0-9_]*)\s+[A-Za-z]/);
+        if (unquotedMatch) {
+            const candidate = unquotedMatch[1];
+            if (!candidate) {
+                continue;
+            }
+            if (!skipKeywords.has(candidate.toUpperCase()) && !seen.has(candidate)) {
+                seen.add(candidate);
+                subjects.push({ type: 'field', name: candidate });
+            }
+            continue;
+        }
+        const quotedMatch = trimmedLine.match(/^"([A-Za-z_][A-Za-z0-9_]*)"\s+[A-Za-z]/);
+        if (quotedMatch) {
+            const candidate = quotedMatch[1];
+            if (!candidate) {
+                continue;
+            }
+            if (!seen.has(candidate)) {
+                seen.add(candidate);
+                subjects.push({ type: 'field', name: candidate });
+            }
+        }
+    }
+    return subjects;
+}
+function extractProcedureFunctionParameters(fileContent) {
+    const subjects = [];
+    const seen = new Set();
+    const parameterRegex = /\b(IN|OUT|INOUT)\s+("?[A-Za-z_][A-Za-z0-9_]*"?)\s+[A-Za-z]/gi;
+    let match = parameterRegex.exec(fileContent);
+    while (match) {
+        const mode = match[1];
+        const rawName = match[2];
+        if (!mode || !rawName) {
+            match = parameterRegex.exec(fileContent);
+            continue;
+        }
+        const normalizedMode = mode.toUpperCase();
+        const normalizedName = rawName.replace(/^"|"$/g, '');
+        if ((normalizedMode === 'IN' || normalizedMode === 'INOUT') && !seen.has(`input:${normalizedName}`)) {
+            seen.add(`input:${normalizedName}`);
+            subjects.push({ type: 'inputParameter', name: normalizedName });
+        }
+        if ((normalizedMode === 'OUT' || normalizedMode === 'INOUT') && !seen.has(`output:${normalizedName}`)) {
+            seen.add(`output:${normalizedName}`);
+            subjects.push({ type: 'outputParameter', name: normalizedName });
+        }
+        match = parameterRegex.exec(fileContent);
+    }
+    return subjects;
+}
+function evaluateAllRules(filePath, extension, subject, rules) {
+    const issues = [];
+    for (const rule of rules) {
+        if (!rule.pattern.test(subject.name)) {
+            issues.push({
+                filePath,
+                artifactName: node_path_1.default.parse(filePath).name,
+                extension,
+                subjectType: subject.type,
+                subjectName: subject.name,
+                failedRuleDescription: rule.description,
+                failedPattern: toRegexLiteral(rule)
+            });
+        }
+    }
+    return issues;
+}
+function evaluateAnyRules(filePath, extension, subject, rules) {
+    const hasAtLeastOneMatch = rules.some((rule) => rule.pattern.test(subject.name));
+    if (hasAtLeastOneMatch) {
+        return [];
+    }
+    return [
+        {
+            filePath,
+            artifactName: node_path_1.default.parse(filePath).name,
+            extension,
+            subjectType: subject.type,
+            subjectName: subject.name,
+            failedRuleDescription: 'At least one OR-group rule must match: ' + rules.map((rule) => rule.description).join(' | '),
+            failedPattern: rules.map(toRegexLiteral).join(' OR ')
+        }
+    ];
+}
+function toRegexLiteral(rule) {
+    return `/${rule.source}/${rule.flags}`;
+}

package/dist/files.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFilesToValidate = resolveFilesToValidate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Resolve files to validate:
+ * - If CLI files are provided: use only existing files from that list.
+ * - If none are provided: run full scan from rootDir.
+ *
+ * @param config - Lint configuration.
+ * @param cliInput - Parsed CLI input.
+ * @returns List of file paths to validate.
+ */
+async function resolveFilesToValidate(config, cliInput) {
+    if (cliInput.files.length > 0) {
+        const existingChecks = await Promise.all(cliInput.files.map(async (filePath) => ({
+            filePath,
+            exists: await isExistingFile(filePath)
+        })));
+        return existingChecks.filter((item) => item.exists).map((item) => node_path_1.default.normalize(item.filePath));
+    }
+    const rootExists = await node_fs_1.promises
+        .access(config.rootDir)
+        .then(() => true)
+        .catch(() => false);
+    if (!rootExists) {
+        throw new Error(`Configured root directory does not exist: "${config.rootDir}"`);
+    }
+    return collectFiles(config.rootDir, config.ignoredDirectories);
+}
+/**
+ * Check if a path exists and is a regular file.
+ *
+ * @param filePath - Path to validate.
+ * @returns True if path exists and is a file.
+ */
+async function isExistingFile(filePath) {
+    try {
+        const stat = await node_fs_1.promises.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Recursively collect all files from a directory while skipping ignored folders.
+ *
+ * @param directoryPath - Absolute or relative folder path.
+ * @param ignoredDirectories - Directory names to skip.
+ * @returns List of full file paths.
+ */
+async function collectFiles(directoryPath, ignoredDirectories) {
+    const entries = await node_fs_1.promises.readdir(directoryPath, { withFileTypes: true });
+    const collected = await Promise.all(entries.map(async (entry) => {
+        const fullPath = node_path_1.default.join(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+            if (ignoredDirectories.includes(entry.name)) {
+                return [];
+            }
+            return collectFiles(fullPath, ignoredDirectories);
+        }
+        if (entry.isFile()) {
+            return [fullPath];
+        }
+        return [];
+    }));
+    return collected.flat();
+}

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+const config_1 = require("./config");
+const files_1 = require("./files");
+const lint_1 = require("./lint");
+const report_1 = require("./report");
+/**
+ * Application entry point.
+ */
+async function main() {
+    const cliInput = (0, cli_1.parseCliInput)();
+    if (cliInput.command === 'init') {
+        await (0, cli_1.runInit)(cliInput.force);
+        return;
+    }
+    const jsonConfig = await (0, config_1.readJsonConfig)(cliInput.configPath);
+    const config = (0, config_1.toLintConfig)(jsonConfig);
+    const filesToValidate = await (0, files_1.resolveFilesToValidate)(config, cliInput);
+    const issues = await (0, lint_1.runLint)(config, filesToValidate);
+    (0, report_1.printReport)(issues, filesToValidate);
+    if (issues.length > 0) {
+        process.exitCode = 1;
+    }
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : 'Unknown error occurred';
+    console.error(`❌ HANA naming lint crashed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/lint.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLint = runLint;
+const node_path_1 = __importDefault(require("node:path"));
+const content_lint_1 = require("./content-lint");
+/**
+ * Run naming lint and return all discovered issues.
+ *
+ * @param config - Lint configuration.
+ * @param filesToValidate - File paths to validate.
+ * @returns All naming violations.
+ */
+async function runLint(config, filesToValidate) {
+    const issues = [];
+    for (const filePath of filesToValidate) {
+        const fileIssues = validateFileName(filePath, config.extensionRuleSets, config.rootDir);
+        issues.push(...fileIssues);
+        if (config.contentRuleSets.length > 0) {
+            const contentIssues = await (0, content_lint_1.lintFileContent)(filePath, config.contentRuleSets);
+            issues.push(...contentIssues);
+        }
+    }
+    return issues;
+}
+/**
+ * Validate a single file against configured rule groups for its extension.
+ *
+ * @param filePath - Full file path.
+ * @param extensionRuleSets - Configured extension rule sets.
+ * @param rootDir - Configured root directory.
+ * @returns List of lint issues.
+ */
+function validateFileName(filePath, extensionRuleSets, rootDir) {
+    const extension = node_path_1.default.extname(filePath);
+    const matchedRuleSets = findRuleSetsForExtension(extension, extensionRuleSets);
+    const ruleSet = mergeRuleSets(extension, matchedRuleSets);
+    if (!ruleSet) {
+        return [];
+    }
+    const artifactName = getArtifactNameFromFilePath(filePath);
+    const issues = [];
+    if (ruleSet.folderName && !isFileInRequiredFolder(filePath, rootDir, ruleSet.folderName)) {
+        issues.push({
+            filePath,
+            artifactName,
+            extension,
+            subjectType: 'artifact',
+            subjectName: artifactName,
+            failedRuleDescription: `File must be located in folder "${ruleSet.folderName}" under configured rootDir`,
+            failedPattern: `folder:${ruleSet.folderName}`
+        });
+    }
+    const allRules = ruleSet.groups.all ?? [];
+    const anyRules = ruleSet.groups.any ?? [];
+    if (allRules.length > 0) {
+        issues.push(...evaluateAllRules(filePath, artifactName, extension, allRules));
+    }
+    if (anyRules.length > 0) {
+        issues.push(...evaluateAnyRules(filePath, artifactName, extension, anyRules));
+    }
+    return issues;
+}
+/**
+ * Extract artifact name from file path.
+ *
+ * @param filePath - Full file path.
+ * @returns Artifact name without extension.
+ */
+function getArtifactNameFromFilePath(filePath) {
+    const parsed = node_path_1.default.parse(filePath);
+    return parsed.name;
+}
+/**
+ * Resolve matching rule sets for a file extension.
+ *
+ * @param extension - File extension.
+ * @param extensionRuleSets - Configured extension rule sets.
+ * @returns Matching extension rule sets.
+ */
+function findRuleSetsForExtension(extension, extensionRuleSets) {
+    return extensionRuleSets.filter((ruleSet) => ruleSet.extension === '*' || ruleSet.extension === extension);
+}
+/**
+ * Merge multiple rule sets into a single effective set.
+ *
+ * @param extension - File extension.
+ * @param ruleSets - Matching rule sets for extension.
+ * @returns Merged rule set or undefined when no rules apply.
+ */
+function mergeRuleSets(extension, ruleSets) {
+    if (ruleSets.length === 0) {
+        return undefined;
+    }
+    const specificRuleSets = ruleSets.filter((ruleSet) => ruleSet.extension === extension);
+    const wildcardRuleSets = ruleSets.filter((ruleSet) => ruleSet.extension === '*');
+    const specificFolderName = specificRuleSets.find((ruleSet) => ruleSet.folderName !== undefined)?.folderName;
+    const wildcardFolderName = wildcardRuleSets.find((ruleSet) => ruleSet.folderName !== undefined)?.folderName;
+    const allRules = ruleSets.flatMap((ruleSet) => ruleSet.groups.all ?? []);
+    const anyRules = ruleSets.flatMap((ruleSet) => ruleSet.groups.any ?? []);
+    return {
+        extension,
+        folderName: specificFolderName ?? wildcardFolderName,
+        groups: {
+            all: allRules.length > 0 ? allRules : undefined,
+            any: anyRules.length > 0 ? anyRules : undefined
+        }
+    };
+}
+/**
+ * Check whether a file is located under a target folder name within rootDir.
+ *
+ * @param filePath - Candidate file path.
+ * @param rootDir - Configured root directory.
+ * @param requiredFolderName - Folder name to enforce.
+ * @returns True when file is under rootDir and contained in required folder.
+ */
+function isFileInRequiredFolder(filePath, rootDir, requiredFolderName) {
+    const absoluteRootDir = node_path_1.default.resolve(rootDir);
+    const absoluteFilePath = node_path_1.default.resolve(filePath);
+    const relativeToRoot = node_path_1.default.relative(absoluteRootDir, absoluteFilePath);
+    // Files outside rootDir are never valid for folder enforcement.
+    if (relativeToRoot.startsWith('..') || node_path_1.default.isAbsolute(relativeToRoot)) {
+        return false;
+    }
+    const parentDirectory = node_path_1.default.dirname(relativeToRoot);
+    if (parentDirectory === '.' || parentDirectory.length === 0) {
+        return false;
+    }
+    const folderSegments = parentDirectory.split(node_path_1.default.sep);
+    return folderSegments.includes(requiredFolderName);
+}
+/**
+ * Convert a rule to displayable regex literal text.
+ *
+ * @param rule - Runtime rule.
+ * @returns Regex literal-like string.
+ */
+function toRegexLiteral(rule) {
+    return `/${rule.source}/${rule.flags}`;
+}
+/**
+ * Build lint issues for failed AND-rules.
+ *
+ * @param filePath - File path.
+ * @param artifactName - Artifact name.
+ * @param extension - Artifact extension.
+ * @param rules - AND-rules list.
+ * @returns Lint issues for failed rules.
+ */
+function evaluateAllRules(filePath, artifactName, extension, rules) {
+    const issues = [];
+    for (const rule of rules) {
+        if (!rule.pattern.test(artifactName)) {
+            issues.push({
+                filePath,
+                artifactName,
+                extension,
+                subjectType: 'artifact',
+                subjectName: artifactName,
+                failedRuleDescription: rule.description,
+                failedPattern: toRegexLiteral(rule)
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Build lint issue for failed OR-group.
+ *
+ * @param filePath - File path.
+ * @param artifactName - Artifact name.
+ * @param extension - Artifact extension.
+ * @param rules - OR-rules list.
+ * @returns Single lint issue if OR-group fails; otherwise empty list.
+ */
+function evaluateAnyRules(filePath, artifactName, extension, rules) {
+    const hasAtLeastOneMatch = rules.some((rule) => rule.pattern.test(artifactName));
+    if (hasAtLeastOneMatch) {
+        return [];
+    }
+    return [
+        {
+            filePath,
+            artifactName,
+            extension,
+            subjectType: 'artifact',
+            subjectName: artifactName,
+            failedRuleDescription: 'At least one OR-group rule must match: ' + rules.map((rule) => rule.description).join(' | '),
+            failedPattern: rules.map(toRegexLiteral).join(' OR ')
+        }
+    ];
+}

package/dist/report.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printReport = printReport;
+/**
+ * Print lint result report to stdout/stderr.
+ *
+ * @param issues - Found naming violations.
+ * @param filesToValidate - Number of candidate files processed.
+ */
+function printReport(issues, filesToValidate) {
+    if (issues.length === 0) {
+        console.info(`✅ HANA naming lint passed. Checked ${filesToValidate.length} file(s).`);
+        return;
+    }
+    console.error(`❌ HANA naming lint failed. Violations: ${issues.length}`);
+    console.error('');
+    for (const issue of issues) {
+        console.error(`- File: ${issue.filePath}`);
+        console.error(`  Artifact: ${issue.artifactName}`);
+        if (issue.subjectType && issue.subjectName) {
+            console.error(`  Subject: ${issue.subjectType} (${issue.subjectName})`);
+        }
+        console.error(`  Type: ${issue.extension}`);
+        console.error(`  Failed rule: ${issue.failedRuleDescription}`);
+        console.error(`  Expected regex: ${issue.failedPattern}`);
+        console.error('');
+    }
+}

package/dist/types/cli.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/issues.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/rules.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "hana-linter",
+  "version": "0.1.1",
+  "description": "Linter for SAP HANA artifacts in an SAP CAP project",
+  "main": "./dist/index.js",
+  "bin": {
+    "hana-linter": "./dist/index.js"
+  },
+  "keywords": [
+    "hana",
+    "lint",
+    "cap",
+    "npm"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qualiture/hana-linter.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Warning: no test specified\" && exit 0"
+  },
+  "author": "Robin van het Hof (Qualiture)",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.9.3"
+  }
+}