cognova 0.2.6 → 0.2.8

package/.output/server/node_modules/undici/lib/mock/mock-agent.js

@@ -1,160 +0,0 @@
-'use strict'
-
-const { kClients } = require('../core/symbols')
-const Agent = require('../dispatcher/agent')
-const {
-  kAgent,
-  kMockAgentSet,
-  kMockAgentGet,
-  kDispatches,
-  kIsMockActive,
-  kNetConnect,
-  kGetNetConnect,
-  kOptions,
-  kFactory
-} = require('./mock-symbols')
-const MockClient = require('./mock-client')
-const MockPool = require('./mock-pool')
-const { matchValue, buildMockOptions } = require('./mock-utils')
-const { InvalidArgumentError, UndiciError } = require('../core/errors')
-const Dispatcher = require('../dispatcher/dispatcher')
-const Pluralizer = require('./pluralizer')
-const PendingInterceptorsFormatter = require('./pending-interceptors-formatter')
-
-class MockAgent extends Dispatcher {
-  constructor (opts) {
-    super(opts)
-
-    this[kNetConnect] = true
-    this[kIsMockActive] = true
-
-    // Instantiate Agent and encapsulate
-    if ((opts?.agent && typeof opts.agent.dispatch !== 'function')) {
-      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
-    }
-    const agent = opts?.agent ? opts.agent : new Agent(opts)
-    this[kAgent] = agent
-
-    this[kClients] = agent[kClients]
-    this[kOptions] = buildMockOptions(opts)
-  }
-
-  get (origin) {
-    let dispatcher = this[kMockAgentGet](origin)
-
-    if (!dispatcher) {
-      dispatcher = this[kFactory](origin)
-      this[kMockAgentSet](origin, dispatcher)
-    }
-    return dispatcher
-  }
-
-  dispatch (opts, handler) {
-    // Call MockAgent.get to perform additional setup before dispatching as normal
-    this.get(opts.origin)
-    return this[kAgent].dispatch(opts, handler)
-  }
-
-  async close () {
-    await this[kAgent].close()
-    this[kClients].clear()
-  }
-
-  deactivate () {
-    this[kIsMockActive] = false
-  }
-
-  activate () {
-    this[kIsMockActive] = true
-  }
-
-  enableNetConnect (matcher) {
-    if (typeof matcher === 'string' || typeof matcher === 'function' || matcher instanceof RegExp) {
-      if (Array.isArray(this[kNetConnect])) {
-        this[kNetConnect].push(matcher)
-      } else {
-        this[kNetConnect] = [matcher]
-      }
-    } else if (typeof matcher === 'undefined') {
-      this[kNetConnect] = true
-    } else {
-      throw new InvalidArgumentError('Unsupported matcher. Must be one of String|Function|RegExp.')
-    }
-  }
-
-  disableNetConnect () {
-    this[kNetConnect] = false
-  }
-
-  // This is required to bypass issues caused by using global symbols - see:
-  // https://github.com/nodejs/undici/issues/1447
-  get isMockActive () {
-    return this[kIsMockActive]
-  }
-
-  [kMockAgentSet] (origin, dispatcher) {
-    this[kClients].set(origin, dispatcher)
-  }
-
-  [kFactory] (origin) {
-    const mockOptions = Object.assign({ agent: this }, this[kOptions])
-    return this[kOptions] && this[kOptions].connections === 1
-      ? new MockClient(origin, mockOptions)
-      : new MockPool(origin, mockOptions)
-  }
-
-  [kMockAgentGet] (origin) {
-    // First check if we can immediately find it
-    const client = this[kClients].get(origin)
-    if (client) {
-      return client
-    }
-
-    // If the origin is not a string create a dummy parent pool and return to user
-    if (typeof origin !== 'string') {
-      const dispatcher = this[kFactory]('http://localhost:9999')
-      this[kMockAgentSet](origin, dispatcher)
-      return dispatcher
-    }
-
-    // If we match, create a pool and assign the same dispatches
-    for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) {
-      if (nonExplicitDispatcher && typeof keyMatcher !== 'string' && matchValue(keyMatcher, origin)) {
-        const dispatcher = this[kFactory](origin)
-        this[kMockAgentSet](origin, dispatcher)
-        dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]
-        return dispatcher
-      }
-    }
-  }
-
-  [kGetNetConnect] () {
-    return this[kNetConnect]
-  }
-
-  pendingInterceptors () {
-    const mockAgentClients = this[kClients]
-
-    return Array.from(mockAgentClients.entries())
-      .flatMap(([origin, scope]) => scope[kDispatches].map(dispatch => ({ ...dispatch, origin })))
-      .filter(({ pending }) => pending)
-  }
-
-  assertNoPendingInterceptors ({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
-    const pending = this.pendingInterceptors()
-
-    if (pending.length === 0) {
-      return
-    }
-
-    const pluralizer = new Pluralizer('interceptor', 'interceptors').pluralize(pending.length)
-
-    throw new UndiciError(`
-${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:
-
-${pendingInterceptorsFormatter.format(pending)}
-`.trim())
-  }
-}
-
-module.exports = MockAgent

