hana-linter 1.2.0 → 1.4.0

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+### 1.4.0
+
+- Bumped package version metadata to `1.4.0` (`package.json` and `package-lock.json`)
+
+---
+
+### 1.3.0
+
+- Added Chevrotain-based `.hdbtrigger` parser; content-linting of trigger names is now fully supported
+- The `.hdbtrigger` parser extracts the trigger name from `CREATE TRIGGER … ON …` DDL, handling all HANA timing/event variants (`BEFORE`, `AFTER`, `INSTEAD OF`), `INSERT`, `UPDATE [OF …]`, and `DELETE` events, `REFERENCING` clauses, `FOR EACH ROW|STATEMENT`, `WHEN (…)` clauses, and nested `BEGIN … END` bodies — all without false-positive extractions from body content
+- Trigger names may be schema-qualified (`schema.triggerName`); the parser correctly extracts only the unqualified name
+- Added `triggerName` as a valid `target` in content rule sets (configuration key: `triggerName`)
+- Default config (`.hana-linter.json`) now includes a `triggerName` rule set enforcing uppercase snake case for `.hdbtrigger` files
+
+---
+
 ### 1.1.0
 
 - Console output is now grouped by file, then by failed rule, reducing noise when multiple violations exist in the same file

package/README.md

@@ -40,7 +40,7 @@ Rule groups per extension:
 
 You can define `extension: "*"` as a shared rule set. Its rules are applied to every file extension and are merged with any extension-specific rule set.
 
-Content-based linting uses purpose-built parsers to reliably extract identifiers from HANA artifact files. SQL DDL artifact types (`.hdbtable`, `.hdbview`, `.hdbprocedure`, `.hdbfunction`, `.hdbtabletype`, `.hdbrole`) use [Chevrotain](https://chevrotain.io)-powered lexers and CST parsers that correctly handle block and line comments, multi-line definitions, quoted identifiers, and HANA-specific DDL constructs. The XML-based `.hdbcalculationview` format uses [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser) to navigate the logical model tree — without the false positives and false negatives that ad-hoc regex scanning produces.
+Content-based linting uses purpose-built parsers to reliably extract identifiers from HANA artifact files. SQL DDL artifact types (`.hdbtable`, `.hdbview`, `.hdbprocedure`, `.hdbfunction`, `.hdbtabletype`, `.hdbrole`, `.hdbsequence`, `.hdbindex`, `.hdbtrigger`) use [Chevrotain](https://chevrotain.io)-powered lexers and CST parsers that correctly handle block and line comments, multi-line definitions, quoted identifiers, and HANA-specific DDL constructs. The JSON-like `.hdbschedulerjob` format is also parsed with Chevrotain, tolerating C-style comments (`//` and `/* … */`) and trailing commas that standard `JSON.parse()` rejects. The XML-based `.hdbcalculationview` format uses [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser) to navigate the logical model tree — without the false positives and false negatives that ad-hoc regex scanning produces.
 
 ## Parser Status
 
@@ -56,14 +56,14 @@ Content-based linting uses purpose-built parsers to reliably extract identifiers
 | `.hdbrole`                | Chevrotain lexer + CST | ✅ Migrated            |
 | `.hdbcalculationview`     | fast-xml-parser (XML)  | ✅ Migrated            |
 | `.hdbanalyticalprivilege` | —                      | ❌ Not yet implemented |
-| `.hdbsequence`            | —                      | ❌ Not yet implemented |
+| `.hdbsequence`            | Chevrotain lexer + CST | ✅ Migrated            |
 | `.hdbconstraint`          | —                      | ❌ Not yet implemented |
-| `.hdbschedulerjob`        | —                      | ❌ Not yet implemented |
-| `.hdbindex`               | —                      | ❌ Not yet implemented |
-| `.hdbtrigger`             | —                      | ❌ Not yet implemented |
+| `.hdbschedulerjob`        | Chevrotain lexer + CST | ✅ Migrated            |
+| `.hdbindex`               | Chevrotain lexer + CST | ✅ Migrated            |
+| `.hdbtrigger`             | Chevrotain lexer + CST | ✅ Migrated            |
 
-- The regex **file name** validations for all of the above listed extensions **are implemented**. The **content extractor** hasn't been implemented everywhere yet.
-- **Not implemented**: `contentRuleSets` targeting these extensions will silently return no results — no identifiers are extracted and no content issues are raised.
+- The regex **file name** validations for all of the above listed extensions **are implemented**.
+- **Not implemented**: `contentRuleSets` targeting `.hdbanalyticalprivilege` or `.hdbconstraint` will silently return no results — no identifiers are extracted and no content issues are raised.
 
 ## Install
 
@@ -172,7 +172,7 @@ When `folderName` is omitted, no folder-location enforcement is applied.
 Each `contentRuleSets` item contains:
 
 - `extension` (string): target extension, for example `.hdbtable`; use `*` to target all extensions
-- `target` (string): extracted identifier type to validate; one of `field`, `inputParameter`, `outputParameter`
+- `target` (string): extracted identifier type to validate; one of `field`, `inputParameter`, `outputParameter`, `roleName`, `grantedRoleName`, `sequenceName`, `jobAction`, `indexName`, `triggerName`
 - `groups.all` (optional array): all rules must match
 - `groups.any` (optional array): at least one rule must match
 
@@ -190,6 +190,10 @@ Supported extractors in this version:
 | `grantedRoleName` | `.hdbrole`            | Each role listed in `extends roles { ... }`                                   |
 | `field`           | `.hdbcalculationview` | Output attributes, calculated attributes, base/calculated/restricted measures |
 | `inputParameter`  | `.hdbcalculationview` | Input parameters (`variable[@parameter="true"]`)                              |
+| `sequenceName`    | `.hdbsequence`        | The sequence name declared in the file                                        |
+| `jobAction`       | `.hdbschedulerjob`    | The procedure/function reference in the `action` field                        |
+| `indexName`       | `.hdbindex`           | The index name declared in the file                                           |
+| `triggerName`     | `.hdbtrigger`         | The trigger name declared in the file                                         |
 
 ### Default Config Example
 
@@ -350,6 +354,54 @@ Supported extractors in this version:
                     }
                 ]
             }
