@the-software-compagny/parser_ldap_rfc4512 0.1.1 → 0.2.0

package/README.md

@@ -15,6 +15,7 @@ This project provides a comprehensive parser for LDAP (Lightweight Directory Acc
 
 ### 🔧 Complete RFC 4512 Parser
 - **Full RFC 4512 Compliance**: Strictly follows the official LDAP schema definition format
+- **OpenLDAP cn=config Support**: Automatically handles OpenLDAP index prefixes like `{57}`
 - **Object Class Parsing**: Complete support for STRUCTURAL, AUXILIARY, and ABSTRACT object classes
 - **Attribute Type Parsing**: Comprehensive parsing of attribute types with all their properties
 - **OID Validation**: Robust validation of numeric object identifiers
@@ -184,6 +185,69 @@ Complete support for attribute type definitions:
 )
 ```
 
+## 🔧 OpenLDAP cn=config Support
+
+The parser includes built-in support for OpenLDAP's `cn=config` format, which uses index prefixes to maintain ordering of multi-valued attributes like `olcAttributeTypes` and `olcObjectClasses`.
+
+### Index Prefix Support
+
+OpenLDAP uses numeric prefixes in curly braces to maintain the order of schema definitions:
+
+```ldap
+# OpenLDAP cn=config format with index prefix
+{57}( 1.3.6.1.4.1.7165.2.1.80 NAME 'sambaSupportedEncryptionTypes' 
+      DESC 'Supported encryption types of a trust' 
+      EQUALITY integerMatch 
+      SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 
+      SINGLE-VALUE )
+
+# Equivalent RFC 4512 pure format (without prefix)
+( 1.3.6.1.4.1.7165.2.1.80 NAME 'sambaSupportedEncryptionTypes' 
+  DESC 'Supported encryption types of a trust' 
+  EQUALITY integerMatch 
+  SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 
+  SINGLE-VALUE )
+```
+
+### Automatic Prefix Removal
+
+The parser automatically detects and removes OpenLDAP index prefixes:
+
+```typescript
+import { parseSchema } from '@the-software-compagny/parser_ldap_rfc4512'
+
+// Both formats parse to identical results
+const openLdapFormat = '{57}( 2.5.4.3 NAME \'cn\' DESC \'Common Name\' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )'
+const rfc4512Format = '( 2.5.4.3 NAME \'cn\' DESC \'Common Name\' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )'
+
+const result1 = parseSchema(openLdapFormat)
+const result2 = parseSchema(rfc4512Format)
+
+console.log(result1 === result2) // true - identical results
+```
+
+### Supported Prefix Patterns
+
+The parser handles various OpenLDAP prefix formats:
+
+- **Basic format**: `{0}`, `{57}`, `{123}`
+- **With whitespace**: `  {0}  `, `\t{57}\t`
+- **Leading spaces**: `   {0}(definition...)`
+- **Any numeric index**: `{0}` to `{99999}` and beyond
+
+### CLI Support for OpenLDAP Format
+
+The CLI tool seamlessly handles OpenLDAP exports:
+
+```bash
+# Parse OpenLDAP cn=config exports directly
+rfc4512-parser --input openldap-export.ldif --format json
+
+# Example OpenLDAP export file content:
+# {0}( 2.5.4.3 NAME 'cn' DESC 'Common Name' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
+# {1}( 2.5.4.4 NAME 'sn' DESC 'Surname' SUP name )
+```
+
 ## 🏗️ Project Architecture
 
 ```bash

package/cli.js

