reverse-schema 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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,85 @@
+# Reverse Schema
+
+Reverse Schema is a small Node.js library for parsing text lines with an ordered array of regular expression fragments. It is designed for cases where a line has a known shape, such as MT940 statement lines, fixed-width data, CSV-like rows, or other text formats.
+
+## Install
+
+For local React app development, install this package from its folder:
+
+```sh
+npm install ../ReverseSchema
+```
+
+## Usage
+
+```js
+import { parseText } from 'reverse-schema';
+
+const schema = [
+  { pattern: ':61:', capture: false },
+  { name: 'valueDate', pattern: '\\d{6}' },
+  { name: 'entryDate', pattern: '\\d{4}' },
+  { name: 'dcMark', pattern: '[DC]' },
+  { name: 'amount', pattern: '\\d+,\\d{0,2}' },
+  { name: 'transactionType', pattern: '[A-Z0-9]{4}' },
+  { name: 'customerReference', pattern: '[^/]+' },
+  { pattern: '//', capture: false },
+  { name: 'bankReference', pattern: '.+' }
+];
+
+const text = ':61:2502180218D12,01NTRFGSLNVSHSUTKWDR//GI2504900007841';
+
+const rows = parseText(schema, text);
+
+console.log(rows);
+```
+
+Output:
+
+```js
+[
+  {
+    valueDate: '250218',
+    entryDate: '0218',
+    dcMark: 'D',
+    amount: '12,01',
+    transactionType: 'NTRF',
+    customerReference: 'GSLNVSHSUTKWDR',
+    bankReference: 'GI2504900007841'
+  }
+]
+```
+
+## API
+
+### `parseText(schema, text)`
+
+Parses a string line by line. Each line is checked against the full generated regex. Nonmatching lines are ignored. Matching lines return one plain JavaScript object each.
+
+### `parseLine(schemaOrCompiled, line)`
+
+Parses one line and returns a plain JavaScript object, or `null` if the line does not match.
+
+### `compileSchema(schema)`
+
+Compiles a schema once and returns `{ regex, source, capturedNames }`. Use this when parsing many individual lines with the same schema.
+
+## Schema Items
+
+Each schema item supports:
+
+```ts
+{
+  name?: string;
+  pattern: string;
+  capture?: boolean;
+}
+```
+
+`pattern` is a JavaScript regular expression fragment. Patterns are concatenated in order and anchored as `^{patterns}$`.
+
+When `capture` is omitted or `true`, the item must have a `name`. Its pattern is wrapped in a named capture group and included in output.
+
+When `capture` is `false`, the pattern still participates in matching but is omitted from output. This is useful for tags, delimiters, and other structural text.
+
+All captured values are returned as strings. No date, number, or amount conversion is performed.

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "reverse-schema",
+  "version": "0.1.0",
+  "description": "Parse text lines using ordered regex schema fragments.",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "parser",
+    "regex",
+    "schema",
+    "mt940"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,22 @@
+export interface ReverseSchemaItem {
+  name?: string;
+  pattern: string;
+  capture?: boolean;
+}
+
+export interface CompiledReverseSchema {
+  regex: RegExp;
+  source: string;
+  capturedNames: string[];
+}
+
+export class ReverseSchemaError extends Error {}
+
+export function compileSchema(schema: ReverseSchemaItem[]): CompiledReverseSchema;
+
+export function parseLine(
+  schemaOrCompiled: ReverseSchemaItem[] | CompiledReverseSchema,
+  line: string
+): Record<string, string> | null;
+
+export function parseText(schema: ReverseSchemaItem[], text: string): Array<Record<string, string>>;

package/src/index.js

@@ -0,0 +1,112 @@
+const VALID_GROUP_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+export class ReverseSchemaError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'ReverseSchemaError';
+  }
+}
+
+export function compileSchema(schema) {
+  validateSchemaArray(schema);
+
+  const capturedNames = [];
+  const seenNames = new Set();
+  const fragments = schema.map((item, index) => {
+    validateSchemaItem(item, index);
+
+    if (item.capture === false) {
+      return `(?:${item.pattern})`;
+    }
+
+    if (!VALID_GROUP_NAME.test(item.name)) {
+      throw new ReverseSchemaError(
+        `Schema item at index ${index} has invalid capture name "${item.name}". Names must be valid JavaScript RegExp group names.`
+      );
+    }
+
+    if (seenNames.has(item.name)) {
+      throw new ReverseSchemaError(`Duplicate capture name "${item.name}" at schema index ${index}.`);
+    }
+
+    seenNames.add(item.name);
+    capturedNames.push(item.name);
+    return `(?<${item.name}>${item.pattern})`;
+  });
+
+  const source = `^${fragments.join('')}$`;
+
+  try {
+    return {
+      regex: new RegExp(source),
+      source,
+      capturedNames
+    };
+  } catch (error) {
+    throw new ReverseSchemaError(`Generated regex is invalid: ${error.message}`);
+  }
+}
+
+export function parseLine(schemaOrCompiled, line) {
+  const compiled = isCompiledSchema(schemaOrCompiled) ? schemaOrCompiled : compileSchema(schemaOrCompiled);
+  const match = compiled.regex.exec(String(line));
+
+  if (!match) {
+    return null;
+  }
+
+  const output = {};
+  for (const name of compiled.capturedNames) {
+    output[name] = match.groups?.[name] ?? '';
+  }
+
+  return output;
+}
+
+export function parseText(schema, text) {
+  const compiled = compileSchema(schema);
+  const lines = String(text).split(/\r\n|\n|\r/);
+  const results = [];
+
+  for (const line of lines) {
+    const parsed = parseLine(compiled, line);
+    if (parsed !== null) {
+      results.push(parsed);
+    }
+  }
+
+  return results;
+}
+
+function validateSchemaArray(schema) {
+  if (!Array.isArray(schema)) {
+    throw new ReverseSchemaError('Schema must be an array.');
+  }
+}
+
+function validateSchemaItem(item, index) {
+  if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+    throw new ReverseSchemaError(`Schema item at index ${index} must be an object.`);
+  }
+
+  if (typeof item.pattern !== 'string') {
+    throw new ReverseSchemaError(`Schema item at index ${index} must have a string pattern.`);
+  }
+
+  if ('capture' in item && typeof item.capture !== 'boolean') {
+    throw new ReverseSchemaError(`Schema item at index ${index} must use a boolean capture value.`);
+  }
+
+  if (item.capture !== false && typeof item.name !== 'string') {
+    throw new ReverseSchemaError(`Schema item at index ${index} must have a string name unless capture is false.`);
+  }
+}
+
+function isCompiledSchema(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    value.regex instanceof RegExp &&
+    Array.isArray(value.capturedNames)
+  );
+}