hana-linter 1.0.1 → 1.0.2

package/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+### 1.0.2
+
+- Added Chevrotain-based `.hdbfunction` parser; content-linting of function input parameters is now fully reliable
+- The `.hdbfunction` parser isolates the parameter list from the `RETURNS` clause and the function body (`AS BEGIN … END`), eliminating false positives caused by `IN` keywords inside SQL body statements and column names in `RETURNS TABLE (...)` definitions
+- HANA functions accept only `IN` parameters; the new parser correctly produces only `inputParameter` subjects and never emits `outputParameter` entries for `.hdbfunction` files
+- Removed the shared ad-hoc regex extractor (`extractProcedureFunctionParameters`) that was previously used for both `.hdbprocedure` and `.hdbfunction` files
+
+---
+
 ### 1.0.0
 
 - Replaced ad-hoc, line-by-line regex extraction with Chevrotain-based lexer + CST parsers for `.hdbtable`, `.hdbprocedure`, and `.hdbview` files

package/README.md

@@ -46,23 +46,22 @@ Content-based linting uses [Chevrotain](https://chevrotain.io)-powered lexers an
 
 > **Work in progress.** Not all artifact types have been migrated to the Chevrotain-based parsing infrastructure yet.
 
-| Artifact extension        | Content extractor      | Status             |
-| ------------------------- | ---------------------- | ------------------ |
-| `.hdbtable`               | Chevrotain lexer + CST | ✅ Migrated        |
-| `.hdbview`                | Chevrotain lexer + CST | ✅ Migrated        |
-| `.hdbprocedure`           | Chevrotain lexer + CST | ✅ Migrated        |
-| `.hdbfunction`            | Inline regex           | ⚠️ Needs migration |
-| `.hdbtabletype`           | —                      | ❌ Not implemented |
-| `.hdbcalculationview`     | —                      | ❌ Not implemented |
-| `.hdbanalyticalprivilege` | —                      | ❌ Not implemented |
-| `.hdbrole`                | —                      | ❌ Not implemented |
-| `.hdbsequence`            | —                      | ❌ Not implemented |
-| `.hdbconstraint`          | —                      | ❌ Not implemented |
-| `.hdbschedulerjob`        | —                      | ❌ Not implemented |
-| `.hdbindex`               | —                      | ❌ Not implemented |
-| `.hdbtrigger`             | —                      | ❌ Not implemented |
-
-- **Needs migration**: uses an ad-hoc regex scan, subject to false positives from body keywords, multi-line definitions, and block comments.
+| Artifact extension        | Content extractor      | Status                 |
+| ------------------------- | ---------------------- | ---------------------- |
+| `.hdbtable`               | Chevrotain lexer + CST | ✅ Migrated            |
+| `.hdbview`                | Chevrotain lexer + CST | ✅ Migrated            |
+| `.hdbprocedure`           | Chevrotain lexer + CST | ✅ Migrated            |
+| `.hdbfunction`            | Chevrotain lexer + CST | ✅ Migrated            |
+| `.hdbtabletype`           | —                      | ❌ Not yet implemented |
+| `.hdbcalculationview`     | —                      | ❌ Not yet implemented |
+| `.hdbanalyticalprivilege` | —                      | ❌ Not yet implemented |
+| `.hdbrole`                | —                      | ❌ Not yet implemented |
+| `.hdbsequence`            | —                      | ❌ Not yet implemented |
+| `.hdbconstraint`          | —                      | ❌ Not yet implemented |
+| `.hdbschedulerjob`        | —                      | ❌ Not yet implemented |
+| `.hdbindex`               | —                      | ❌ Not yet implemented |
+| `.hdbtrigger`             | —                      | ❌ Not yet implemented |
+
 - **Not implemented**: `contentRuleSets` targeting these extensions will silently return no results — no identifiers are extracted and no content issues are raised.
 
 ## Install
@@ -178,12 +177,13 @@ Each `contentRuleSets` item contains:
 
 Supported extractors in this version:
 
-| `target`          | Supported extensions            | Extracted identifiers                          |
-| ----------------- | ------------------------------- | ---------------------------------------------- |
-| `field`           | `.hdbtable`                     | Column names                                   |
-| `field`           | `.hdbview`                      | Column aliases (explicit list or `AS` aliases) |
-| `inputParameter`  | `.hdbprocedure`, `.hdbfunction` | `IN` and `INOUT` parameters                    |
-| `outputParameter` | `.hdbprocedure`, `.hdbfunction` | `OUT` and `INOUT` parameters                   |
+| `target`          | Supported extensions | Extracted identifiers                          |
+| ----------------- | -------------------- | ---------------------------------------------- |
+| `field`           | `.hdbtable`          | Column names                                   |
+| `field`           | `.hdbview`           | Column aliases (explicit list or `AS` aliases) |
+| `inputParameter`  | `.hdbprocedure`      | `IN` and `INOUT` parameters                    |
+| `inputParameter`  | `.hdbfunction`       | `IN` parameters (functions accept `IN` only)   |
+| `outputParameter` | `.hdbprocedure`      | `OUT` and `INOUT` parameters                   |
 
 ### Default Config Example
 

package/dist/content-lint.js

@@ -9,6 +9,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const index_1 = require("./parsers/hdbtable/index");
 const index_2 = require("./parsers/hdbview/index");
 const index_3 = require("./parsers/hdbprocedure/index");
+const index_4 = require("./parsers/hdbfunction/index");
 /**
  * Run content-based naming lint for a file.
  *
@@ -55,36 +56,10 @@ function extractSubjects(extension, fileContent) {
         return (0, index_3.extractProcedureParameters)(fileContent);
     }
     if (extension === '.hdbfunction') {
-        return extractProcedureFunctionParameters(fileContent);
+        return (0, index_4.extractFunctionParameters)(fileContent);
     }
     return [];
 }
-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) {

package/dist/parsers/hdbfunction/__tests__/extractFunctionParameters.test.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../index");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function inputs(ddl) {
+    return (0, index_1.extractFunctionParameters)(ddl)
+        .filter((s) => s.type === 'inputParameter')
+        .map((s) => s.name);
+}
+// ---------------------------------------------------------------------------
+// AC-1  IN parameter extraction (scalar function)
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-1: IN parameter extraction (scalar function)', () => {
+    (0, vitest_1.it)('extracts IN parameters as inputParameter subjects', () => {
+        const ddl = `
+            FUNCTION MY_FUNC (
+                IN IV_CUSTOMER_ID NVARCHAR(10),
+                IN IV_DATE DATE
+            ) RETURNS NVARCHAR(100) AS BEGIN END
+        `;
+        (0, vitest_1.expect)((0, index_1.extractFunctionParameters)(ddl)).toEqual([
+            { type: 'inputParameter', name: 'IV_CUSTOMER_ID' },
+            { type: 'inputParameter', name: 'IV_DATE' }
+        ]);
+    });
+    (0, vitest_1.it)('does not produce outputParameter entries for any parameter', () => {
+        const ddl = `FUNCTION F (IN IV_AMOUNT DECIMAL(18,2)) RETURNS INTEGER AS BEGIN END`;
+        const outputSubjects = (0, index_1.extractFunctionParameters)(ddl).filter((s) => s.type === 'outputParameter');
+        (0, vitest_1.expect)(outputSubjects).toHaveLength(0);
+    });
+    (0, vitest_1.it)('all results carry type "inputParameter"', () => {
+        const ddl = `FUNCTION F (IN IV_A INTEGER, IN IV_B NVARCHAR(10)) RETURNS INTEGER AS BEGIN END`;
+        (0, vitest_1.expect)((0, index_1.extractFunctionParameters)(ddl).every((r) => r.type === 'inputParameter')).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-2  IN parameter extraction (table function)
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-2: IN parameter extraction (table function)', () => {
+    (0, vitest_1.it)('extracts IN params and ignores RETURNS TABLE columns', () => {
+        const ddl = `
+            FUNCTION MY_FUNC (
+                IN IV_STATUS NVARCHAR(1)
+            ) RETURNS TABLE (ID INTEGER, NAME NVARCHAR(100)) AS BEGIN END
+        `;
+        (0, vitest_1.expect)((0, index_1.extractFunctionParameters)(ddl)).toEqual([{ type: 'inputParameter', name: 'IV_STATUS' }]);
+    });
+    (0, vitest_1.it)('does not produce outputParameter entries for a table function', () => {
+        const ddl = `
+            FUNCTION F (IN IV_X INTEGER)
+            RETURNS TABLE (COL1 NVARCHAR(10))
+            AS BEGIN END
+        `;
+        const outputSubjects = (0, index_1.extractFunctionParameters)(ddl).filter((s) => s.type === 'outputParameter');
+        (0, vitest_1.expect)(outputSubjects).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-3  RETURNS TABLE columns are not extracted
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-3: RETURNS TABLE columns not extracted', () => {
+    (0, vitest_1.it)('does not extract OUT_COL or IN_COL from RETURNS TABLE definition', () => {
+        const ddl = `
+            FUNCTION F ()
+            RETURNS TABLE (OUT_COL INTEGER, IN_COL NVARCHAR(10))
+            AS BEGIN END
+        `;
+        const names = (0, index_1.extractFunctionParameters)(ddl).map((s) => s.name);
+        (0, vitest_1.expect)(names).not.toContain('OUT_COL');
+        (0, vitest_1.expect)(names).not.toContain('IN_COL');
+    });
+    (0, vitest_1.it)('does not extract column names from a multi-column RETURNS TABLE', () => {
+        const ddl = `
+            FUNCTION F (IN IV_X INTEGER)
+            RETURNS TABLE (
+                COL_A BIGINT,
+                COL_B NVARCHAR(200),
+                COL_C TIMESTAMP
+            ) AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_X']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-4  No outputParameter subjects produced
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-4: no outputParameter subjects produced', () => {
+    (0, vitest_1.it)('never emits an outputParameter entry for any parameter', () => {
+        const ddl = `
+            FUNCTION F (IN IV_A INTEGER, IN IV_B NVARCHAR(10))
+            RETURNS INTEGER AS BEGIN END
+        `;
+        const outputSubjects = (0, index_1.extractFunctionParameters)(ddl).filter((s) => s.type === 'outputParameter');
+        (0, vitest_1.expect)(outputSubjects).toHaveLength(0);
+    });
+    (0, vitest_1.it)('never emits outputParameter even for a function with no parameters', () => {
+        const ddl = `FUNCTION F () RETURNS INTEGER AS BEGIN END`;
+        const outputSubjects = (0, index_1.extractFunctionParameters)(ddl).filter((s) => s.type === 'outputParameter');
+        (0, vitest_1.expect)(outputSubjects).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-5  TABLE-type IN parameter: inner columns not extracted
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-5: TABLE-type IN parameter columns not extracted', () => {
+    (0, vitest_1.it)('extracts only the outer parameter name, not inner column names', () => {
+        const ddl = `
+            FUNCTION F (
+                IN TV_INPUT TABLE (COL1 INTEGER, COL2 NVARCHAR(100))
+            ) RETURNS INTEGER AS BEGIN END
+        `;
+        const result = (0, index_1.extractFunctionParameters)(ddl);
+        (0, vitest_1.expect)(result).toContainEqual({ type: 'inputParameter', name: 'TV_INPUT' });
+        (0, vitest_1.expect)(result.map((s) => s.name)).not.toContain('COL1');
+        (0, vitest_1.expect)(result.map((s) => s.name)).not.toContain('COL2');
+    });
+    (0, vitest_1.it)('handles multi-column TABLE-type IN param without extracting column names', () => {
+        const ddl = `
+            FUNCTION F (
+                IN TV_DATA TABLE (
+                    ID BIGINT,
+                    NAME NVARCHAR(200),
+                    CREATED_AT TIMESTAMP
+                )
+            ) RETURNS INTEGER AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['TV_DATA']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-6  Function body SQL does not pollute extraction
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-6: function body SQL does not pollute extraction', () => {
+    (0, vitest_1.it)('ignores IN keyword inside WHERE clause in the body', () => {
+        const ddl = `
+            FUNCTION F (IN IV_ID INTEGER) RETURNS INTEGER AS
+            BEGIN
+                SELECT COUNT(*) FROM MY_TABLE WHERE STATUS IN ('A', 'B');
+            END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_ID']);
+    });
+    (0, vitest_1.it)('handles nested BEGIN/END in body without false extraction', () => {
+        const ddl = `
+            FUNCTION F (IN IV_FLAG BOOLEAN) RETURNS NVARCHAR(10) AS
+            BEGIN
+                DECLARE result NVARCHAR(10);
+                IF IV_FLAG = TRUE THEN
+                BEGIN
+                    result = 'YES';
+                END;
+                RETURN result;
+            END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_FLAG']);
+    });
+    (0, vitest_1.it)('body content containing IN and function-like syntax is ignored', () => {
+        const ddl = `
+            FUNCTION F (IN IV_STATUS NVARCHAR(1), IN IV_ID INTEGER)
+            RETURNS TABLE (OUT_COL NVARCHAR(10))
+            AS
+            BEGIN
+                RETURN SELECT STATUS FROM T WHERE ID IN (1, 2, 3) AND TYPE = 'IN';
+            END
+        `;
+        const result = (0, index_1.extractFunctionParameters)(ddl);
+        (0, vitest_1.expect)(result).toEqual([
+            { type: 'inputParameter', name: 'IV_STATUS' },
+            { type: 'inputParameter', name: 'IV_ID' }
+        ]);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-7  Block comment exclusion
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-7: block comment exclusion', () => {
+    (0, vitest_1.it)('does not extract a parameter wrapped in /* … */', () => {
+        const ddl = `
+            FUNCTION F (
+                IN IV_ACTIVE BOOLEAN
+                /* , IN IV_OLD NVARCHAR(10) */
+            ) RETURNS INTEGER AS BEGIN END
+        `;
+        const names = inputs(ddl);
+        (0, vitest_1.expect)(names).not.toContain('IV_OLD');
+        (0, vitest_1.expect)(names).toContain('IV_ACTIVE');
+    });
+    (0, vitest_1.it)('handles block comment spanning multiple lines', () => {
+        const ddl = `
+            FUNCTION F (
+                /*
+                 * IN IV_COMMENTED INTEGER,
+                 */
+                IN IV_REAL NVARCHAR(10)
+            ) RETURNS INTEGER AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_REAL']);
+        (0, vitest_1.expect)(inputs(ddl)).not.toContain('IV_COMMENTED');
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-8  Line comment exclusion
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-8: line comment exclusion', () => {
+    (0, vitest_1.it)('does not extract a parameter on a -- comment line', () => {
+        const ddl = `
+            FUNCTION F (
+                IN IV_ID INTEGER
+                -- , IN IV_OLD NVARCHAR(10)
+            ) RETURNS INTEGER AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_ID']);
+        (0, vitest_1.expect)(inputs(ddl)).not.toContain('IV_OLD');
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-9  Quoted identifier normalisation
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-9: quoted identifier normalisation', () => {
+    (0, vitest_1.it)('strips double-quotes from a quoted parameter name', () => {
+        const ddl = `FUNCTION F (IN "IV_CUSTOMER_ID" NVARCHAR(10)) RETURNS INTEGER AS BEGIN END`;
+        (0, vitest_1.expect)((0, index_1.extractFunctionParameters)(ddl)).toContainEqual({
+            type: 'inputParameter',
+            name: 'IV_CUSTOMER_ID'
+        });
+    });
+    (0, vitest_1.it)('handles mixed quoted and unquoted parameters', () => {
+        const ddl = `
+            FUNCTION F (
+                IN "IV_QUOTED" NVARCHAR(10),
+                IN IV_UNQUOTED INTEGER
+            ) RETURNS INTEGER AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_QUOTED', 'IV_UNQUOTED']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-10  Schema-qualified function name
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-10: schema-qualified function name', () => {
+    (0, vitest_1.it)('parses schema-qualified name without error', () => {
+        const ddl = `
+            FUNCTION "MY_SCHEMA"."MY_FUNCTION" (IN IV_ID INTEGER)
+            RETURNS INTEGER AS BEGIN END
+        `;
+        (0, vitest_1.expect)(() => (0, index_1.extractFunctionParameters)(ddl)).not.toThrow();
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_ID']);
+    });
+    (0, vitest_1.it)('parses unquoted schema-qualified name without error', () => {
+        const ddl = `FUNCTION MY_SCHEMA.MY_FUNC (IN IV_X INTEGER) RETURNS INTEGER AS BEGIN END`;
+        (0, vitest_1.expect)(() => (0, index_1.extractFunctionParameters)(ddl)).not.toThrow();
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_X']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-11  Function options are ignored
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-11: function option clauses do not affect extraction', () => {
+    (0, vitest_1.it)('handles LANGUAGE SQLSCRIPT SQL SECURITY INVOKER', () => {
+        const ddl = `
+            FUNCTION F (IN IV_ID INTEGER)
+            RETURNS INTEGER
+            LANGUAGE SQLSCRIPT
+            SQL SECURITY INVOKER
+            AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_ID']);
+    });
+    (0, vitest_1.it)('handles SQL SECURITY DEFINER WITH ENCRYPTION', () => {
+        const ddl = `
+            FUNCTION F (IN IV_X NVARCHAR(10))
+            RETURNS NVARCHAR(10)
+            SQL SECURITY DEFINER
+            WITH ENCRYPTION
+            AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_X']);
+    });
+    (0, vitest_1.it)('handles DEFAULT SCHEMA option', () => {
+        const ddl = `
+            FUNCTION F (IN IV_X INTEGER)
+            RETURNS INTEGER
+            DEFAULT SCHEMA MY_SCHEMA
+            AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_X']);
+    });
+    (0, vitest_1.it)('handles all options combined', () => {
+        const ddl = `
+            CREATE FUNCTION F (IN IV_A INTEGER, IN IV_B NVARCHAR(10))
+            RETURNS TABLE (RES_COL NVARCHAR(10))
+            LANGUAGE SQLSCRIPT
+            SQL SECURITY DEFINER
+            DEFAULT SCHEMA MY_SCHEMA
+            WITH ENCRYPTION
+            AS BEGIN END
+        `;
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_A', 'IV_B']);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-12  Empty parameter list
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-12: empty parameter list', () => {
+    (0, vitest_1.it)('returns empty array for a function with no parameters', () => {
+        const ddl = `FUNCTION F () RETURNS INTEGER AS BEGIN END`;
+        (0, vitest_1.expect)((0, index_1.extractFunctionParameters)(ddl)).toEqual([]);
+    });
+    (0, vitest_1.it)('returns empty array for a table function with no parameters', () => {
+        const ddl = `FUNCTION F () RETURNS TABLE (COL1 INTEGER) AS BEGIN END`;
+        (0, vitest_1.expect)((0, index_1.extractFunctionParameters)(ddl)).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-13  CREATE keyword optional
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-13: CREATE keyword optional', () => {
+    (0, vitest_1.it)('extracts identically with and without CREATE keyword', () => {
+        const withCreate = `CREATE FUNCTION F (IN IV_ID INTEGER) RETURNS INTEGER AS BEGIN END`;
+        const withoutCreate = `FUNCTION F (IN IV_ID INTEGER) RETURNS INTEGER AS BEGIN END`;
+        (0, vitest_1.expect)((0, index_1.extractFunctionParameters)(withCreate)).toEqual((0, index_1.extractFunctionParameters)(withoutCreate));
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-14  Graceful error on unparseable file
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-14: graceful error handling', () => {
+    (0, vitest_1.it)('does not throw on invalid syntax', () => {
+        const ddl = `FUNCTION ??? GARBAGE SYNTAX`;
+        (0, vitest_1.expect)(() => (0, index_1.extractFunctionParameters)(ddl)).not.toThrow();
+    });
+    (0, vitest_1.it)('returns an array (possibly empty) on invalid syntax', () => {
+        const ddl = `FUNCTION ??? GARBAGE SYNTAX`;
+        (0, vitest_1.expect)(Array.isArray((0, index_1.extractFunctionParameters)(ddl))).toBe(true);
+    });
+    (0, vitest_1.it)('does not throw on an empty string', () => {
+        (0, vitest_1.expect)(() => (0, index_1.extractFunctionParameters)('')).not.toThrow();
+        (0, vitest_1.expect)(Array.isArray((0, index_1.extractFunctionParameters)(''))).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// AC-15  CRLF line endings
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('AC-15: CRLF line ending support', () => {
+    (0, vitest_1.it)('correctly extracts parameters from a file with CRLF line endings', () => {
+        const ddl = 'FUNCTION F (\r\n    IN IV_ID INTEGER,\r\n    IN IV_NAME NVARCHAR(100)\r\n) RETURNS INTEGER AS BEGIN END';
+        (0, vitest_1.expect)(inputs(ddl)).toEqual(['IV_ID', 'IV_NAME']);
+    });
+});

package/dist/parsers/hdbfunction/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFunctionParameters = extractFunctionParameters;
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const visitor_1 = require("./visitor");
+/**
+ * Extract parameter names from the content of a `.hdbfunction` DDL file.
+ *
+ * Uses a Chevrotain lexer and CstParser. The parser recognises the function
+ * header (parameter list, RETURNS clause, and options) and consumes the entire
+ * function body (AS BEGIN … END) as an opaque block, ensuring that SQL keywords
+ * inside the body never contaminate the extraction result.
+ *
+ * HANA functions accept only IN parameters. Every parameter produces an
+ * { type: 'inputParameter', name } entry. No 'outputParameter' entries are
+ * ever produced. RETURNS clause types and RETURNS TABLE column names are
+ * parsed structurally but not extracted.
+ *
+ * Handles block/line comments, quoted and unquoted identifiers, schema-qualified
+ * function names, TABLE-type IN parameters, RETURNS TABLE definitions, and all
+ * standard function options. Gracefully returns partial results on invalid input
+ * — does not throw.
+ *
+ * @param fileContent - Raw UTF-8 file content (LF or CRLF).
+ * @returns Array of ExtractedSubject with type 'inputParameter' only.
+ */
+function extractFunctionParameters(fileContent) {
+    const lexResult = lexer_1.HdbFunctionLexer.tokenize(fileContent);
+    // Feed the token stream to the singleton parser.
+    parser_1.hdbFunctionParser.input = lexResult.tokens;
+    const cst = parser_1.hdbFunctionParser.createFunctionStatement();
+    // Lex/parse errors are intentionally not re-thrown — the CST visitor
+    // will extract whatever parameters 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.HdbFunctionParameterVisitor();
+    visitor.visit(cst);
+    return visitor.parameters;
+}