s202226701001/sever-test/node_modules/@ldapjs/dn/lib/dn.js

'use strict'

const warning = require('./deprecations')
const RDN = require('./rdn')
const parseString = require('./utils/parse-string')

/**
 * Implements distinguished name strings as described in
 * https://www.rfc-editor.org/rfc/rfc4514 as an object.
 * This is the primary implementation for parsing and generating DN strings.
 *
 * @example
 * const dn = new DN({rdns: [{cn: 'jdoe', givenName: 'John'}] })
 * dn.toString() // 'cn=jdoe+givenName=John'
 */
class DN {
  #rdns = []

  /**
   * @param {object} input
   * @param {RDN[]} [input.rdns=[]] A set of RDN objects that define the DN.
   * Remember that DNs are in reverse domain order. Thus, the target RDN must
   * be the first item and the top-level RDN the last item.
   *
   * @throws When the provided `rdns` array is invalid.
   */
  constructor ({ rdns = [] } = {}) {
    if (Array.isArray(rdns) === false) {
      throw Error('rdns must be an array')
    }

    const hasNonRdn = rdns.some(
      r => RDN.isRdn(r) === false
    )
    if (hasNonRdn === true) {
      throw Error('rdns must be an array of RDN objects')
    }

    Array.prototype.push.apply(
      this.#rdns,
      rdns.map(r => {
        if (Object.prototype.toString.call(r) === '[object LdapRdn]') {
          return r
        }
        return new RDN(r)
      })
    )
  }

  get [Symbol.toStringTag] () {
    return 'LdapDn'
  }

  /**
   * The number of RDNs that make up the DN.
   *
   * @returns {number}
   */
  get length () {
    return this.#rdns.length
  }

  /**
   * Determine if the current instance is the child of another DN instance or
   * DN string.
   *
   * @param {DN|string} dn
   *
   * @returns {boolean}
   */
  childOf (dn) {
    if (typeof dn === 'string') {
      const parsedDn = DN.fromString(dn)
      return parsedDn.parentOf(this)
    }
    return dn.parentOf(this)
  }

