@withbuddi/buddi 0.1.0-pre.37 → 0.1.0-pre.38

package/node_modules/pino/test/types/{pino.tst.ts → pino.test-d.ts}

@@ -1,10 +1,8 @@
-import { expect } from 'tstyche'
-
-import { IncomingMessage, ServerResponse } from 'node:http'
-import { Socket } from 'node:net'
+import { IncomingMessage, ServerResponse } from 'http'
 import { mock } from 'node:test'
-
-import pino, { type LogFn, type LoggerOptions } from '../../pino.js'
+import { Socket } from 'net'
+import { expectError, expectType } from 'tsd'
+import pino, { LogFn, LoggerOptions } from '../../'
 import Logger = pino.Logger
 
 const log = pino()
@@ -37,7 +35,7 @@ info('The object is %o', { a: 1, b: '2' })
 info('The json is %j', { a: 1, b: '2' })
 info('The object is %O', { a: 1, b: '2' })
 info('The answer is %d and the question is %s with %o', 42, 'unknown', {
-  correct: 'order'
+  correct: 'order',
 })
 info('Missing placeholder is fine %s')
 
@@ -78,18 +76,16 @@ info('Symbol %o', Symbol('test'))
 info('String %o', 'hello')
 
 // placeholder messages type errors
-expect(info).type.not.toBeCallableWith('The answer is %d', 'not a number')
-expect(info).type.not.toBeCallableWith(
-  'The answer is %d and the question is %s with %o',
-  'unknown',
-  { incorrect: 'order' },
-  42
-)
-expect(info).type.not.toBeCallableWith(
-  'Extra message %s',
-  'after placeholder',
-  'not allowed'
+expectError(info('The answer is %d', 'not a number'))
+expectError(
+  info(
+    'The answer is %d and the question is %s with %o',
+    'unknown',
+    { incorrect: 'order' },
+    42
+  )
 )
+expectError(info('Extra message %s', 'after placeholder', 'not allowed'))
 
 // object types with messages
 info({ obj: 42 }, 'hello world')
@@ -98,23 +94,18 @@ info({ obj: { aa: 'bbb' } }, 'another')
 info({ a: 1, b: '2' }, 'hello world with %s', 'extra data')
 
 // Extra message after placeholder
-expect(info).type.not.toBeCallableWith(
-  { a: 1, b: '2' },
-  'hello world with %d',
-  2,
-  'extra'
-)
+expectError(info({ a: 1, b: '2' }, 'hello world with %d', 2, 'extra'))
 
 // metadata with messages type passes, because of custom toString method
 // We can't detect if the object has a custom toString method that returns a string
 info({ a: 1, b: '2' }, 'hello world with %s', {})
 
 // metadata after message
-expect(info).type.not.toBeCallableWith('message', { a: 1, b: '2' })
+expectError(info('message', { a: 1, b: '2' }))
 
 // multiple strings without placeholder
-expect(info).type.not.toBeCallableWith('string1', 'string2')
-expect(info).type.not.toBeCallableWith('string1', 'string2', 'string3')
+expectError(info('string1', 'string2'))
+expectError(info('string1', 'string2', 'string3'))
 
 setImmediate(info, 'after setImmediate')
 error(new Error('an error'))
@@ -122,7 +113,7 @@ error(new Error('an error'))
 const writeSym = pino.symbols.writeSym
 
 const testUniqSymbol = {
-  [pino.symbols.needsMetadataGsym]: true
+  [pino.symbols.needsMetadataGsym]: true,
 }[pino.symbols.needsMetadataGsym]
 
 const log2: pino.Logger = pino({
@@ -131,81 +122,83 @@ const log2: pino.Logger = pino({
   serializers: {
     req: pino.stdSerializers.req,
     res: pino.stdSerializers.res,
-    err: pino.stdSerializers.err
-  }
+    err: pino.stdSerializers.err,
+  },
 })
 
 pino({
-  write (o) {}
+  write (o) {},
 })
 
 pino({
   mixin () {
     return { customName: 'unknown', customId: 111 }
-  }
+  },
 })
 
 pino({
-  mixin: () => ({ customName: 'unknown', customId: 111 })
+  mixin: () => ({ customName: 'unknown', customId: 111 }),
 })
 
 pino({
-  mixin: (context: object) => ({ customName: 'unknown', customId: 111 })
+  mixin: (context: object) => ({ customName: 'unknown', customId: 111 }),
 })
 
 pino({
   mixin: (context: object, level: number) => ({
     customName: 'unknown',
-    customId: 111
-  })
+    customId: 111,
+  }),
 })
 
 pino({
-  redact: { paths: [], censor: 'SECRET' }
+  redact: { paths: [], censor: 'SECRET' },
 })
 
 pino({
-  redact: { paths: [], censor: () => 'SECRET' }
+  redact: { paths: [], censor: () => 'SECRET' },
 })
 
 pino({
-  redact: { paths: [], censor: (value) => value }
+  redact: { paths: [], censor: (value) => value },
 })
 
 pino({
-  redact: { paths: [], censor: (value, path) => path.join() }
+  redact: { paths: [], censor: (value, path) => path.join() },
 })
 
 pino({
   redact: {
     paths: [],
-    censor: (value): string => 'SECRET'
-  }
+    censor: (value): string => 'SECRET',
+  },
 })
 