+        },
+        {
+            "extension": ".hdbsequence",
+            "target": "sequenceName",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Sequence names in uppercase snake case",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbschedulerjob",
+            "target": "jobAction",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Job action must reference a package-qualified procedure (contains ::)",
+                        "pattern": "::"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbindex",
+            "target": "indexName",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Index names in uppercase snake case",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbtrigger",
+            "target": "triggerName",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Trigger names in uppercase snake case",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    }
+                ]
+            }
         }
     ]
 }

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

@@ -291,6 +291,54 @@
                     }
                 ]
             }
+        },
+        {
+            "extension": ".hdbsequence",
+            "target": "sequenceName",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Sequence names in uppercase snake case",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbschedulerjob",
+            "target": "jobAction",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Job action must reference a package-qualified procedure (contains ::)",
+                        "pattern": "::"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbindex",
+            "target": "indexName",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Index names in uppercase snake case",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    }
+                ]
+            }
+        },
+        {
+            "extension": ".hdbtrigger",
+            "target": "triggerName",
+            "groups": {
+                "all": [
+                    {
+                        "description": "Trigger names in uppercase snake case",
+                        "pattern": "^[A-Z0-9]+(?:_[A-Z0-9]+)*$"
+                    }
+                ]
+            }
         }
     ]
 }

package/dist/config.js

