@glion/lint-max-message-size 0.14.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Rethink Health
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# @glion/lint-max-message-size
+
+A [`unified`][github-unified] lint rule that warns when an HL7v2 message exceeds a configurable maximum size in bytes or number of segments.
+
+- **Default max size:** 10,000,000 bytes (10MB)
+- **Optional:** Limit the number of segments
+
+## What is this?
+
+This package validates the **maximum message size** in HL7v2 syntax trees produced by parsers like [`@glion/parser`][github-hl7v2-parser].
+
+It reports a message when the HL7v2 message exceeds a configurable maximum size in bytes (default: 1,000,000 bytes) or, optionally, a maximum number of segments.
+
+## When should I use this?
+
+Use this rule to enforce a maximum HL7v2 message size (in bytes) and/or segment count, helping to prevent oversized messages that may cause downstream processing issues or violate system constraints.
+
+This linter is useful for:
+
+- Ensuring HL7v2 messages do not exceed a safe or expected size limit (default: 10MB).
+- Optionally restricting the number of segments in a message to catch unusually large or malformed messages.
+- Improving reliability and performance by catching messages that could cause resource exhaustion or be rejected by receivers.
+
+Configure the rule to match your system's requirements for message size and segment count.
+
+## Install
+
+This package is **ESM only**. In Node.js (v16+), install with npm:
+
+```sh
+npm install @glion/lint-max-message-size
+```
+
+## Use
+
+On the API:
+
+```js
+import { unified } from "unified";
+import { hl7v2Parse } from "@glion/parser";
+import hl7v2LintMaxMessageSize from "@glion/lint-max-message-size";
+import { reporter } from "vfile-reporter";
+
+const msg = `MSH|^~\\&|...`;
+const file = await unified()
+  .use(hl7v2Parse)
+  .use(hl7v2LintMaxMessageSize)
+  .process(msg);
+
+console.error(reporter([file]));
+```
+
+## API
+
+### `unified().use(hl7v2LintMaxMessageSize[, options])`
+
+Warns when the HL7v2 message exceeds a configurable maximum size in bytes (default: 10,000,000 bytes) or, optionally, a maximum number of segments.  
+Reports a message if the message is too large or has too many segments.
+
+###### Returns
+
+A `unified` Transformer that adds messages to the file.
+
+## Security
+
+This plugin only transforms AST nodes and does not execute code. Ensure you trust the source of HL7v2 messages before processing.
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide][github-contributing] for more details.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Code of Conduct
+
+To ensure a welcoming and positive environment, we have a [Code of Conduct][github-code-of-conduct] that all contributors and participants are expected to adhere to.
+
+## License
+
+Copyright 2025 Rethink Health, SUARL. All rights reserved.
+
+This program is licensed to you under the terms of the [MIT License](https://opensource.org/licenses/MIT). This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the [LICENSE][github-license] file for details.
+
+[github-code-of-conduct]: https://github.com/rethinkhealth/glion/blob/main/CODE_OF_CONDUCT.md
+[github-license]: https://github.com/rethinkhealth/glion/blob/main/LICENSE
+[github-contributing]: https://github.com/rethinkhealth/glion/blob/main/CONTRIBUTING.md
+[github-unified]: https://github.com/unifiedjs/unified
+[github-hl7v2-parser]: https://github.com/rethinkhealth/glion/tree/main/packages/hl7v2-parser

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import type { Node } from "@glion/ast";
+export interface MaxMessageSizeOptions {
+    /**
+     * Max allowed size of the HL7v2 message in bytes (UTF-8). Default: 1_000_000
+     * (1MB).
+     */
+    maxBytes?: number;
+    /**
+     * Max allowed number of segments (counts nodes with `type: "segment"`).
+     * Default: undefined (disabled). Set to a number to enable.
+     */
+    maxSegments?: number;
+}
+/**
+ * Hl7v2-lint rule to warn when message size exceeds the maximum allowed size.
+ *
+ * This rule is useful for ensuring that HL7v2 messages do not exceed a safe
+ * or expected size limit (default: 10MB).
+ */
+declare const hl7v2LintMaxMessageSize: import("unified-lint-rule").Plugin<Node, MaxMessageSizeOptions>;
+export default hl7v2LintMaxMessageSize;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAKvC,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AASD;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,iEAwC5B,CAAC;AAEF,eAAe,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,37 @@
+import pluralize from "pluralize";
+import { lintRule } from "unified-lint-rule";
+import { SKIP, visit } from "unist-util-visit";
+//#region src/index.ts
+const defaultOptions = {
+	maxBytes: 1e7,
+	maxSegments: void 0
+};
+/**
+* Hl7v2-lint rule to warn when message size exceeds the maximum allowed size.
+*
+* This rule is useful for ensuring that HL7v2 messages do not exceed a safe
+* or expected size limit (default: 10MB).
+*/
+const hl7v2LintMaxMessageSize = lintRule({
+	origin: "hl7v2-lint:max-message-size",
+	url: "https://github.com/rethinkhealth/hl7v2/tree/main/packages/hl7v2-lint-max-message-size#readme"
+}, (tree, file, opts) => {
+	const options = {
+		...defaultOptions,
+		...opts
+	};
+	const byteLength = Buffer.byteLength(String(file.value), "utf8");
+	if (byteLength > options.maxBytes) file.message(`Message size ${pluralize("byte", byteLength, true)} exceeds ${pluralize("byte", options.maxBytes, true)} limit — trim payload or raise "maxBytes"`);
+	let totalSegments = 0;
+	visit(tree, (node) => {
+		if (node.type === "segment") {
+			totalSegments += 1;
+			return SKIP;
+		}
+	});
+	if (options.maxSegments && totalSegments > options.maxSegments) file.message(`Message contains ${pluralize("segment", totalSegments, true)} (limit ${pluralize("segment", options.maxSegments, true)}) — reduce segment count or raise "maxSegments"`);
+});
+//#endregion
+export { hl7v2LintMaxMessageSize as default };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { Node } from \"@glion/ast\";\nimport pluralize from \"pluralize\";\nimport { lintRule } from \"unified-lint-rule\";\nimport { SKIP, visit } from \"unist-util-visit\";\n\nexport interface MaxMessageSizeOptions {\n  /**\n   * Max allowed size of the HL7v2 message in bytes (UTF-8). Default: 1_000_000\n   * (1MB).\n   */\n  maxBytes?: number;\n  /**\n   * Max allowed number of segments (counts nodes with `type: \"segment\"`).\n   * Default: undefined (disabled). Set to a number to enable.\n   */\n  maxSegments?: number;\n}\n\nconst defaultOptions: Required<Omit<MaxMessageSizeOptions, \"maxSegments\">> & {\n  maxSegments?: number;\n} = {\n  maxBytes: 10_000_000, // 10MB\n  maxSegments: undefined,\n};\n\n/**\n * Hl7v2-lint rule to warn when message size exceeds the maximum allowed size.\n *\n * This rule is useful for ensuring that HL7v2 messages do not exceed a safe\n * or expected size limit (default: 10MB).\n */\nconst hl7v2LintMaxMessageSize = lintRule<Node, MaxMessageSizeOptions>(\n  {\n    origin: \"hl7v2-lint:max-message-size\",\n    url: \"https://github.com/rethinkhealth/hl7v2/tree/main/packages/hl7v2-lint-max-message-size#readme\",\n  },\n  (tree, file, opts) => {\n    const options = { ...defaultOptions, ...opts };\n\n    // Byte length of the message\n    const byteLength = Buffer.byteLength(String(file.value), \"utf8\");\n    if (byteLength > options.maxBytes) {\n      file.message(\n        `Message size ${pluralize(\"byte\", byteLength, true)} exceeds ${pluralize(\"byte\", options.maxBytes, true)} limit — trim payload or raise \"maxBytes\"`\n      );\n    }\n\n    let totalSegments = 0;\n\n    visit(tree, (node) => {\n      // Count all segments including those in nested groups\n      if (node.type === \"segment\") {\n        totalSegments += 1;\n        return SKIP;\n      }\n    });\n\n    if (options.maxSegments && totalSegments > options.maxSegments) {\n      file.message(\n        `Message contains ${pluralize(\n          \"segment\",\n          totalSegments,\n          true\n        )} (limit ${pluralize(\n          \"segment\",\n          options.maxSegments,\n          true\n        )}) — reduce segment count or raise \"maxSegments\"`\n      );\n    }\n  }\n);\n\nexport default hl7v2LintMaxMessageSize;\n"],"mappings":";;;;AAkBA,MAAM,iBAEF;CACF,UAAU;CACV,aAAa,KAAA;CACd;;;;;;;AAQD,MAAM,0BAA0B,SAC9B;CACE,QAAQ;CACR,KAAK;CACN,GACA,MAAM,MAAM,SAAS;CACpB,MAAM,UAAU;EAAE,GAAG;EAAgB,GAAG;EAAM;CAG9C,MAAM,aAAa,OAAO,WAAW,OAAO,KAAK,MAAM,EAAE,OAAO;AAChE,KAAI,aAAa,QAAQ,SACvB,MAAK,QACH,gBAAgB,UAAU,QAAQ,YAAY,KAAK,CAAC,WAAW,UAAU,QAAQ,QAAQ,UAAU,KAAK,CAAC,2CAC1G;CAGH,IAAI,gBAAgB;AAEpB,OAAM,OAAO,SAAS;AAEpB,MAAI,KAAK,SAAS,WAAW;AAC3B,oBAAiB;AACjB,UAAO;;GAET;AAEF,KAAI,QAAQ,eAAe,gBAAgB,QAAQ,YACjD,MAAK,QACH,oBAAoB,UAClB,WACA,eACA,KACD,CAAC,UAAU,UACV,WACA,QAAQ,aACR,KACD,CAAC,iDACH;EAGN"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@glion/lint-max-message-size",
+  "version": "0.14.1",
+  "description": "hl7v2-lint rule to warn when message size exceeds the maximum allowed size",
+  "keywords": [
+    "definition",
+    "hl7",
+    "hl7v2",
+    "hl7v2-lint",
+    "hl7v2-lint-rule",
+    "lint",
+    "nodejs",
+    "rule",
+    "typescript"
+  ],
+  "homepage": "https://glion.dev",
+  "license": "MIT",
+  "author": {
+    "name": "Melek Somai",
+    "email": "melek@rethinkhealth.io"
+  },
+  "repository": "rethinkhealth/glion.git",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "pluralize": "8.0.0",
+    "unified": "11.0.5",
+    "unified-lint-rule": "3.0.1",
+    "unist-util-visit": "5.1.0",
+    "unist-util-visit-parents": "6.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/pluralize": "^0.0.33",
+    "@types/unist": "^3.0.3",
+    "@vitest/coverage-v8": "4.1.2",
+    "tsdown": "0.21.7",
+    "typescript": "^5.9.3",
+    "vfile": "^6.0.3",
+    "vitest": "4.1.2",
+    "@glion/tsconfig": "0.0.1",
+    "@glion/builder": "0.14.1",
+    "@glion/ast": "0.14.1",
+    "@glion/testing": "0.0.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsdown && tsc --emitDeclarationOnly",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
+  }
+}