hana-linter 0.1.1

package/src/assets/.hana-linter.json

@@ -0,0 +1,224 @@
+{
+    "rootDir": "db",
+    "ignoredDirectories": ["node_modules", ".git", "gen"],
+    "extensionRuleSets": [
+        {
+            "extension": "hdb*",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Upper snake case only",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    },
+                    {
+                        "description": "Max length 30",
+                        "pattern": "^.{1,30}$",
+                        "flags": "u"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbtable",
+            "folderName": "tables",
+            "groups": {
+                "any": [
+                    {
+                        "description": "Prefix T_",
+                        "pattern": "^T_.+"
+                    },
+                    {
+                        "description": "Prefix TX_",
+                        "pattern": "^TX_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbview",
+            "folderName": "sqlviews",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix V_",
+                        "pattern": "^V_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbfunction",
+            "folderName": "functions",
+            "groups": {
+                "any": [
+                    {
+                        "description": "Prefix TF_",
+                        "pattern": "^TF_.+"
+                    },
+                    {
+                        "description": "Prefix SF_",
+                        "pattern": "^SF_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbprocedure",
+            "folderName": "procedures",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix PR_",
+                        "pattern": "^PR_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbcalculationview",
+            "folderName": "models",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix CV_",
+                        "pattern": "^CV_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbanalyticalprivilege",
+            "folderName": "authorizations",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix AP_",
+                        "pattern": "^AP_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbrole",
+            "folderName": "roles",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix R_",
+                        "pattern": "^R_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbsequence",
+            "folderName": "sequences",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix S_",
+                        "pattern": "^S_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbtabletype",
+            "folderName": "tabletypes",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix TT_",
+                        "pattern": "^TT_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbconstraint",
+            "folderName": "constraints",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix C_",
+                        "pattern": "^C_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbschedulerjob",
+            "folderName": "jobs",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix J_",
+                        "pattern": "^J_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbindex",
+            "folderName": "indexes",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix IDX_",
+                        "pattern": "^IDX_.+"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbtrigger",
+            "folderName": "triggers",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Prefix TR_",
+                        "pattern": "^TR_.+"
+                    }
+                ]
+            }
+        }
+    ],
+    "contentRuleSets": [
+        {
+            "extension": ".hdbtable",
+            "target": "field",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Field names in uppercase snake case",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbprocedure",
+            "target": "inputParameter",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Input parameters prefixed with IP_",
+                        "pattern": "^IP_[A-Z0-9_]+$"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbprocedure",
+            "target": "outputParameter",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Output parameters prefixed with OP_",
+                        "pattern": "^OP_[A-Z0-9_]+$"
+                    }
+                ]
+            }
+        }
+    ]
+}

package/src/cli.ts

@@ -0,0 +1,113 @@
+import { constants as fsConstants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { CliInput } from './types/cli';
+
+const DEFAULT_CONFIG_PATH = '.hana-linter.json';
+
+/**
+ * Parse command-line arguments.
+ *
+ * Supported:
+ * - --config <path>
+ * - remaining arguments are treated as file paths
+ *
+ * @returns Parsed CLI input.
+ */
+export function parseCliInput(): CliInput {
+    const args = process.argv.slice(2);
+
+    if (args[0] === 'init') {
+        const initArgs = args.slice(1);
+        let force = false;
+
+        for (const value of initArgs) {
+            if (value === '--force') {
+                force = true;
+                continue;
+            }
+
+            throw new Error(`Unknown argument for init: "${value}". Supported: --force`);
+        }
+
+        return {
+            command: 'init',
+            files: [],
+            configPath: DEFAULT_CONFIG_PATH,
+            force
+        };
+    }
+
+    const files: string[] = [];
+    let configPath = DEFAULT_CONFIG_PATH;
+
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+
+        if (value === '--config') {
+            const nextValue = args[index + 1];
+            if (!nextValue || nextValue.startsWith('--')) {
+                throw new Error('Missing value for --config');
+            }
+            configPath = nextValue;
+            index += 1;
+            continue;
+        }
+
+        files.push(value as string);
+    }
+
+    return {
+        command: 'lint',
+        files: files.filter((value) => value.trim().length > 0),
+        configPath,
+        force: false
+    };
+}
+
+/**
+ * Create .hana-linter.json in current working directory from bundled template.
+ *
+ * @param force - Overwrite existing file when true.
+ */
+export async function runInit(force: boolean): Promise<void> {
+    const templatePath = await resolveTemplateConfigPath();
+    const targetPath = path.resolve(process.cwd(), DEFAULT_CONFIG_PATH);
+
+    try {
+        await fs.copyFile(templatePath, targetPath, force ? 0 : fsConstants.COPYFILE_EXCL);
+        console.info(`✅ Created ${DEFAULT_CONFIG_PATH} at ${targetPath}`);
+    } catch (error: unknown) {
+        if (!force && typeof error === 'object' && error !== null && 'code' in error && (error as NodeJS.ErrnoException).code === 'EEXIST') {
+            throw new Error(`${DEFAULT_CONFIG_PATH} already exists at ${targetPath}. Use "hana-linter init --force" to overwrite.`);
+        }
+
+        throw error;
+    }
+}
+
+/**
+ * Resolve the packaged default config template path.
+ *
+ * Supports both:
+ * - built artifact layout (dist/assets)
+ * - source layout (src/assets) during local development
+ *
+ * @returns Existing template path.
+ */
+async function resolveTemplateConfigPath(): Promise<string> {
+    const candidatePaths = [
+        path.resolve(__dirname, 'assets', DEFAULT_CONFIG_PATH),
+        path.resolve(__dirname, '..', 'src', 'assets', DEFAULT_CONFIG_PATH)
+    ];
+
+    for (const candidatePath of candidatePaths) {
+        try {
+            await fs.access(candidatePath);
+            return candidatePath;
+        } catch {
+            // Try next candidate.
+        }
+    }
+
+    throw new Error('Could not locate bundled default configuration template. Expected one of: ' + candidatePaths.join(', '));
+}

package/src/config.ts

@@ -0,0 +1,305 @@
+import { promises as fs } from 'node:fs';
+import { LintConfig } from './types/config';
+import {
+    ContentRuleSet,
+    ContentTarget,
+    ExtensionRuleSet,
+    JsonContentRuleSet,
+    JsonLintConfig,
+    JsonExtensionRuleSet,
+    JsonRuleDefinition,
+    RuleDefinition,
+    RuleGroup
+} from './types/rules';
+
+/**
+ * Read and parse JSON config file.
+ *
+ * @param configPath - Path to JSON configuration.
+ * @returns Parsed JSON config object.
+ */
+export async function readJsonConfig(configPath: string): Promise<JsonLintConfig> {
+    const rawContent = await fs.readFile(configPath, { encoding: 'utf-8' });
+    const parsed: unknown = JSON.parse(rawContent);
+
+    if (!isJsonLintConfig(parsed)) {
+        throw new Error(`Invalid configuration schema in "${configPath}". Please verify required fields.`);
+    }
+
+    return parsed;
+}
+
+/**
+ * Convert JSON config into runtime compiled config.
+ *
+ * @param jsonConfig - Parsed JSON config.
+ * @returns Runtime lint config with compiled regex.
+ */
+export function toLintConfig(jsonConfig: JsonLintConfig): LintConfig {
+    const extensionFolderNames = new Map<string, string>();
+
+    const extensionRuleSets: ExtensionRuleSet[] = jsonConfig.extensionRuleSets.map((jsonRuleSet) => {
+        const folderName = jsonRuleSet.folderName?.trim();
+
+        if (folderName !== undefined && folderName.length === 0) {
+            throw new Error(`Invalid folderName for extension "${jsonRuleSet.extension}": value must not be empty.`);
+        }
+
+        if (folderName !== undefined && (folderName.includes('/') || folderName.includes('\\'))) {
+            throw new Error(`Invalid folderName for extension "${jsonRuleSet.extension}": use only a folder name, not a path.`);
+        }
+
+        if (folderName !== undefined) {
+            const existingFolderName = extensionFolderNames.get(jsonRuleSet.extension);
+            if (existingFolderName && existingFolderName !== folderName) {
+                throw new Error(
+                    `Conflicting folderName values configured for extension "${jsonRuleSet.extension}": "${existingFolderName}" and "${folderName}".`
+                );
+            }
+            extensionFolderNames.set(jsonRuleSet.extension, folderName);
+        }
+
+        const compiledGroups = compileRuleGroup(jsonRuleSet.groups, `extension "${jsonRuleSet.extension}"`);
+
+        const allRules = compiledGroups.all ?? [];
+        const anyRules = compiledGroups.any ?? [];
+
+        const hasAllRules = allRules.length > 0;
+        const hasAnyRules = anyRules.length > 0;
+
+        if (!hasAllRules && !hasAnyRules) {
+            throw new Error(
+                `Invalid rule configuration for extension "${jsonRuleSet.extension}": at least one rule is required in "groups.all" or "groups.any".`
+            );
+        }
+
+        return {
+            extension: jsonRuleSet.extension,
+            folderName,
+            groups: compiledGroups
+        };
+    });
+
+    const contentRuleSets: ContentRuleSet[] = (jsonConfig.contentRuleSets ?? []).map((jsonRuleSet) => {
+        const compiledGroups = compileRuleGroup(jsonRuleSet.groups, `content target "${jsonRuleSet.target}" extension "${jsonRuleSet.extension}"`);
+
+        const hasAllRules = (compiledGroups.all ?? []).length > 0;
+        const hasAnyRules = (compiledGroups.any ?? []).length > 0;
+
+        if (!hasAllRules && !hasAnyRules) {
+            throw new Error(
+                `Invalid content rule configuration for target "${jsonRuleSet.target}" extension "${jsonRuleSet.extension}": at least one rule is required in "groups.all" or "groups.any".`
+            );
+        }
+
+        return {
+            extension: jsonRuleSet.extension,
+            target: jsonRuleSet.target,
+            groups: compiledGroups
+        };
+    });
+
+    return {
+        rootDir: jsonConfig.rootDir,
+        ignoredDirectories: jsonConfig.ignoredDirectories,
+        extensionRuleSets,
+        contentRuleSets
+    };
+}
+
+/**
+ * Basic runtime schema guard for JSON config.
+ *
+ * @param value - Unknown parsed JSON value.
+ * @returns True when value matches expected shape.
+ */
+function isJsonLintConfig(value: unknown): value is JsonLintConfig {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+
+    const candidate = value as Partial<JsonLintConfig>;
+
+    if (typeof candidate.rootDir !== 'string') {
+        return false;
+    }
+
+    if (!Array.isArray(candidate.ignoredDirectories)) {
+        return false;
+    }
+
+    if (!Array.isArray(candidate.extensionRuleSets)) {
+        return false;
+    }
+
+    if (candidate.contentRuleSets !== undefined && !Array.isArray(candidate.contentRuleSets)) {
+        return false;
+    }
+
+    const extensionRuleSetsValid = candidate.extensionRuleSets.every((ruleSet) => {
+        if (!ruleSet || typeof ruleSet !== 'object') {
+            return false;
+        }
+
+        const typedRuleSet = ruleSet as Partial<JsonExtensionRuleSet>;
+        if (typeof typedRuleSet.extension !== 'string') {
+            return false;
+        }
+
+        if (typedRuleSet.folderName !== undefined && typeof typedRuleSet.folderName !== 'string') {
+            return false;
+        }
+
+        if (!typedRuleSet.groups || typeof typedRuleSet.groups !== 'object') {
+            return false;
+        }
+
+        const groups = typedRuleSet.groups;
+        const allRulesValid =
+            groups.all === undefined ||
+            (Array.isArray(groups.all) &&
+                (groups.all as JsonRuleDefinition[]).every(
+                    (rule) =>
+                        !!rule &&
+                        typeof rule.description === 'string' &&
+                        typeof rule.pattern === 'string' &&
+                        (rule.flags === undefined || typeof rule.flags === 'string')
+                ));
+
+        const anyRulesValid =
+            groups.any === undefined ||
+            (Array.isArray(groups.any) &&
+                (groups.any as JsonRuleDefinition[]).every(
+                    (rule) =>
+                        !!rule &&
+                        typeof rule.description === 'string' &&
+                        typeof rule.pattern === 'string' &&
+                        (rule.flags === undefined || typeof rule.flags === 'string')
+                ));
+
+        return allRulesValid && anyRulesValid;
+    });
+
+    if (!extensionRuleSetsValid) {
+        return false;
+    }
+
+    return (candidate.contentRuleSets ?? []).every((ruleSet) => {
+        if (!ruleSet || typeof ruleSet !== 'object') {
+            return false;
+        }
+
+        const typedRuleSet = ruleSet as Partial<JsonContentRuleSet>;
+        if (typeof typedRuleSet.extension !== 'string') {
+            return false;
+        }
+
+        if (!isContentTarget(typedRuleSet.target)) {
+            return false;
+        }
+
+        if (!typedRuleSet.groups || typeof typedRuleSet.groups !== 'object') {
+            return false;
+        }
+
+        const groups = typedRuleSet.groups;
+        const allRulesValid =
+            groups.all === undefined ||
+            (Array.isArray(groups.all) &&
+                (groups.all as JsonRuleDefinition[]).every(
+                    (rule) =>
+                        !!rule &&
+                        typeof rule.description === 'string' &&
+                        typeof rule.pattern === 'string' &&
+                        (rule.flags === undefined || typeof rule.flags === 'string')
+                ));
+
+        const anyRulesValid =
+            groups.any === undefined ||
+            (Array.isArray(groups.any) &&
+                (groups.any as JsonRuleDefinition[]).every(
+                    (rule) =>
+                        !!rule &&
+                        typeof rule.description === 'string' &&
+                        typeof rule.pattern === 'string' &&
+                        (rule.flags === undefined || typeof rule.flags === 'string')
+                ));
+
+        return allRulesValid && anyRulesValid;
+    });
+}
+
+function isContentTarget(target: unknown): target is ContentTarget {
+    return target === 'field' || target === 'inputParameter' || target === 'outputParameter';
+}
+
+function compileRuleGroup(groups: { all?: readonly JsonRuleDefinition[]; any?: readonly JsonRuleDefinition[] }, contextRoot: string): RuleGroup {
+    const allRules: RuleDefinition[] = (groups.all ?? []).map((rule, index) => {
+        const flags = rule.flags ?? '';
+        const context = `${contextRoot} group "all" rule #${index + 1}`;
+        return {
+            description: rule.description,
+            source: rule.pattern,
+            flags,
+            pattern: compileRegex(rule.pattern, flags, context)
+        };
+    });
+
+    const anyRules: RuleDefinition[] = (groups.any ?? []).map((rule, index) => {
+        const flags = rule.flags ?? '';
+        const context = `${contextRoot} group "any" rule #${index + 1}`;
+        return {
+            description: rule.description,
+            source: rule.pattern,
+            flags,
+            pattern: compileRegex(rule.pattern, flags, context)
+        };
+    });
+
+    return {
+        all: allRules.length > 0 ? allRules : undefined,
+        any: anyRules.length > 0 ? anyRules : undefined
+    };
+}
+
+/**
+ * Validate regex flags for duplicate/unsupported values.
+ *
+ * @param flags - Raw regex flags string.
+ * @param context - Rule context for clear error messages.
+ */
+function validateRegexFlags(flags: string, context: string): void {
+    const allowedFlags = new Set(['d', 'g', 'i', 'm', 's', 'u', 'v', 'y']);
+    const seen = new Set<string>();
+
+    for (const flag of flags) {
+        if (!allowedFlags.has(flag)) {
+            throw new Error(`Invalid regex flag in ${context}: "${flag}"`);
+        }
+
+        if (seen.has(flag)) {
+            throw new Error(`Duplicate regex flag in ${context}: "${flag}"`);
+        }
+
+        seen.add(flag);
+    }
+}
+
+/**
+ * Compile regex source and flags into RegExp with helpful error context.
+ *
+ * @param source - Regex source from config.
+ * @param flags - Regex flags from config.
+ * @param context - Rule context for error reporting.
+ * @returns Compiled RegExp.
+ */
+function compileRegex(source: string, flags: string, context: string): RegExp {
+    validateRegexFlags(flags, context);
+
+    try {
+        return new RegExp(source, flags);
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Unknown regex error';
+        throw new Error(`Invalid regex in ${context}: pattern="${source}" flags="${flags}". ${message}`, { cause: error });
+    }
+}