package/.output/server/node_modules/undici/lib/mock/mock-client.js

@@ -1,59 +0,0 @@
-'use strict'
-
-const { promisify } = require('node:util')
-const Client = require('../dispatcher/client')
-const { buildMockDispatch } = require('./mock-utils')
-const {
-  kDispatches,
-  kMockAgent,
-  kClose,
-  kOriginalClose,
-  kOrigin,
-  kOriginalDispatch,
-  kConnected
-} = require('./mock-symbols')
-const { MockInterceptor } = require('./mock-interceptor')
-const Symbols = require('../core/symbols')
-const { InvalidArgumentError } = require('../core/errors')
-
-/**
- * MockClient provides an API that extends the Client to influence the mockDispatches.
- */
-class MockClient extends Client {
-  constructor (origin, opts) {
-    super(origin, opts)
-
-    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
-      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
-    }
-
-    this[kMockAgent] = opts.agent
-    this[kOrigin] = origin
-    this[kDispatches] = []
-    this[kConnected] = 1
-    this[kOriginalDispatch] = this.dispatch
-    this[kOriginalClose] = this.close.bind(this)
-
-    this.dispatch = buildMockDispatch.call(this)
-    this.close = this[kClose]
-  }
-
-  get [Symbols.kConnected] () {
-    return this[kConnected]
-  }
-
-  /**
-   * Sets up the base interceptor for mocking replies from undici.
-   */
-  intercept (opts) {
-    return new MockInterceptor(opts, this[kDispatches])
-  }
-
-  async [kClose] () {
-    await promisify(this[kOriginalClose])()
-    this[kConnected] = 0
-    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
-  }
-}
-
-module.exports = MockClient

package/.output/server/node_modules/undici/lib/mock/mock-errors.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { UndiciError } = require('../core/errors')
-
-class MockNotMatchedError extends UndiciError {
-  constructor (message) {
-    super(message)
-    Error.captureStackTrace(this, MockNotMatchedError)
-    this.name = 'MockNotMatchedError'
-    this.message = message || 'The request does not match any registered mock dispatches'
-    this.code = 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
-  }
-}
-
-module.exports = {
-  MockNotMatchedError
-}

package/.output/server/node_modules/undici/lib/mock/mock-interceptor.js