-expect(pino).type.not.toBeCallableWith({
-  redact: { paths: [], censor: (value: string) => value }
-})
+expectError(
+  pino({
+    redact: { paths: [], censor: (value: string) => value },
+  })
+)
 
 pino({
-  depthLimit: 1
+  depthLimit: 1,
 })
 
 pino({
-  edgeLimit: 1
+  edgeLimit: 1,
 })
 
 pino({
   browser: {
-    write (o) {}
-  }
+    write (o) {},
+  },
 })
 
 pino({
   browser: {
     write: {
       info (o) {},
-      error (o) {}
+      error (o) {},
     },
     serialize: true,
     asObject: true,
@@ -217,16 +210,16 @@ pino({
         logEvent.level
         logEvent.ts
         logEvent.messages
-      }
+      },
     },
-    disabled: false
-  }
+    disabled: false,
+  },
 })
 
 pino({
   browser: {
-    asObjectBindingsOnly: true
-  }
+    asObjectBindingsOnly: true,
+  },
 })
 
 pino({}, undefined)
@@ -234,7 +227,7 @@ pino({}, undefined)
 pino({ base: null })
 if ('pino' in log) console.log(`pino version: ${log.pino}`)
 
-expect(log.flush()).type.toBe<void>()
+expectType<void>(log.flush())
 log.flush((err?: Error) => undefined)
 log.child({ a: 'property' }).info('hello child!')
 log.level = 'error'
@@ -249,7 +242,7 @@ child.bindings()
 const customSerializers = {
   test () {
     return 'this is my serializer'
-  }
+  },
 }
 pino()
   .child({}, { serializers: customSerializers })
@@ -259,20 +252,20 @@ const childChild = child2.child({ baby: true })
 const childRedacted = pino().child({}, { redact: ['path'] })
 childRedacted.info({
   msg: 'logged with redacted properties',
-  path: 'Not shown'
+  path: 'Not shown',
 })
 const childAnotherRedacted = pino().child(
   {},
   {
     redact: {
       paths: ['anotherPath'],
-      censor: 'Not the log you\re looking for'
-    }
+      censor: 'Not the log you\re looking for',
+    },
   }
 )
 childAnotherRedacted.info({
   msg: 'another logged with redacted properties',
-  anotherPath: 'Not shown'
+  anotherPath: 'Not shown',
 })
 
 log.level = 'info'
