@clickhouse/datatype-parser 0.1.1 → 0.1.2

package/README.md

@@ -308,7 +308,6 @@ The module structure tracks the C++ sources one-to-one:
 | `src/parser.ts` | `src/parser.cpp` + `parser.h` | the `ParserDataType::parseImpl` port    |
 | `src/json.ts`   | `src/json.cpp`                | the byte-faithful JSON serializer       |
 | `src/index.ts`  | —                             | public barrel                           |
-| `tool/main.ts`  | `tool/main.cpp`               | the `chdt-parse` CLI                    |
 
 The lexer and parser deliberately preserve the original control flow, branch
 ordering, helper names, and `pos` save/restore points. A few signatures changed

package/dist/parser.js

@@ -40,6 +40,17 @@ function isWordCharOrDollar(c) {
 function isEnumTypeUpper(u) {
     return u === "ENUM" || u === "ENUM8" || u === "ENUM16";
 }
+/// Does `text` parse in FULL as a numeric literal — the TS equivalent of the
+/// C++ `strtod` (float) / `strtoull` (integer) + end-pointer check? The lexer
+/// is deliberately lenient and can hand back a half-formed lexeme such as `1e`
+/// (an exponent with no digits); those must be rejected. Integer lexemes the
+/// lexer emits are pure digit runs (so always valid); floats may carry a
+/// malformed exponent, so the optional exponent here requires >= 1 digit.
+function isFullyParsedNumber(text, isFloat) {
+    if (isFloat)
+        return /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(text);
+    return /^\d+$/.test(text);
+}
 class Parser {
     tokens;
     pos = 0;
@@ -419,13 +430,26 @@ class Parser {
         }
         if (this.type() !== TokenType.Number)
             return null;
+        /// The lexer only SKIPS over a number without checking correctness (the
+        /// server's `Lexer` does the same: "not to parse a number or check
+        /// correctness, but only to skip it"). The server then rejects a malformed
+        /// literal when it converts the token text into a `Field`; this port has no
+        /// such stage, so validate here by parsing the lexeme in full. Without it a
+        /// bare exponent like `1e` would be emitted verbatim into a `Float64`
+        /// literal's JSON `value`, yielding invalid JSON (`"value":1e`). Mirrors the
+        /// C++ `strtod` / `strtoull` + end-pointer check in `parser.cpp`.
+        const text = this.cur().text;
+        if (!isFullyParsedNumber(text, this.cur().is_float)) {
+            this.setHardError(this.cur().begin, `malformed numeric literal: '${text}'`);
+            return null;
+        }
         const node = makeNode(NodeKind.Literal);
         node.value_type = this.cur().is_float
             ? "Float64"
             : negative
                 ? "Int64"
                 : "UInt64";
-        node.value = (negative ? "-" : "") + this.cur().text;
+        node.value = (negative ? "-" : "") + text;
         this.advance();
         return node;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clickhouse/datatype-parser",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Standalone ClickHouse data-type string parser — a TypeScript port of the chdt C++ library.",
   "license": "Apache-2.0",
   "type": "module",
@@ -41,8 +41,8 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint --max-warnings=0 .",
     "lint:fix": "eslint . --fix",
+    "pack": "npm pack",
     "prepack": "npm run build",
-    "parse": "node tool/main.ts",
     "bench": "vitest bench --run",
     "test": "vitest run",
     "test:watch": "vitest",