@wbce/projen-d9 0.0.28 → 0.1.0

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

@@ -0,0 +1,681 @@
+import { expect } from 'tstyche'
+
+import { IncomingMessage, ServerResponse } from 'node:http'
+import { Socket } from 'node:net'
+import { mock } from 'node:test'
+
+import pino, { type LogFn, type LoggerOptions } from '../../pino.js'
+import Logger = pino.Logger
+
+const log = pino()
+const info = log.info
+const error = log.error
+
+info('hello world')
+error('this is at error level')
+
+// primitive types
+info('simple string')
+info(true)
+info(42)
+info(3.14)
+info(null)
+info(undefined)
+
+// object types
+info({ a: 1, b: '2' })
+info(new Error())
+info(new Date())
+info([])
+info(new Map())
+info(new Set())
+
+// placeholder messages
+info('Hello %s', 'world')
+info('The answer is %d', 42)
+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'
+})
+info('Missing placeholder is fine %s')
+
+// %s placeholder supports all primitive types
+info('Boolean %s', true)
+info('Boolean %s', false)
+info('Number %s', 123)
+info('Number %s', 3.14)
+info('BigInt %s', BigInt(123))
+info('Null %s', null)
+info('Undefined %s', undefined)
+info('Symbol %s', Symbol('test'))
+info('String %s', 'hello')
+
+// %s placeholder with multiple primitives
+info('Multiple primitives %s %s %s', true, 42, 'world')
+info(
+  'All primitive types %s %s %s %s %s %s %s',
+  'string',
+  123,
+  true,
+  BigInt(123),
+  null,
+  undefined,
+  Symbol('test')
+)
+declare const errorOrString: string | Error
+info(errorOrString)
+
+// %o placeholder supports primitives too (except undefined)
+info('Boolean %o', true)
+info('Boolean %o', false)
+info('Number %o', 123)
+info('Number %o', 3.14)
+info('BigInt %o', BigInt(123))
+info('Null %o', null)
+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'
+)
+
+// object types with messages
+info({ obj: 42 }, 'hello world')
+info({ obj: 42, b: 2 }, 'hello world')
+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'
+)
+
+// 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' })
+
+// multiple strings without placeholder
+expect(info).type.not.toBeCallableWith('string1', 'string2')
+expect(info).type.not.toBeCallableWith('string1', 'string2', 'string3')
+
+setImmediate(info, 'after setImmediate')
+error(new Error('an error'))
+
+const writeSym = pino.symbols.writeSym
+
+const testUniqSymbol = {
+  [pino.symbols.needsMetadataGsym]: true
+}[pino.symbols.needsMetadataGsym]
+
+const log2: pino.Logger = pino({
+  name: 'myapp',
+  safe: true,
+  serializers: {
+    req: pino.stdSerializers.req,
+    res: pino.stdSerializers.res,
+    err: pino.stdSerializers.err
+  }
+})
+
+pino({
+  write (o) {}
+})
+
+pino({
+  mixin () {
+    return { customName: 'unknown', customId: 111 }
+  }
+})
+
+pino({
+  mixin: () => ({ customName: 'unknown', customId: 111 })
+})
+
+pino({
+  mixin: (context: object) => ({ customName: 'unknown', customId: 111 })
+})
+
+pino({
+  mixin: (context: object, level: number) => ({
+    customName: 'unknown',
+    customId: 111
+  })
+})
+
+pino({
+  redact: { paths: [], censor: 'SECRET' }
+})
+
+pino({
+  redact: { paths: [], censor: () => 'SECRET' }
+})
+
+pino({
+  redact: { paths: [], censor: (value) => value }
+})
+
+pino({
+  redact: { paths: [], censor: (value, path) => path.join() }
+})
+
+pino({
+  redact: {
+    paths: [],
+    censor: (value): string => 'SECRET'
+  }
+})
+
+expect(pino).type.not.toBeCallableWith({
+  redact: { paths: [], censor: (value: string) => value }
+})
+
+pino({
+  depthLimit: 1
+})
+
+pino({
+  edgeLimit: 1
+})
+
+pino({
+  browser: {
+    write (o) {}
+  }
+})
+
+pino({
+  browser: {
+    write: {
+      info (o) {},
+      error (o) {}
+    },
+    serialize: true,
+    asObject: true,
+    transmit: {
+      level: 'fatal',
+      send: (level, logEvent) => {
+        level
+        logEvent.bindings
+        logEvent.level
+        logEvent.ts
+        logEvent.messages
+      }
+    },
+    disabled: false
+  }
+})
+
+pino({
+  browser: {
+    asObjectBindingsOnly: true
+  }
+})
+
+pino({}, undefined)
+
+pino({ base: null })
+if ('pino' in log) console.log(`pino version: ${log.pino}`)
+
+expect(log.flush()).type.toBe<void>()
+log.flush((err?: Error) => undefined)
+log.child({ a: 'property' }).info('hello child!')
+log.level = 'error'
+log.info('nope')
+const child = log.child({ foo: 'bar' })
+child.info('nope again')
+child.level = 'info'
+child.info('hooray')
+log.info('nope nope nope')
+log.child({ foo: 'bar' }, { level: 'debug' }).debug('debug!')
+child.bindings()
+const customSerializers = {
+  test () {
+    return 'this is my serializer'
+  }
+}
+pino()
+  .child({}, { serializers: customSerializers })
+  .info({ test: 'should not show up' })
+const child2 = log.child({ father: true })
+const childChild = child2.child({ baby: true })
+const childRedacted = pino().child({}, { redact: ['path'] })
+childRedacted.info({
+  msg: 'logged with redacted properties',
+  path: 'Not shown'
+})
+const childAnotherRedacted = pino().child(
+  {},
+  {
+    redact: {
+      paths: ['anotherPath'],
+      censor: 'Not the log you\re looking for'
+    }
+  }
+)
+childAnotherRedacted.info({
+  msg: 'another logged with redacted properties',
+  anotherPath: 'Not shown'
+})
+
+log.level = 'info'
+if (log.levelVal === 30) {
+  console.log('logger level is `info`')
+}
+
+const listener = (lvl: any, val: any, prevLvl: any, prevVal: any) => {
+  console.log(lvl, val, prevLvl, prevVal)
+}
+log.on('level-change', (lvl, val, prevLvl, prevVal, logger) => {
+  console.log(lvl, val, prevLvl, prevVal)
+})
+log.level = 'trace'
+log.removeListener('level-change', listener)
+log.level = 'info'
+
+pino.levels.values.error === 50
+pino.levels.labels[50] === 'error'
+
+const logstderr: pino.Logger = pino(process.stderr)
+logstderr.error('on stderr instead of stdout')
+
+log.useLevelLabels = true
+log.info('lol')
+log.level === 'info'
+const isEnabled: boolean = log.isLevelEnabled('info')
+
+const redacted = pino({
+  redact: ['path']
+})
+
+redacted.info({
+  msg: 'logged with redacted properties',
+  path: 'Not shown'
+})
+
+const anotherRedacted = pino({
+  redact: {
+    paths: ['anotherPath'],
+    censor: 'Not the log you\re looking for'
+  }
+})
+
+anotherRedacted.info({
+  msg: 'another logged with redacted properties',
+  anotherPath: 'Not shown'
+})
+
+const withTimeFn = pino({
+  timestamp: pino.stdTimeFunctions.isoTime
+})
+
+const withRFC3339TimeFn = pino({
+  timestamp: pino.stdTimeFunctions.isoTimeNano
+})
+
+const withNestedKey = pino({
+  nestedKey: 'payload'
+})
+
+const withHooks = pino({
+  hooks: {
+    logMethod (args, method, level) {
+      expect(this).type.toBe<pino.Logger>()
+      return method.apply(this, args)
+    },
+    streamWrite (s) {
+      expect(s).type.toBe<string>()
+      return s.replaceAll('secret-key', 'xxx')
+    }
+  }
+})
+
+// Properties/types imported from pino-std-serializers
+const wrappedErrSerializer = pino.stdSerializers.wrapErrorSerializer(
+  (err: pino.SerializedError) => {
+    return { ...err, newProp: 'foo' }
+  }
+)
+const wrappedReqSerializer = pino.stdSerializers.wrapRequestSerializer(
+  (req: pino.SerializedRequest) => {
+    return { ...req, newProp: 'foo' }
+  }
+)
+const wrappedResSerializer = pino.stdSerializers.wrapResponseSerializer(
+  (res: pino.SerializedResponse) => {
+    return { ...res, newProp: 'foo' }
+  }
+)
+
+const socket = new Socket()
+const incomingMessage = new IncomingMessage(socket)
+const serverResponse = new ServerResponse(incomingMessage)
+
+const mappedHttpRequest: { req: pino.SerializedRequest } =
+  pino.stdSerializers.mapHttpRequest(incomingMessage)
+const mappedHttpResponse: { res: pino.SerializedResponse } =
+  pino.stdSerializers.mapHttpResponse(serverResponse)
+
+const serializedErr: pino.SerializedError = pino.stdSerializers.err(
+  new Error()
+)
+const serializedReq: pino.SerializedRequest =
+  pino.stdSerializers.req(incomingMessage)
+const serializedRes: pino.SerializedResponse =
+  pino.stdSerializers.res(serverResponse)
+
+/**
+ * Destination static method
+ */
+const destinationViaDefaultArgs = pino.destination()
+const destinationViaStrFileDescriptor = pino.destination('/log/path')
+const destinationViaNumFileDescriptor = pino.destination(2)
+const destinationViaStream = pino.destination(process.stdout)
+const destinationViaOptionsObject = pino.destination({
+  dest: '/log/path',
+  sync: false
+})
+
+pino(destinationViaDefaultArgs)
+pino({ name: 'my-logger' }, destinationViaDefaultArgs)
+pino(destinationViaStrFileDescriptor)
+pino({ name: 'my-logger' }, destinationViaStrFileDescriptor)
+pino(destinationViaNumFileDescriptor)
+pino({ name: 'my-logger' }, destinationViaNumFileDescriptor)
+pino(destinationViaStream)
+pino({ name: 'my-logger' }, destinationViaStream)
+pino(destinationViaOptionsObject)
+pino({ name: 'my-logger' }, destinationViaOptionsObject)
+
+try {
+  throw new Error('Some error')
+} catch (err) {
+  log.error(err)
+}
+
+interface StrictShape {
+  activity: string;
+  err?: unknown;
+}
+
+info<StrictShape>({
+  activity: 'Required property'
+})
+
+const logLine: pino.LogDescriptor = {
+  level: 20,
+  msg: 'A log message',
+  time: new Date().getTime(),
+  aCustomProperty: true
+}
+
+interface CustomLogger extends pino.Logger {
+  customMethod(msg: string, ...args: unknown[]): void;
+}
+
+const serializerFunc: pino.SerializerFn = () => {}
+const writeFunc: pino.WriteFn = () => {}
+
+interface CustomBaseLogger extends pino.BaseLogger {
+  child(): CustomBaseLogger;
+}
+
+const customBaseLogger: CustomBaseLogger = {
+  level: 'info',
+  fatal () {},
+  error () {},
+  warn () {},
+  info () {},
+  debug () {},
+  trace () {},
+  silent () {},
+  child () {
+    return this
+  },
+  msgPrefix: 'prefix'
+}
+
+// custom levels
+const log3 = pino({ customLevels: { myLevel: 100 } })
+expect(log3).type.not.toHaveProperty('log')
+log3.level = 'myLevel'
+log3.myLevel('')
+log3.child({}).myLevel('')
+
+log3.on('level-change', (lvl, val, prevLvl, prevVal, instance) => {
+  instance.myLevel('foo')
+})
+
+const clog3 = log3.child({}, { customLevels: { childLevel: 120 } })
+// child inherit parent
+clog3.myLevel('')
+// child itself
+clog3.childLevel('')
+const cclog3 = clog3.child({}, { customLevels: { childLevel2: 130 } })
+// child inherit root
+cclog3.myLevel('')
+// child inherit parent
+cclog3.childLevel('')
+// child itself
+cclog3.childLevel2('')
+
+const ccclog3 = clog3.child({})
+expect(ccclog3).type.not.toHaveProperty('nonLevel')
+
+const withChildCallback = pino({
+  onChild: (child: Logger) => {}
+})
+withChildCallback.onChild = (child: Logger) => {}
+
+pino({
+  crlf: true
+})
+
+const customLevels = { foo: 99, bar: 42 }
+
+const customLevelLogger = pino({ customLevels })
+
+type CustomLevelLogger = typeof customLevelLogger
+type CustomLevelLoggerLevels = pino.Level | keyof typeof customLevels
+
+const fn = (logger: Pick<CustomLevelLogger, CustomLevelLoggerLevels>) => {}
+
+const customLevelChildLogger = customLevelLogger.child({ name: 'child' })
+
+fn(customLevelChildLogger) // missing foo typing
+
+// unknown option
+expect(pino).type.not.toBeCallableWith({
+  hello: 'world'
+})
+
+// unknown option
+expect(pino).type.not.toBeCallableWith({
+  hello: 'world',
+  customLevels: {
+    log: 30
+  }
+})
+
+function dangerous () {
+  throw Error('foo')
+}
+
+try {
+  dangerous()
+} catch (err) {
+  log.error(err)
+}
+
+try {
+  dangerous()
+} catch (err) {
+  log.error({ err })
+}
+
+const bLogger = pino({
+  customLevels: {
+    log: 5
+  },
+  level: 'log',
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      colorize: true
+    }
+  }
+})
+
+// Test that we can properly extract parameters from the log fn type
+type LogParam = Parameters<LogFn>
+const [param1, param2, param3, param4]: LogParam = [
+  { multiple: 'params' },
+  'should',
+  'be',
+  'accepted'
+]
+
+expect(param1).type.toBe<unknown>()
+expect(param2).type.toBe<string>()
+expect(param3).type.toBe<unknown>()
+expect(param4).type.toBe<unknown>()
+
+const logger = mock.fn<LogFn>()
+logger.mock.calls[0].arguments[1]?.includes('I should be able to get params')
+
+const hooks: LoggerOptions['hooks'] = {
+  logMethod (this, parameters, method) {
+    if (parameters.length >= 2) {
+      const [parameter1, parameter2, ...remainingParameters] = parameters
+      if (typeof parameter1 === 'string') {
+        return method.apply(this, [
+          parameter2,
+          parameter1,
+          ...remainingParameters
+        ])
+      }
+      return method.apply(this, [parameter2])
+    }
+
+    return method.apply(this, parameters)
+  }
+}
+
+expect(
+  pino({
+    customLevels: {
+      log: 5
+    },
+    level: 'log',
+    transport: {
+      target: 'pino-pretty',
+      options: {
+        colorize: true
+      }
+    }
+  })
+).type.toBe<Logger<'log'>>()
+
+const parentLogger1 = pino(
+  {
+    customLevels: { myLevel: 90 },
+    onChild: (child) => {
+      const a = child.myLevel
+    }
+  },
+  process.stdout
+)
+parentLogger1.onChild = (child) => {
+  child.myLevel('')
+}
+
+const childLogger1 = parentLogger1.child({})
+childLogger1.myLevel('')
+expect(childLogger1).type.not.toHaveProperty('doesntExist')
+
+const parentLogger2 = pino({}, process.stdin)
+parentLogger2.onChild = (child) => {
+  expect(child).type.not.toHaveProperty('doesntExist')
+}
+
+const childLogger2 = parentLogger2.child({})
+expect(childLogger2).type.not.toHaveProperty('doesntExist')
+
+pino(
+  {
+    onChild: (child) => {
+      expect(child).type.not.toHaveProperty('doesntExist')
+    }
+  },
+  process.stdout
+)
+
+const pinoWithoutLevelsSorting = pino({})
+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' })
+// with wrong level comparison type
+expect(pino).type.not.toBeCallableWith({ levelComparison: 123 })
+// 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' })
+
+const customLevelsOnlyOpts = {
+  useOnlyCustomLevels: true,
+  customLevels: {
+    customDebug: 10,
+    info: 20, // to make sure the default names are also available for override
+    customNetwork: 30,
+    customError: 40
+  },
+  level: 'customDebug'
+} satisfies LoggerOptions
+
+const loggerWithCustomLevelOnly = pino(customLevelsOnlyOpts)
+loggerWithCustomLevelOnly.customDebug('test3')
+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>()
+
+// Module extension
+declare module '../../' {
+  interface LogFnFields {
+    bannedField?: never;
+    typeCheckedField?: string;
+  }
+}
+
+info({ typeCheckedField: 'bar' })
+expect(info).type.not.toBeCallableWith({ bannedField: 'bar' })
+expect(info).type.not.toBeCallableWith({ typeCheckedField: 123 })
+const someGenericFunction = <T extends string | number | symbol = never>(
+  arg: Record<T, unknown>
+) => {
+  info(arg)
+}

package/node_modules/pino/test/types/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "fastify-tsconfig",
+  "compilerOptions": {
+    "checkJs": true,
+    "noEmit": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "types": []
+  }
+}

package/node_modules/pino/tsconfig.json

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

package/node_modules/pino-pretty/.borp.yaml

@@ -0,0 +1,6 @@
+reporters:
+  - '@jsumners/line-reporter'
+
+files:
+  - 'lib/**/*.test.js'
+  - 'test/**/*.test.js'

package/node_modules/pino-pretty/.editorconfig

@@ -0,0 +1,13 @@
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+# [*.md]
+# trim_trailing_whitespace = false