@@ -12760,21 +12760,46 @@ var __dirname = "/home/runner/work/parser_ldap_rfc4512/parser_ldap_rfc4512/src";
 
 class RFC4512Parser {
   _parser;
-  constructor(options2) {
+  _options;
+  constructor(options2, pegOptions) {
+    this._options = {
+      relaxedMode: false,
+      ...options2
+    };
     try {
       const grammarPath = path.join(__dirname, "./_grammars/rfc4512.pegjs");
       const grammar = readFileSync3(grammarPath, "utf-8");
-      this._parser = import_peggy.generate(grammar, options2);
+      this._parser = import_peggy.generate(grammar, pegOptions);
     } catch (error) {
       throw new RFC4512ParserError(`Error loading grammar: ${error instanceof Error ? error.message : "Unknown error"}`, "GRAMMAR_LOAD_ERROR" /* GRAMMAR_LOAD_ERROR */, "", { cause: error instanceof Error ? error : undefined });
     }
   }
+  removeOpenLDAPPrefix(schemaDefinition) {
+    const openLdapPrefixPattern = /^\s*\{\d+\}\s*/;
+    return schemaDefinition.replace(openLdapPrefixPattern, "").trim();
+  }
+  transformOpenLDAPOids(schemaDefinition) {
+    if (!this._options.relaxedMode) {
+      return schemaDefinition;
+    }
+    const openldapOidPattern = /\b(OLcfg(?:Ov|Db|Gl)(?:At|Oc)):([\d.]+)\b/g;
+    return schemaDefinition.replace(openldapOidPattern, (match, prefix, suffix) => {
+      return match;
+    });
+  }
   parseSchema(schemaDefinition) {
     try {
-      const cleanInput = schemaDefinition.trim();
+      let cleanInput = this.removeOpenLDAPPrefix(schemaDefinition).trim();
+      cleanInput = this.transformOpenLDAPOids(cleanInput);
       if (!cleanInput) {
         throw new RFC4512ParserError("Schema definition cannot be empty", "EMPTY_INPUT" /* EMPTY_INPUT */, schemaDefinition);
       }
+      if (!this._options.relaxedMode) {
+        const openldapOidPattern = /\b(OLcfg(?:Ov|Db|Gl)(?:At|Oc)):([\d.]+)\b/;
+        if (openldapOidPattern.test(cleanInput)) {
+          throw new RFC4512ParserError("OpenLDAP configuration OIDs are not supported in strict RFC 4512 mode. Use relaxedMode: true to enable support.", "SYNTAX_ERROR" /* SYNTAX_ERROR */, schemaDefinition);
+        }
+      }
       const parsed = this._parser.parse(cleanInput);
       if (!parsed.oid) {
         throw new RFC4512ParserError("Missing OID in schema definition", "MISSING_FIELD" /* MISSING_FIELD */, schemaDefinition, { context: "OID field is required for all LDAP schema definitions" });
@@ -12789,8 +12814,11 @@ class RFC4512Parser {
           throw new RFC4512ParserError("ObjectClass must specify exactly one type: STRUCTURAL, AUXILIARY, or ABSTRACT", "OBJECTCLASS_ERROR" /* OBJECTCLASS_ERROR */, schemaDefinition, { context: "RFC 4512 Section 4.1.1 - ObjectClass type validation" });
         }
         const oidPattern = /^[0-9]+(\.[0-9]+)*$/;
-        if (!oidPattern.test(objectClass.oid)) {
-          throw new RFC4512ParserError(`Invalid OID format: ${objectClass.oid}. Must follow dotted decimal notation`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: "RFC 4512 - OID must use dotted decimal notation (e.g., 2.5.6.6)" });
+        const openldapOidPattern = /^OLcfg(?:Ov|Db|Gl)(?:At|Oc):[0-9]+(\.[0-9]+)*$/;
+        const isValidOid = this._options.relaxedMode ? oidPattern.test(objectClass.oid) || openldapOidPattern.test(objectClass.oid) : oidPattern.test(objectClass.oid);
+        if (!isValidOid) {
+          const validFormats = this._options.relaxedMode ? "dotted decimal notation (e.g., 2.5.6.6) or OpenLDAP configuration format (e.g., OLcfgOvAt:18.1)" : "dotted decimal notation (e.g., 2.5.6.6)";
+          throw new RFC4512ParserError(`Invalid OID format: ${objectClass.oid}. Must follow ${validFormats}`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: `RFC 4512 - OID validation (relaxedMode: ${this._options.relaxedMode})` });
         }
         if (objectClass.sup && typeof objectClass.sup === "string") {
           const reservedKeywords = ["STRUCTURAL", "AUXILIARY", "ABSTRACT", "MUST", "MAY", "DESC", "NAME", "OBSOLETE"];
@@ -12832,7 +12860,8 @@ class RFC4512Parser {
           "sup",
           "objectClassType",
           "must",
-          "may"
+          "may",
+          "extensions"
         ];
         for (const key of Object.keys(objectClass)) {
           if (!validObjectClassFields.includes(key)) {
@@ -12843,8 +12872,11 @@ class RFC4512Parser {
       if (parsed.type === "attributeType") {
         const attributeType = parsed;
         const oidPattern = /^[0-9]+(\.[0-9]+)*$/;
-        if (!oidPattern.test(attributeType.oid)) {
-          throw new RFC4512ParserError(`Invalid OID format: ${attributeType.oid}. Must follow dotted decimal notation`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: "RFC 4512 - OID must use dotted decimal notation (e.g., 2.5.4.3)" });
+        const openldapOidPattern = /^OLcfg(?:Ov|Db|Gl)(?:At|Oc):[0-9]+(\.[0-9]+)*$/;
+        const isValidOid = this._options.relaxedMode ? oidPattern.test(attributeType.oid) || openldapOidPattern.test(attributeType.oid) : oidPattern.test(attributeType.oid);
+        if (!isValidOid) {
+          const validFormats = this._options.relaxedMode ? "dotted decimal notation (e.g., 2.5.4.3) or OpenLDAP configuration format (e.g., OLcfgOvAt:18.1)" : "dotted decimal notation (e.g., 2.5.4.3)";
+          throw new RFC4512ParserError(`Invalid OID format: ${attributeType.oid}. Must follow ${validFormats}`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: `RFC 4512 - OID validation (relaxedMode: ${this._options.relaxedMode})` });
         }
         if (attributeType.sup && typeof attributeType.sup === "string") {
           const reservedKeywords = ["EQUALITY", "ORDERING", "SUBSTR", "SYNTAX", "SINGLE-VALUE", "COLLECTIVE", "NO-USER-MODIFICATION", "USAGE"];
@@ -12855,6 +12887,13 @@ class RFC4512Parser {
         if (!attributeType.sup && !attributeType.syntax) {
           throw new RFC4512ParserError("AttributeType must have either SUP (superior type) or SYNTAX defined", "ATTRIBUTETYPE_ERROR" /* ATTRIBUTETYPE_ERROR */, schemaDefinition, { context: "RFC 4512 Section 4.1.2 - AttributeType must inherit from superior or define syntax" });
         }
+        if (attributeType.syntax && !this._options.relaxedMode) {
+          const syntaxOid = attributeType.syntax.oid;
+          const standardOidPattern = /^[0-9]+(\.[0-9]+)*$/;
+          if (!standardOidPattern.test(syntaxOid)) {
+            throw new RFC4512ParserError(`Invalid SYNTAX OID format: ${syntaxOid}. In strict mode, SYNTAX must use standard numeric OID format (e.g., '1.3.6.1.4.1.1466.115.121.1.15'). Use relaxedMode: true to support OpenLDAP syntax names.`, "INVALID_FIELD" /* INVALID_FIELD */, schemaDefinition, { context: `RFC 4512 - SYNTAX validation (relaxedMode: ${this._options.relaxedMode})` });
+          }
+        }
         const validAttributeTypeFields = [
           "type",
           "oid",
@@ -12868,7 +12907,8 @@ class RFC4512Parser {
           "singleValue",
           "collective",
           "noUserModification",
-          "usage"
+          "usage",
+          "extensions"
         ];
         for (const key of Object.keys(attributeType)) {
           if (!validAttributeTypeFields.includes(key)) {
@@ -12917,12 +12957,15 @@ class RFC4512Parser {
       return null;
     }
   }
+  get options() {
+    return { ...this._options };
+  }
 }
 var rfc4512_parser_default = RFC4512Parser;
 
 // src/functions/parse-schema.function.ts
-function parseSchema(schemaDefinition, options2) {
-  const parser2 = new rfc4512_parser_default(options2);
+function parseSchema(schemaDefinition, options2, pegOptions) {
+  const parser2 = new rfc4512_parser_default(options2, pegOptions);
   return parser2.parseSchema(schemaDefinition);
 }
 // src/logger.ts

package/index.js

@@ -7916,21 +7916,46 @@ var __dirname = "/home/runner/work/parser_ldap_rfc4512/parser_ldap_rfc4512/src";
 
 class RFC4512Parser {
   _parser;
-  constructor(options2) {
+  _options;
+  constructor(options2, pegOptions) {
+    this._options = {
+      relaxedMode: false,
+      ...options2
+    };
     try {
       const grammarPath = path.join(__dirname, "./_grammars/rfc4512.pegjs");
       const grammar = readFileSync(grammarPath, "utf-8");
-      this._parser = import_peggy.generate(grammar, options2);
+      this._parser = import_peggy.generate(grammar, pegOptions);
     } catch (error) {
       throw new RFC4512ParserError(`Error loading grammar: ${error instanceof Error ? error.message : "Unknown error"}`, "GRAMMAR_LOAD_ERROR" /* GRAMMAR_LOAD_ERROR */, "", { cause: error instanceof Error ? error : undefined });
     }
   }
+  removeOpenLDAPPrefix(schemaDefinition) {
+    const openLdapPrefixPattern = /^\s*\{\d+\}\s*/;
+    return schemaDefinition.replace(openLdapPrefixPattern, "").trim();
+  }
+  transformOpenLDAPOids(schemaDefinition) {
+    if (!this._options.relaxedMode) {
+      return schemaDefinition;
+    }
+    const openldapOidPattern = /\b(OLcfg(?:Ov|Db|Gl)(?:At|Oc)):([\d.]+)\b/g;
+    return schemaDefinition.replace(openldapOidPattern, (match, prefix, suffix) => {
+      return match;
+    });
+  }
   parseSchema(schemaDefinition) {
     try {
-      const cleanInput = schemaDefinition.trim();
+      let cleanInput = this.removeOpenLDAPPrefix(schemaDefinition).trim();
+      cleanInput = this.transformOpenLDAPOids(cleanInput);
       if (!cleanInput) {
         throw new RFC4512ParserError("Schema definition cannot be empty", "EMPTY_INPUT" /* EMPTY_INPUT */, schemaDefinition);
       }
+      if (!this._options.relaxedMode) {
+        const openldapOidPattern = /\b(OLcfg(?:Ov|Db|Gl)(?:At|Oc)):([\d.]+)\b/;
+        if (openldapOidPattern.test(cleanInput)) {
+          throw new RFC4512ParserError("OpenLDAP configuration OIDs are not supported in strict RFC 4512 mode. Use relaxedMode: true to enable support.", "SYNTAX_ERROR" /* SYNTAX_ERROR */, schemaDefinition);
+        }
+      }
       const parsed = this._parser.parse(cleanInput);
       if (!parsed.oid) {
         throw new RFC4512ParserError("Missing OID in schema definition", "MISSING_FIELD" /* MISSING_FIELD */, schemaDefinition, { context: "OID field is required for all LDAP schema definitions" });
@@ -7945,8 +7970,11 @@ class RFC4512Parser {
           throw new RFC4512ParserError("ObjectClass must specify exactly one type: STRUCTURAL, AUXILIARY, or ABSTRACT", "OBJECTCLASS_ERROR" /* OBJECTCLASS_ERROR */, schemaDefinition, { context: "RFC 4512 Section 4.1.1 - ObjectClass type validation" });
         }
         const oidPattern = /^[0-9]+(\.[0-9]+)*$/;
-        if (!oidPattern.test(objectClass.oid)) {
-          throw new RFC4512ParserError(`Invalid OID format: ${objectClass.oid}. Must follow dotted decimal notation`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: "RFC 4512 - OID must use dotted decimal notation (e.g., 2.5.6.6)" });
+        const openldapOidPattern = /^OLcfg(?:Ov|Db|Gl)(?:At|Oc):[0-9]+(\.[0-9]+)*$/;
+        const isValidOid = this._options.relaxedMode ? oidPattern.test(objectClass.oid) || openldapOidPattern.test(objectClass.oid) : oidPattern.test(objectClass.oid);
+        if (!isValidOid) {
+          const validFormats = this._options.relaxedMode ? "dotted decimal notation (e.g., 2.5.6.6) or OpenLDAP configuration format (e.g., OLcfgOvAt:18.1)" : "dotted decimal notation (e.g., 2.5.6.6)";
+          throw new RFC4512ParserError(`Invalid OID format: ${objectClass.oid}. Must follow ${validFormats}`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: `RFC 4512 - OID validation (relaxedMode: ${this._options.relaxedMode})` });
         }
         if (objectClass.sup && typeof objectClass.sup === "string") {
           const reservedKeywords = ["STRUCTURAL", "AUXILIARY", "ABSTRACT", "MUST", "MAY", "DESC", "NAME", "OBSOLETE"];
@@ -7988,7 +8016,8 @@ class RFC4512Parser {
           "sup",
           "objectClassType",
           "must",
-          "may"
+          "may",
+          "extensions"
         ];
         for (const key of Object.keys(objectClass)) {
           if (!validObjectClassFields.includes(key)) {
@@ -7999,8 +8028,11 @@ class RFC4512Parser {
       if (parsed.type === "attributeType") {
         const attributeType = parsed;
         const oidPattern = /^[0-9]+(\.[0-9]+)*$/;
-        if (!oidPattern.test(attributeType.oid)) {
-          throw new RFC4512ParserError(`Invalid OID format: ${attributeType.oid}. Must follow dotted decimal notation`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: "RFC 4512 - OID must use dotted decimal notation (e.g., 2.5.4.3)" });
+        const openldapOidPattern = /^OLcfg(?:Ov|Db|Gl)(?:At|Oc):[0-9]+(\.[0-9]+)*$/;
+        const isValidOid = this._options.relaxedMode ? oidPattern.test(attributeType.oid) || openldapOidPattern.test(attributeType.oid) : oidPattern.test(attributeType.oid);
+        if (!isValidOid) {
+          const validFormats = this._options.relaxedMode ? "dotted decimal notation (e.g., 2.5.4.3) or OpenLDAP configuration format (e.g., OLcfgOvAt:18.1)" : "dotted decimal notation (e.g., 2.5.4.3)";
+          throw new RFC4512ParserError(`Invalid OID format: ${attributeType.oid}. Must follow ${validFormats}`, "INVALID_OID" /* INVALID_OID */, schemaDefinition, { context: `RFC 4512 - OID validation (relaxedMode: ${this._options.relaxedMode})` });
         }
         if (attributeType.sup && typeof attributeType.sup === "string") {
           const reservedKeywords = ["EQUALITY", "ORDERING", "SUBSTR", "SYNTAX", "SINGLE-VALUE", "COLLECTIVE", "NO-USER-MODIFICATION", "USAGE"];
@@ -8011,6 +8043,13 @@ class RFC4512Parser {
         if (!attributeType.sup && !attributeType.syntax) {
           throw new RFC4512ParserError("AttributeType must have either SUP (superior type) or SYNTAX defined", "ATTRIBUTETYPE_ERROR" /* ATTRIBUTETYPE_ERROR */, schemaDefinition, { context: "RFC 4512 Section 4.1.2 - AttributeType must inherit from superior or define syntax" });
         }
+        if (attributeType.syntax && !this._options.relaxedMode) {
+          const syntaxOid = attributeType.syntax.oid;
+          const standardOidPattern = /^[0-9]+(\.[0-9]+)*$/;
+          if (!standardOidPattern.test(syntaxOid)) {
+            throw new RFC4512ParserError(`Invalid SYNTAX OID format: ${syntaxOid}. In strict mode, SYNTAX must use standard numeric OID format (e.g., '1.3.6.1.4.1.1466.115.121.1.15'). Use relaxedMode: true to support OpenLDAP syntax names.`, "INVALID_FIELD" /* INVALID_FIELD */, schemaDefinition, { context: `RFC 4512 - SYNTAX validation (relaxedMode: ${this._options.relaxedMode})` });
+          }
+        }
         const validAttributeTypeFields = [
           "type",
           "oid",
@@ -8024,7 +8063,8 @@ class RFC4512Parser {
           "singleValue",
           "collective",
           "noUserModification",
-          "usage"
+          "usage",
+          "extensions"
         ];
         for (const key of Object.keys(attributeType)) {
           if (!validAttributeTypeFields.includes(key)) {
@@ -8073,12 +8113,15 @@ class RFC4512Parser {
       return null;
     }
   }
+  get options() {
+    return { ...this._options };
+  }
 }
 var rfc4512_parser_default = RFC4512Parser;
 
 // src/functions/parse-schema.function.ts
-function parseSchema(schemaDefinition, options2) {
-  const parser = new rfc4512_parser_default(options2);
+function parseSchema(schemaDefinition, options2, pegOptions) {
+  const parser = new rfc4512_parser_default(options2, pegOptions);
   return parser.parseSchema(schemaDefinition);
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-software-compagny/parser_ldap_rfc4512",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A TypeScript parser for LDAP schema definitions based on RFC 4512, using PEG.js grammar",
   "repository": "https://github.com/The-Software-Compagny/parser_ldap_rfc4512.git",
   "author": "tacxou <12997062+tacxou@users.noreply.github.com> (https://github.com/tacxou)",
@@ -26,9 +26,7 @@
     "postbuild": "cpr README.md dist/README.md && cpr LICENSE dist/LICENSE && cpr package.json dist/package.json",
     "test": "bun test",
     "test:watch": "bun test --watch",
-    "test:cli": "bun test test/cli.test.ts",
-    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\""
+    "test:cli": "bun test test/cli.test.ts"
   },
   "devDependencies": {
     "@types/bun": "latest",