@@ -160,7 +160,15 @@ function isJsonLintConfig(value) {
     });
 }
 function isContentTarget(target) {
-    return target === 'field' || target === 'inputParameter' || target === 'outputParameter';
+    return (target === 'field' ||
+        target === 'inputParameter' ||
+        target === 'outputParameter' ||
+        target === 'roleName' ||
+        target === 'grantedRoleName' ||
+        target === 'sequenceName' ||
+        target === 'jobAction' ||
+        target === 'indexName' ||
+        target === 'triggerName');
 }
 function compileRuleGroup(groups, contextRoot) {
     const allRules = (groups.all ?? []).map((rule, index) => {

package/dist/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config.test.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const config_1 = require("./config");
+const supportedTargets = [
+    'field',
+    'inputParameter',
+    'outputParameter',
+    'roleName',
+    'grantedRoleName',
+    'sequenceName',
+    'jobAction',
+    'indexName',
+    'triggerName'
+];
+(0, vitest_1.describe)('readJsonConfig', () => {
+    (0, vitest_1.it)('accepts the bundled default configuration', async () => {
+        const configPath = node_path_1.default.resolve(process.cwd(), 'src/assets/.hana-linter.json');
+        await (0, vitest_1.expect)((0, config_1.readJsonConfig)(configPath)).resolves.toBeDefined();
+    });
+    vitest_1.it.each(supportedTargets)('accepts content target "%s"', async (target) => {
+        const tempDir = await node_fs_1.promises.mkdtemp(node_path_1.default.join((0, node_os_1.tmpdir)(), 'hana-linter-config-'));
+        const configPath = node_path_1.default.join(tempDir, '.hana-linter.json');
+        const config = {
+            rootDir: 'db',
+            ignoredDirectories: ['node_modules'],
+            extensionRuleSets: [
+                {
+                    extension: '*',
+                    groups: {
+                        all: [{ description: 'Any name', pattern: '.+' }]
+                    }
+                }
+            ],
+            contentRuleSets: [
+                {
+                    extension: '.hdbtable',
+                    target,
+                    groups: {
+                        all: [{ description: 'Any name', pattern: '.+' }]
+                    }
+                }
+            ]
+        };
+        await node_fs_1.promises.writeFile(configPath, JSON.stringify(config), 'utf-8');
+        await (0, vitest_1.expect)((0, config_1.readJsonConfig)(configPath)).resolves.toEqual(config);
+        await node_fs_1.promises.rm(tempDir, { recursive: true, force: true });
+    });
+});

package/dist/content-lint.js

@@ -13,6 +13,10 @@ const index_4 = require("./parsers/hdbfunction/index");
 const index_5 = require("./parsers/hdbtabletype/index");
 const index_6 = require("./parsers/hdbrole/index");
 const index_7 = require("./parsers/hdbcalculationview/index");
+const index_8 = require("./parsers/hdbsequence/index");
+const index_9 = require("./parsers/hdbschedulerjob/index");
+const index_10 = require("./parsers/hdbindex/index");
+const index_11 = require("./parsers/hdbtrigger/index");
 /**
  * Run content-based naming lint for a file.
  *
@@ -70,6 +74,18 @@ function extractSubjects(extension, fileContent) {
     if (extension === '.hdbcalculationview') {
         return (0, index_7.extractCalculationViewOutputs)(fileContent);
     }
+    if (extension === '.hdbsequence') {
+        return (0, index_8.extractSequenceName)(fileContent);
+    }
+    if (extension === '.hdbschedulerjob') {
+        return (0, index_9.extractSchedulerJobAction)(fileContent);
+    }
+    if (extension === '.hdbindex') {
+        return (0, index_10.extractIndexName)(fileContent);
+    }
+    if (extension === '.hdbtrigger') {
+        return (0, index_11.extractTriggerName)(fileContent);
+    }
     return [];
 }
 function evaluateAllRules(filePath, extension, subject, rules) {

package/dist/parsers/hdbindex/__tests__/extractIndexName.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/parsers/hdbindex/__tests__/extractIndexName.test.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../index");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function names(ddl) {
+    return (0, index_1.extractIndexName)(ddl)
+        .filter((s) => s.type === 'indexName')
+        .map((s) => s.name);
+}
+// ---------------------------------------------------------------------------
+// AC-1  Bare INDEX syntax — unquoted name
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-1: bare INDEX syntax, unquoted name', () => {
+    (0, vitest_1.it)('extracts the index name as an indexName subject', () => {
+        const ddl = `INDEX MY_INDEX ON MY_TABLE (COL1, COL2);`;
+        (0, vitest_1.expect)((0, index_1.extractIndexName)(ddl)).toEqual([{ type: 'indexName', name: 'MY_INDEX', lineNumber: 1 }]);
+    });
+    (0, vitest_1.it)('handles a file without a trailing semicolon', () => {
+        const ddl = `INDEX MY_INDEX ON MY_TABLE (COL1)`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+    (0, vitest_1.it)('all results carry type "indexName"', () => {
+        const ddl = `INDEX MY_IDX ON T (C1)`;
+        (0, vitest_1.expect)((0, index_1.extractIndexName)(ddl).every((r) => r.type === 'indexName')).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-2  Full CREATE INDEX syntax — unquoted name
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-2: CREATE INDEX syntax, unquoted name', () => {
+    (0, vitest_1.it)('extracts the index name from a full CREATE INDEX statement', () => {
+        const ddl = `CREATE INDEX MY_INDEX ON MY_TABLE (COL1 ASC, COL2 DESC);`;
+        (0, vitest_1.expect)((0, index_1.extractIndexName)(ddl)).toEqual([{ type: 'indexName', name: 'MY_INDEX', lineNumber: 1 }]);
+    });
+    (0, vitest_1.it)('handles multi-line formatting', () => {
+        const ddl = `CREATE INDEX\n  MY_INDEX\nON MY_TABLE\n  (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-3  CREATE UNIQUE INDEX syntax
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-3: CREATE UNIQUE INDEX syntax', () => {
+    (0, vitest_1.it)('extracts the index name from a CREATE UNIQUE INDEX statement', () => {
+        const ddl = `CREATE UNIQUE INDEX MY_UNIQUE_INDEX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)((0, index_1.extractIndexName)(ddl)).toEqual([{ type: 'indexName', name: 'MY_UNIQUE_INDEX', lineNumber: 1 }]);
+    });
+    (0, vitest_1.it)('handles UNIQUE without CREATE prefix', () => {
+        const ddl = `UNIQUE INDEX MY_UNIQUE_INDEX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_UNIQUE_INDEX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-4  Index type keyword variants consumed without error
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-4: index type keyword variants', () => {
+    const cases = [
+        ['BTREE', `CREATE BTREE INDEX MY_IDX ON MY_TABLE (COL1);`],
+        ['CPBTREE', `CREATE CPBTREE INDEX MY_IDX ON MY_TABLE (COL1);`],
+        ['INVERTED HASH', `CREATE INVERTED HASH INDEX MY_IDX ON MY_TABLE (COL1);`],
+        ['INVERTED VALUE', `CREATE INVERTED VALUE INDEX MY_IDX ON MY_TABLE (COL1);`],
+        ['INVERTED INDIVIDUAL', `CREATE INVERTED INDIVIDUAL INDEX MY_IDX ON MY_TABLE (COL1);`]
+    ];
+    for (const [label, ddl] of cases) {
+        (0, vitest_1.it)(`extracts the index name when type is ${label}`, () => {
+            (0, vitest_1.expect)((0, index_1.extractIndexName)(ddl)).toEqual([{ type: 'indexName', name: 'MY_IDX', lineNumber: 1 }]);
+        });
+    }
+    (0, vitest_1.it)('accepts UNIQUE combined with INVERTED HASH', () => {
+        const ddl = `CREATE UNIQUE INVERTED HASH INDEX MY_IDX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_IDX']);
+    });
+    (0, vitest_1.it)('accepts UNIQUE combined with INVERTED VALUE', () => {
+        const ddl = `CREATE UNIQUE INVERTED VALUE INDEX MY_IDX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_IDX']);
+    });
+    (0, vitest_1.it)('accepts UNIQUE combined with INVERTED INDIVIDUAL', () => {
+        const ddl = `CREATE UNIQUE INVERTED INDIVIDUAL INDEX MY_IDX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_IDX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-5  Quoted identifier normalisation
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-5: quoted identifier normalisation', () => {
+    (0, vitest_1.it)('strips double-quotes from the index name', () => {
+        const ddl = `CREATE INDEX "MY_INDEX" ON "MY_TABLE" ("COL1", "COL2");`;
+        (0, vitest_1.expect)((0, index_1.extractIndexName)(ddl)).toEqual([{ type: 'indexName', name: 'MY_INDEX', lineNumber: 1 }]);
+    });
+    (0, vitest_1.it)('handles a mixed-quote file (quoted index name, unquoted table)', () => {
+        const ddl = `CREATE INDEX "MY_INDEX" ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+    (0, vitest_1.it)('handles a fully unquoted file', () => {
+        const ddl = `CREATE INDEX MY_INDEX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-6  Schema-qualified index name — local name extracted
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-6: schema-qualified index name', () => {
+    (0, vitest_1.it)('extracts only the local name (after the dot)', () => {
+        const ddl = `CREATE INDEX "MY_SCHEMA"."MY_INDEX" ON "MY_SCHEMA"."MY_TABLE" ("COL1");`;
+        (0, vitest_1.expect)((0, index_1.extractIndexName)(ddl)).toEqual([{ type: 'indexName', name: 'MY_INDEX', lineNumber: 1 }]);
+    });
+    (0, vitest_1.it)('does not include the schema prefix as a subject', () => {
+        const ddl = `CREATE INDEX "MY_SCHEMA"."MY_INDEX" ON "MY_TABLE" (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).not.toContain('MY_SCHEMA');
+    });
+    (0, vitest_1.it)('handles unquoted schema-qualified name', () => {
+        const ddl = `CREATE INDEX MY_SCHEMA.MY_INDEX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-7  Column identifiers not extracted
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-7: column identifiers not extracted', () => {
+    (0, vitest_1.it)('does not include column names in the result', () => {
+        const ddl = `CREATE INDEX MY_INDEX ON MY_TABLE (FIRST_COLUMN ASC, SECOND_COLUMN DESC);`;
+        const result = (0, index_1.extractIndexName)(ddl);
+        (0, vitest_1.expect)(result).toEqual([{ type: 'indexName', name: 'MY_INDEX', lineNumber: 1 }]);
+        (0, vitest_1.expect)(names(ddl)).not.toContain('FIRST_COLUMN');
+        (0, vitest_1.expect)(names(ddl)).not.toContain('SECOND_COLUMN');
+    });
+    (0, vitest_1.it)('does not include the table name in the result', () => {
+        const ddl = `CREATE INDEX MY_INDEX ON MY_TABLE (COL1);`;
+        (0, vitest_1.expect)(names(ddl)).not.toContain('MY_TABLE');
+    });
+    (0, vitest_1.it)('handles a multi-column list without extracting any column name', () => {
+        const ddl = `INDEX MY_INDEX ON T (A, B, C, D);`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-8  Block comment exclusion
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-8: block comment exclusion', () => {
+    (0, vitest_1.it)('does not extract an index name wrapped in a block comment', () => {
+        const ddl = `
+            /* CREATE INDEX OLD_INDEX ON MY_TABLE (COL1); */
+            CREATE INDEX MY_INDEX ON MY_TABLE (COL1);
+        `;
+        (0, vitest_1.expect)(names(ddl)).not.toContain('OLD_INDEX');
+        (0, vitest_1.expect)(names(ddl)).toContain('MY_INDEX');
+    });
+    (0, vitest_1.it)('handles a block comment spanning multiple lines before the real statement', () => {
+        const ddl = `
+            /*
+              CREATE INDEX COMMENTED_INDEX ON MY_TABLE (COL1);
+            */
+            INDEX MY_INDEX ON MY_TABLE (COL1);
+        `;
+        (0, vitest_1.expect)(names(ddl)).not.toContain('COMMENTED_INDEX');
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-9  Line comment exclusion
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-9: line comment exclusion', () => {
+    (0, vitest_1.it)('does not extract an index name on a -- comment line', () => {
+        const ddl = `
+            -- CREATE INDEX OLD_INDEX ON MY_TABLE (COL1);
+            CREATE INDEX MY_INDEX ON MY_TABLE (COL1);
+        `;
+        (0, vitest_1.expect)(names(ddl)).not.toContain('OLD_INDEX');
+        (0, vitest_1.expect)(names(ddl)).toContain('MY_INDEX');
+    });
+    (0, vitest_1.it)('ignores a -- comment after the statement', () => {
+        const ddl = `CREATE INDEX MY_INDEX ON MY_TABLE (COL1); -- production index`;
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-10  Optional semicolon
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-10: optional semicolon', () => {
+    (0, vitest_1.it)('produces the same result with and without a trailing semicolon', () => {
+        const withSemicolon = `CREATE INDEX MY_INDEX ON MY_TABLE (COL1);`;
+        const withoutSemicolon = `CREATE INDEX MY_INDEX ON MY_TABLE (COL1)`;
+        (0, vitest_1.expect)(names(withSemicolon)).toEqual(names(withoutSemicolon));
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-11  Graceful error on unparseable file
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-11: graceful error handling', () => {
+    (0, vitest_1.it)('does not throw on completely invalid input', () => {
+        (0, vitest_1.expect)(() => (0, index_1.extractIndexName)('THIS IS NOT VALID DDL !!!')).not.toThrow();
+    });
+    (0, vitest_1.it)('does not throw on an empty string', () => {
+        (0, vitest_1.expect)(() => (0, index_1.extractIndexName)('')).not.toThrow();
+        (0, vitest_1.expect)((0, index_1.extractIndexName)('')).toEqual([]);
+    });
+    (0, vitest_1.it)('does not throw when INDEX keyword is missing', () => {
+        (0, vitest_1.expect)(() => (0, index_1.extractIndexName)('CREATE MY_INDEX ON MY_TABLE (COL1)')).not.toThrow();
+    });
+    (0, vitest_1.it)('handles CRLF line endings', () => {
+        const ddl = 'CREATE INDEX MY_INDEX ON MY_TABLE (COL1);\r\n';
+        (0, vitest_1.expect)(names(ddl)).toEqual(['MY_INDEX']);
+    });
+});

package/dist/parsers/hdbindex/index.d.ts

@@ -0,0 +1,25 @@
+import type { ExtractedSubject } from '../../types/issues';
+/**
+ * Extract the index name from the content of an `.hdbindex` DDL file.
+ *
+ * Uses a Chevrotain lexer and CstParser to correctly handle all SAP HANA
+ * index DDL variants:
+ *   - bare `INDEX <name> ON <table> (<columns>)`
+ *   - `CREATE INDEX <name> ON <table> (<columns>)`
+ *   - `CREATE UNIQUE INDEX <name> ON <table> (<columns>)`
+ *   - `CREATE [UNIQUE] BTREE|CPBTREE|INVERTED HASH|INVERTED VALUE|INVERTED INDIVIDUAL INDEX ...`
+ *
+ * The parser handles block/line comments, quoted and unquoted index names,
+ * schema-qualified index names (schema prefix excluded from result),
+ * and optional trailing semicolons.
+ *
+ * Column names and sort-order keywords (ASC/DESC) inside the column list
+ * are consumed structurally and never extracted.
+ *
+ * Gracefully returns a partial or empty result on invalid input — does
+ * not throw.
+ *
+ * @param fileContent - Raw UTF-8 file content (LF or CRLF).
+ * @returns Array containing at most one ExtractedSubject with type 'indexName'.
+ */
+export declare function extractIndexName(fileContent: string): ExtractedSubject[];

package/dist/parsers/hdbindex/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractIndexName = extractIndexName;
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const visitor_1 = require("./visitor");
+/**
+ * Extract the index name from the content of an `.hdbindex` DDL file.
+ *
+ * Uses a Chevrotain lexer and CstParser to correctly handle all SAP HANA
+ * index DDL variants:
+ *   - bare `INDEX <name> ON <table> (<columns>)`
+ *   - `CREATE INDEX <name> ON <table> (<columns>)`
+ *   - `CREATE UNIQUE INDEX <name> ON <table> (<columns>)`
+ *   - `CREATE [UNIQUE] BTREE|CPBTREE|INVERTED HASH|INVERTED VALUE|INVERTED INDIVIDUAL INDEX ...`
+ *
+ * The parser handles block/line comments, quoted and unquoted index names,
+ * schema-qualified index names (schema prefix excluded from result),
+ * and optional trailing semicolons.
+ *
+ * Column names and sort-order keywords (ASC/DESC) inside the column list
+ * are consumed structurally and never extracted.
+ *
+ * Gracefully returns a partial or empty result on invalid input — does
+ * not throw.
+ *
+ * @param fileContent - Raw UTF-8 file content (LF or CRLF).
+ * @returns Array containing at most one ExtractedSubject with type 'indexName'.
+ */
+function extractIndexName(fileContent) {
+    const lexResult = lexer_1.HdbIndexLexer.tokenize(fileContent);
+    // Feed the token stream to the singleton parser.
+    parser_1.hdbIndexParser.input = lexResult.tokens;
+    const cst = parser_1.hdbIndexParser.indexStatement();
+    // Lex/parse errors are intentionally not re-thrown — the CST visitor
+    // will extract whatever could be parsed from the partial tree.
+    // Guard against a completely unrecoverable parse (cst may be undefined).
+    if (!cst) {
+        return [];
+    }
+    const visitor = new visitor_1.HdbIndexVisitor();
+    visitor.visit(cst);
+    return visitor.subjects;
+}

package/dist/parsers/hdbindex/lexer.d.ts

@@ -0,0 +1,29 @@
+import { Lexer, type TokenType } from 'chevrotain';
+export declare const BlockComment: TokenType;
+export declare const LineComment: TokenType;
+export declare const WhiteSpace: TokenType;
+export declare const Identifier: TokenType;
+export declare const QuotedIdentifier: TokenType;
+export declare const CreateKw: TokenType;
+export declare const UniqueKw: TokenType;
+export declare const IndexKw: TokenType;
+export declare const OnKw: TokenType;
+export declare const AscKw: TokenType;
+export declare const DescKw: TokenType;
+export declare const BtreeKw: TokenType;
+export declare const CpbtreeKw: TokenType;
+export declare const InvertedKw: TokenType;
+export declare const HashKw: TokenType;
+export declare const ValueKw: TokenType;
+export declare const IndividualKw: TokenType;
+export declare const LParen: TokenType;
+export declare const RParen: TokenType;
+export declare const Comma: TokenType;
+export declare const Semicolon: TokenType;
+export declare const Dot: TokenType;
+export declare const allTokens: TokenType[];
+/**
+ * Singleton Chevrotain Lexer for `.hdbindex` DDL files.
+ * Instantiated once at module load time per Chevrotain best practices.
+ */
+export declare const HdbIndexLexer: Lexer;