@@ -302,49 +295,49 @@ log.level === 'info'
 const isEnabled: boolean = log.isLevelEnabled('info')
 
 const redacted = pino({
-  redact: ['path']
+  redact: ['path'],
 })
 
 redacted.info({
   msg: 'logged with redacted properties',
-  path: 'Not shown'
+  path: 'Not shown',
 })
 
 const anotherRedacted = pino({
   redact: {
     paths: ['anotherPath'],
-    censor: 'Not the log you\re looking for'
-  }
+    censor: 'Not the log you\re looking for',
+  },
 })
 
 anotherRedacted.info({
   msg: 'another logged with redacted properties',
-  anotherPath: 'Not shown'
+  anotherPath: 'Not shown',
 })
 
 const withTimeFn = pino({
-  timestamp: pino.stdTimeFunctions.isoTime
+  timestamp: pino.stdTimeFunctions.isoTime,
 })
 
 const withRFC3339TimeFn = pino({
-  timestamp: pino.stdTimeFunctions.isoTimeNano
+  timestamp: pino.stdTimeFunctions.isoTimeNano,
 })
 
 const withNestedKey = pino({
-  nestedKey: 'payload'
+  nestedKey: 'payload',
 })
 
 const withHooks = pino({
   hooks: {
     logMethod (args, method, level) {
-      expect(this).type.toBe<pino.Logger>()
+      expectType<pino.Logger>(this)
       return method.apply(this, args)
     },
     streamWrite (s) {
-      expect(s).type.toBe<string>()
+      expectType<string>(s)
       return s.replaceAll('secret-key', 'xxx')
-    }
-  }
+    },
+  },
 })
 
 // Properties/types imported from pino-std-serializers
@@ -390,7 +383,7 @@ const destinationViaNumFileDescriptor = pino.destination(2)
 const destinationViaStream = pino.destination(process.stdout)
 const destinationViaOptionsObject = pino.destination({
   dest: '/log/path',
-  sync: false
+  sync: false,
 })
 
 pino(destinationViaDefaultArgs)
@@ -416,14 +409,14 @@ interface StrictShape {
 }
 
 info<StrictShape>({
-  activity: 'Required property'
+  activity: 'Required property',
 })
 
 const logLine: pino.LogDescriptor = {
   level: 20,
   msg: 'A log message',
   time: new Date().getTime(),
-  aCustomProperty: true
+  aCustomProperty: true,
 }
 
 interface CustomLogger extends pino.Logger {
@@ -449,12 +442,12 @@ const customBaseLogger: CustomBaseLogger = {
   child () {
     return this
   },
-  msgPrefix: 'prefix'
+  msgPrefix: 'prefix',
 }
 
 // custom levels
 const log3 = pino({ customLevels: { myLevel: 100 } })
-expect(log3).type.not.toHaveProperty('log')
+expectError(log3.log())
 log3.level = 'myLevel'
 log3.myLevel('')
 log3.child({}).myLevel('')
@@ -477,15 +470,15 @@ cclog3.childLevel('')
 cclog3.childLevel2('')
 
 const ccclog3 = clog3.child({})
-expect(ccclog3).type.not.toHaveProperty('nonLevel')
+expectError(ccclog3.nonLevel(''))
 
 const withChildCallback = pino({
-  onChild: (child: Logger) => {}
+  onChild: (child: Logger) => {},
 })
 withChildCallback.onChild = (child: Logger) => {}
 
 pino({
-  crlf: true
+  crlf: true,
 })
 
 const customLevels = { foo: 99, bar: 42 }
@@ -502,17 +495,21 @@ const customLevelChildLogger = customLevelLogger.child({ name: 'child' })
 fn(customLevelChildLogger) // missing foo typing
 
 // unknown option
-expect(pino).type.not.toBeCallableWith({
-  hello: 'world'
-})
+expectError(
+  pino({
+    hello: 'world',
+  })
+)
 
 // unknown option
-expect(pino).type.not.toBeCallableWith({
-  hello: 'world',
-  customLevels: {
-    log: 30
-  }
-})
+expectError(
+  pino({
+    hello: 'world',
+    customLevels: {
+      log: 30,
+    },
+  })
+)
 
 function dangerous () {
   throw Error('foo')
@@ -532,15 +529,15 @@ try {
 
 const bLogger = pino({
   customLevels: {
-    log: 5
+    log: 5,
   },
   level: 'log',
   transport: {
     target: 'pino-pretty',
     options: {
-      colorize: true
-    }
-  }
+      colorize: true,
+    },
+  },
 })
 
 // Test that we can properly extract parameters from the log fn type
@@ -549,13 +546,13 @@ const [param1, param2, param3, param4]: LogParam = [
   { multiple: 'params' },
   'should',
   'be',
-  'accepted'
+  'accepted',
 ]
 
-expect(param1).type.toBe<unknown>()
-expect(param2).type.toBe<string>()
-expect(param3).type.toBe<unknown>()
-expect(param4).type.toBe<unknown>()
+expectType<unknown>(param1)
+expectType<string>(param2)
+expectType<unknown>(param3)
+expectType<unknown>(param4)
 
 const logger = mock.fn<LogFn>()
 logger.mock.calls[0].arguments[1]?.includes('I should be able to get params')
@@ -568,37 +565,37 @@ const hooks: LoggerOptions['hooks'] = {
         return method.apply(this, [
           parameter2,
           parameter1,
-          ...remainingParameters
+          ...remainingParameters,
         ])
       }
       return method.apply(this, [parameter2])
     }
 
     return method.apply(this, parameters)