@@ -1,207 +0,0 @@
-'use strict'
-
-const { getResponseData, buildKey, addMockDispatch } = require('./mock-utils')
-const {
-  kDispatches,
-  kDispatchKey,
-  kDefaultHeaders,
-  kDefaultTrailers,
-  kContentLength,
-  kMockDispatch
-} = require('./mock-symbols')
-const { InvalidArgumentError } = require('../core/errors')
-const { buildURL } = require('../core/util')
-
-/**
- * Defines the scope API for an interceptor reply
- */
-class MockScope {
-  constructor (mockDispatch) {
-    this[kMockDispatch] = mockDispatch
-  }
-
-  /**
-   * Delay a reply by a set amount in ms.
-   */
-  delay (waitInMs) {
-    if (typeof waitInMs !== 'number' || !Number.isInteger(waitInMs) || waitInMs <= 0) {
-      throw new InvalidArgumentError('waitInMs must be a valid integer > 0')
-    }
-
-    this[kMockDispatch].delay = waitInMs
-    return this
-  }
-
-  /**
-   * For a defined reply, never mark as consumed.
-   */
-  persist () {
-    this[kMockDispatch].persist = true
-    return this
-  }
-
-  /**
-   * Allow one to define a reply for a set amount of matching requests.
-   */
-  times (repeatTimes) {
-    if (typeof repeatTimes !== 'number' || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
-      throw new InvalidArgumentError('repeatTimes must be a valid integer > 0')
-    }
-
-    this[kMockDispatch].times = repeatTimes
-    return this
-  }
-}
-
-/**
- * Defines an interceptor for a Mock
- */
-class MockInterceptor {
-  constructor (opts, mockDispatches) {
-    if (typeof opts !== 'object') {
-      throw new InvalidArgumentError('opts must be an object')
-    }
-    if (typeof opts.path === 'undefined') {
-      throw new InvalidArgumentError('opts.path must be defined')
-    }
-    if (typeof opts.method === 'undefined') {
-      opts.method = 'GET'
-    }
-    // See https://github.com/nodejs/undici/issues/1245
-    // As per RFC 3986, clients are not supposed to send URI
-    // fragments to servers when they retrieve a document,
-    if (typeof opts.path === 'string') {
-      if (opts.query) {
-        opts.path = buildURL(opts.path, opts.query)
-      } else {
-        // Matches https://github.com/nodejs/undici/blob/main/lib/web/fetch/index.js#L1811
-        const parsedURL = new URL(opts.path, 'data://')
-        opts.path = parsedURL.pathname + parsedURL.search
-      }
-    }
-    if (typeof opts.method === 'string') {
-      opts.method = opts.method.toUpperCase()
-    }
-
-    this[kDispatchKey] = buildKey(opts)
-    this[kDispatches] = mockDispatches
-    this[kDefaultHeaders] = {}
-    this[kDefaultTrailers] = {}
-    this[kContentLength] = false
-  }
-
-  createMockScopeDispatchData ({ statusCode, data, responseOptions }) {
-    const responseData = getResponseData(data)
-    const contentLength = this[kContentLength] ? { 'content-length': responseData.length } : {}
-    const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }
-    const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }
-
-    return { statusCode, data, headers, trailers }
-  }
-
-  validateReplyParameters (replyParameters) {
-    if (typeof replyParameters.statusCode === 'undefined') {
-      throw new InvalidArgumentError('statusCode must be defined')
-    }
-    if (typeof replyParameters.responseOptions !== 'object' || replyParameters.responseOptions === null) {
-      throw new InvalidArgumentError('responseOptions must be an object')
-    }
-  }
-
-  /**
-   * Mock an undici request with a defined reply.
-   */
-  reply (replyOptionsCallbackOrStatusCode) {
-    // Values of reply aren't available right now as they
-    // can only be available when the reply callback is invoked.
-    if (typeof replyOptionsCallbackOrStatusCode === 'function') {
-      // We'll first wrap the provided callback in another function,
-      // this function will properly resolve the data from the callback
-      // when invoked.
-      const wrappedDefaultsCallback = (opts) => {
-        // Our reply options callback contains the parameter for statusCode, data and options.
-        const resolvedData = replyOptionsCallbackOrStatusCode(opts)
-
-        // Check if it is in the right format
-        if (typeof resolvedData !== 'object' || resolvedData === null) {
-          throw new InvalidArgumentError('reply options callback must return an object')
-        }
-
-        const replyParameters = { data: '', responseOptions: {}, ...resolvedData }
-        this.validateReplyParameters(replyParameters)
-        // Since the values can be obtained immediately we return them
-        // from this higher order function that will be resolved later.
-        return {
-          ...this.createMockScopeDispatchData(replyParameters)
-        }
-      }
-
-      // Add usual dispatch data, but this time set the data parameter to function that will eventually provide data.
-      const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback)
-      return new MockScope(newMockDispatch)
-    }
-
-    // We can have either one or three parameters, if we get here,
-    // we should have 1-3 parameters. So we spread the arguments of
-    // this function to obtain the parameters, since replyData will always
-    // just be the statusCode.
-    const replyParameters = {
-      statusCode: replyOptionsCallbackOrStatusCode,
-      data: arguments[1] === undefined ? '' : arguments[1],
-      responseOptions: arguments[2] === undefined ? {} : arguments[2]
-    }
-    this.validateReplyParameters(replyParameters)
-
-    // Send in-already provided data like usual
-    const dispatchData = this.createMockScopeDispatchData(replyParameters)
-    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData)
-    return new MockScope(newMockDispatch)
-  }
-
-  /**
-   * Mock an undici request with a defined error.
-   */
-  replyWithError (error) {
-    if (typeof error === 'undefined') {
-      throw new InvalidArgumentError('error must be defined')
-    }
-
-    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error })
-    return new MockScope(newMockDispatch)
-  }
-
-  /**
-   * Set default reply headers on the interceptor for subsequent replies
-   */
-  defaultReplyHeaders (headers) {
-    if (typeof headers === 'undefined') {
-      throw new InvalidArgumentError('headers must be defined')
-    }
-
-    this[kDefaultHeaders] = headers
-    return this
-  }
-
-  /**
-   * Set default reply trailers on the interceptor for subsequent replies
-   */
-  defaultReplyTrailers (trailers) {
-    if (typeof trailers === 'undefined') {
-      throw new InvalidArgumentError('trailers must be defined')
-    }
-
-    this[kDefaultTrailers] = trailers
-    return this
-  }
-
-  /**
-   * Set reply content length header for replies on the interceptor
-   */
-  replyContentLength () {
-    this[kContentLength] = true
-    return this
-  }
-}
-
-module.exports.MockInterceptor = MockInterceptor
-module.exports.MockScope = MockScope