  /**
   * Get a new instance that is a replica of the current instance.
   *
   * @returns {DN}
   */
  clone () {
    return new DN({ rdns: this.#rdns })
  }

  /**
   * Determine if the instance is equal to another DN.
   *
   * @param {DN|string} dn
   *
   * @returns {boolean}
   */
  equals (dn) {
    if (typeof dn === 'string') {
      const parsedDn = DN.fromString(dn)
      return parsedDn.equals(this)
    }

    if (this.length !== dn.length) return false

    for (let i = 0; i < this.length; i += 1) {
      if (this.#rdns[i].equals(dn.rdnAt(i)) === false) {
        return false
      }
    }

    return true
  }

  /**
   * @deprecated Use .toString() instead.
   *
   * @returns {string}
   */
  format () {
    warning.emit('LDAP_DN_DEP_002')
    return this.toString()
  }

  /**
   * Determine if the instance has any RDNs defined.
   *
   * @returns {boolean}
   */
  isEmpty () {
    return this.#rdns.length === 0
  }

  /**
   * Get a DN representation of the parent of this instance.
   *
   * @returns {DN|undefined}
   */
  parent () {
    if (this.length === 0) return undefined
    const save = this.shift()
    const dn = new DN({ rdns: this.#rdns })
    this.unshift(save)
    return dn
  }

  /**
   * Determine if the instance is the parent of a given DN instance or DN
   * string.
   *
   * @param {DN|string} dn
   *
   * @returns {boolean}
   */
  parentOf (dn) {
    if (typeof dn === 'string') {
      const parsedDn = DN.fromString(dn)
      return this.parentOf(parsedDn)
    }

    if (this.length >= dn.length) {
      // If we have more RDNs in our set then we must be a descendent at least.
      return false
    }

    const numberOfElementsDifferent = dn.length - this.length
    for (let i = this.length - 1; i >= 0; i -= 1) {
      const myRdn = this.#rdns[i]
      const theirRdn = dn.rdnAt(i + numberOfElementsDifferent)
      if (myRdn.equals(theirRdn) === false) {
        return false
      }
    }

    return true
  }

  /**
   * Removes the last RDN from the list and returns it. This alters the
   * instance.
   *
   * @returns {RDN}
   */
  pop () {
    return this.#rdns.pop()
  }

  /**
   * Adds a new RDN to the end of the list (i.e. the "top most" RDN in the
   * directory path) and returns the new RDN count.
   *
   * @param {RDN} rdn
   *
   * @returns {number}
   *
   * @throws When the input is not a valid RDN.
   */
  push (rdn) {
    if (Object.prototype.toString.call(rdn) !== '[object LdapRdn]') {
      throw Error('rdn must be a RDN instance')
    }
    return this.#rdns.push(rdn)
  }

  /**
   * Return the RDN at the provided index in the list of RDNs associated with
   * this instance.
   *
   * @param {number} index
   *
   * @returns {RDN}
   */
  rdnAt (index) {
    return this.#rdns[index]
  }

  /**
   * Reverse the RDNs list such that the first element becomes the last, and
   * the last becomes the first. This is useful when the RDNs were added in the
   * opposite order of how they should have been.
   *
   * This is an in-place operation. The instance is changed as a result of
   * this operation.
   *
   * @returns {DN} The current instance (i.e. this method is chainable).
   */
  reverse () {
    this.#rdns.reverse()
    return this
  }

  /**
   * @deprecated Formatting options are not supported.
   */
  setFormat () {
    warning.emit('LDAP_DN_DEP_004')
  }

  /**
   * Remove the first RDN from the set of RDNs and return it.
   *
   * @returns {RDN}
   */
  shift () {
    return this.#rdns.shift()
  }

  /**
   * Render the DN instance as a spec compliant DN string.
   *
   * @returns {string}
   */
  toString () {
    let result = ''
    for (const rdn of this.#rdns) {
      const rdnString = rdn.toString()
      result += `,${rdnString}`
    }
    return result.substring(1)
  }

  /**
   * Adds an RDN to the beginning of the RDN list and returns the new length.
   *
   * @param {RDN} rdn
   *
   * @returns {number}
   *
   * @throws When the RDN is invalid.
   */
  unshift (rdn) {
    if (Object.prototype.toString.call(rdn) !== '[object LdapRdn]') {
      throw Error('rdn must be a RDN instance')
    }
    return this.#rdns.unshift(rdn)
  }

  /**
   * Determine if an object is an instance of {@link DN} or is at least
   * a DN-like object. It is safer to perform a `toString` check.
   *
   * @example Valid Instance
   * const dn = new DN()
   * DN.isDn(dn) // true
   *
   * @example DN-like Instance
   * let dn = { rdns: [{name: 'cn', value: 'foo'}] }
   * DN.isDn(dn) // true
   *
   * dn = { rdns: [{cn: 'foo', sn: 'bar'}, {dc: 'example'}, {dc: 'com'}]}
   * DN.isDn(dn) // true
   *
   * @example Preferred Check
   * let dn = new DN()
   * Object.prototype.toString.call(dn) === '[object LdapDn]' // true
   *
   * dn = { rdns: [{name: 'cn', value: 'foo'}] }
   * Object.prototype.toString.call(dn) === '[object LdapDn]' // false
   *
   * @param {object} dn
   * @returns {boolean}
   */
  static isDn (dn) {
    if (Object.prototype.toString.call(dn) === '[object LdapDn]') {
      return true
    }
    if (
      Object.prototype.toString.call(dn) !== '[object Object]' ||
      Array.isArray(dn.rdns) === false
    ) {
      return false
    }
    if (dn.rdns.some(dn => RDN.isRdn(dn) === false) === true) {
      return false
    }

    return true
  }

  /**
   * Parses a DN string and returns a new {@link DN} instance.
   *
   * @example
   * const dn = DN.fromString('cn=foo,dc=example,dc=com')
   * DN.isDn(dn) // true
   *
   * @param {string} dnString
   *
   * @returns {DN}
   *
   * @throws If the string is not parseable.
   */
  static fromString (dnString) {
    const rdns = parseString(dnString)
    return new DN({ rdns })
  }
}

module.exports = DN