-  }
+  },
 }
 
-expect(
+expectType<Logger<'log'>>(
   pino({
     customLevels: {
-      log: 5
+      log: 5,
     },
     level: 'log',
     transport: {
       target: 'pino-pretty',
       options: {
-        colorize: true
-      }
-    }
+        colorize: true,
+      },
+    },
   })
-).type.toBe<Logger<'log'>>()
+)
 
 const parentLogger1 = pino(
   {
     customLevels: { myLevel: 90 },
     onChild: (child) => {
       const a = child.myLevel
-    }
+    },
   },
   process.stdout
 )
@@ -608,23 +605,27 @@ parentLogger1.onChild = (child) => {
 
 const childLogger1 = parentLogger1.child({})
 childLogger1.myLevel('')
-expect(childLogger1).type.not.toHaveProperty('doesntExist')
+expectError(childLogger1.doesntExist(''))
 
 const parentLogger2 = pino({}, process.stdin)
-parentLogger2.onChild = (child) => {
-  expect(child).type.not.toHaveProperty('doesntExist')
-}
+expectError(
+  (parentLogger2.onChild = (child) => {
+    const b = child.doesntExist
+  })
+)
 
 const childLogger2 = parentLogger2.child({})
-expect(childLogger2).type.not.toHaveProperty('doesntExist')
-
-pino(
-  {
-    onChild: (child) => {
-      expect(child).type.not.toHaveProperty('doesntExist')
-    }
-  },
-  process.stdout
+expectError(childLogger2.doesntExist)
+
+expectError(
+  pino(
+    {
+      onChild: (child) => {
+        const a = child.doesntExist
+      },
+    },
+    process.stdout
+  )
 )
 
 const pinoWithoutLevelsSorting = pino({})
@@ -632,13 +633,13 @@ const pinoWithDescSortingLevels = pino({ levelComparison: 'DESC' })
 const pinoWithAscSortingLevels = pino({ levelComparison: 'ASC' })
 const pinoWithCustomSortingLevels = pino({ levelComparison: () => false })
 // with wrong level comparison direction
-expect(pino).type.not.toBeCallableWith({ levelComparison: 'SOME' })
+expectError(pino({ levelComparison: 'SOME' }), process.stdout)
 // with wrong level comparison type
-expect(pino).type.not.toBeCallableWith({ levelComparison: 123 })
+expectError(pino({ levelComparison: 123 }), process.stdout)
 // with wrong custom level comparison return type
-expect(pino).type.not.toBeCallableWith({ levelComparison: () => null })
-expect(pino).type.not.toBeCallableWith({ levelComparison: () => 1 })
-expect(pino).type.not.toBeCallableWith({ levelComparison: () => 'string' })
+expectError(pino({ levelComparison: () => null }), process.stdout)
+expectError(pino({ levelComparison: () => 1 }), process.stdout)
+expectError(pino({ levelComparison: () => 'string' }), process.stdout)
 
 const customLevelsOnlyOpts = {
   useOnlyCustomLevels: true,
@@ -646,9 +647,9 @@ const customLevelsOnlyOpts = {
     customDebug: 10,
     info: 20, // to make sure the default names are also available for override
     customNetwork: 30,
-    customError: 40
+    customError: 40,
   },
-  level: 'customDebug'
+  level: 'customDebug',
 } satisfies LoggerOptions
 
 const loggerWithCustomLevelOnly = pino(customLevelsOnlyOpts)
@@ -657,11 +658,11 @@ loggerWithCustomLevelOnly.info('test4')
 loggerWithCustomLevelOnly.customError('test5')
 loggerWithCustomLevelOnly.customNetwork('test6')
 
-expect(loggerWithCustomLevelOnly.fatal).type.toBe<never>()
-expect(loggerWithCustomLevelOnly.error).type.toBe<never>()
-expect(loggerWithCustomLevelOnly.warn).type.toBe<never>()
-expect(loggerWithCustomLevelOnly.debug).type.toBe<never>()
-expect(loggerWithCustomLevelOnly.trace).type.toBe<never>()
+expectError(loggerWithCustomLevelOnly.fatal('test'))
+expectError(loggerWithCustomLevelOnly.error('test'))
+expectError(loggerWithCustomLevelOnly.warn('test'))
+expectError(loggerWithCustomLevelOnly.debug('test'))
+expectError(loggerWithCustomLevelOnly.trace('test'))
 
 // Module extension
 declare module '../../' {
@@ -672,8 +673,9 @@ declare module '../../' {
 }
 
 info({ typeCheckedField: 'bar' })
-expect(info).type.not.toBeCallableWith({ bannedField: 'bar' })
-expect(info).type.not.toBeCallableWith({ typeCheckedField: 123 })
+expectError(info({ bannedField: 'bar' }))
+expectError(info({ typeCheckedField: 123 }))
+
 const someGenericFunction = <T extends string | number | symbol = never>(
   arg: Record<T, unknown>
 ) => {

package/node_modules/pino/test/types/pino.ts

@@ -1,19 +1,12 @@
-import { tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { tmpdir } from 'node:os'
 import pinoPretty from 'pino-pretty'
-
 // Test both default ("Pino") and named ("pino") imports.
-import Pino, {
-  type LoggerOptions,
-  type StreamEntry,
-  pino,
-  multistream,
-  transport
-} from '../../pino.js'
+import Pino, { type LoggerOptions, type StreamEntry, pino, multistream, transport } from '../../pino'
 
 const destination = join(
   tmpdir(),
-  '_' + Math.random().toString(36).slice(2, 9)
+  '_' + Math.random().toString(36).substr(2, 9)
 )
 
 // Single
@@ -31,7 +24,7 @@ loggerDefault.info('test2')
 loggerDefault.flush()
 
 const transport2 = transport({
-  target: 'pino-pretty'
+  target: 'pino-pretty',
 })
 const logger2 = pino(transport2)
 logger2.info('test2')
@@ -63,7 +56,7 @@ const customLevels = {
   customDebug: 1,
   info: 2,
   customNetwork: 3,
-  customError: 4
+  customError: 4,
 }
 
 type CustomLevels = keyof typeof customLevels
@@ -71,7 +64,7 @@ type CustomLevels = keyof typeof customLevels
 const pinoOpts = {
   useOnlyCustomLevels: true,
   customLevels,
-  level: 'customDebug'
+  level: 'customDebug',
 } satisfies LoggerOptions
 
 const multistreamOpts = {
@@ -83,7 +76,7 @@ const streams: StreamEntry<CustomLevels>[] = [
   { level: 'customDebug', stream: pinoPretty() },
   { level: 'info', stream: pinoPretty() },
   { level: 'customNetwork', stream: pinoPretty() },
-  { level: 'customError', stream: pinoPretty() }
+  { level: 'customError', stream: pinoPretty() },
 ]
 
 const loggerCustomLevel = pino(pinoOpts, multistream(streams, multistreamOpts))

package/node_modules/pino/tsconfig.json

@@ -1,14 +1,14 @@
 {
   "compilerOptions": {
-    "target": "es2022",
-    "lib": ["es2022"],
-    "module": "node16",
-    "moduleResolution": "node16",
+    "target": "es6",
+    "lib": [ "es2015", "dom" ],
+    "module": "commonjs",
     "noEmit": true,
     "strict": true,
-    "types": ["node"]
+    "esModuleInterop": true
   },
   "exclude": [
+    "./test/types/*.test-d.ts",
     "./*.d.ts"
   ]
-}
+}