package/.output/server/node_modules/undici/lib/mock/mock-pool.js

@@ -1,59 +0,0 @@
-'use strict'
-
-const { promisify } = require('node:util')
-const Pool = require('../dispatcher/pool')
-const { buildMockDispatch } = require('./mock-utils')
-const {
-  kDispatches,
-  kMockAgent,
-  kClose,
-  kOriginalClose,
-  kOrigin,
-  kOriginalDispatch,
-  kConnected
-} = require('./mock-symbols')
-const { MockInterceptor } = require('./mock-interceptor')
-const Symbols = require('../core/symbols')
-const { InvalidArgumentError } = require('../core/errors')
-
-/**
- * MockPool provides an API that extends the Pool to influence the mockDispatches.
- */
-class MockPool extends Pool {
-  constructor (origin, opts) {
-    super(origin, opts)
-
-    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
-      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
-    }
-
-    this[kMockAgent] = opts.agent
-    this[kOrigin] = origin
-    this[kDispatches] = []
-    this[kConnected] = 1
-    this[kOriginalDispatch] = this.dispatch
-    this[kOriginalClose] = this.close.bind(this)
-
-    this.dispatch = buildMockDispatch.call(this)
-    this.close = this[kClose]
-  }
-
-  get [Symbols.kConnected] () {
-    return this[kConnected]
-  }
-
-  /**
-   * Sets up the base interceptor for mocking replies from undici.
-   */
-  intercept (opts) {
-    return new MockInterceptor(opts, this[kDispatches])
-  }
-
-  async [kClose] () {
-    await promisify(this[kOriginalClose])()
-    this[kConnected] = 0
-    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
-  }
-}
-
-module.exports = MockPool

package/.output/server/node_modules/undici/lib/mock/mock-symbols.js

@@ -1,23 +0,0 @@
-'use strict'
-
-module.exports = {
-  kAgent: Symbol('agent'),
-  kOptions: Symbol('options'),
-  kFactory: Symbol('factory'),
-  kDispatches: Symbol('dispatches'),
-  kDispatchKey: Symbol('dispatch key'),
-  kDefaultHeaders: Symbol('default headers'),
-  kDefaultTrailers: Symbol('default trailers'),
-  kContentLength: Symbol('content length'),
-  kMockAgent: Symbol('mock agent'),
-  kMockAgentSet: Symbol('mock agent set'),
-  kMockAgentGet: Symbol('mock agent get'),
-  kMockDispatch: Symbol('mock dispatch'),
-  kClose: Symbol('close'),
-  kOriginalClose: Symbol('original agent close'),
-  kOrigin: Symbol('origin'),
-  kIsMockActive: Symbol('is mock active'),
-  kNetConnect: Symbol('net connect'),
-  kGetNetConnect: Symbol('get net connect'),
-  kConnected: Symbol('connected')
-}