pino-sdk 9.7.0

package/test/types/pino-transport.test-d.ts

@@ -0,0 +1,145 @@
+import { pino } from '../../pino'
+import { expectType } from "tsd";
+
+// Single
+const transport = pino.transport({
+    target: '#pino/pretty',
+    options: { some: 'options for', the: 'transport' }
+})
+pino(transport)
+
+expectType<pino.Logger>(pino({
+    transport: {
+        target: 'pino-pretty'
+    },
+}))
+
+// Multiple
+const transports = pino.transport({targets: [
+    {
+        level: 'info',
+        target: '#pino/pretty',
+        options: { some: 'options for', the: 'transport' }
+    },
+    {
+        level: 'trace',
+        target: '#pino/file',
+        options: { destination: './test.log' }
+    }
+]})
+pino(transports)
+
+expectType<pino.Logger>(pino({
+    transport: {targets: [
+            {
+                level: 'info',
+                target: '#pino/pretty',
+                options: { some: 'options for', the: 'transport' }
+            },
+            {
+                level: 'trace',
+                target: '#pino/file',
+                options: { destination: './test.log' }
+            }
+        ]},
+}))
+
+const transportsWithCustomLevels = pino.transport({targets: [
+    {
+        level: 'info',
+        target: '#pino/pretty',
+        options: { some: 'options for', the: 'transport' }
+    },
+    {
+        level: 'foo',
+        target: '#pino/file',
+        options: { destination: './test.log' }
+    }
+], levels: { foo: 35 }})
+pino(transports)
+
+expectType<pino.Logger>(pino({
+    transport: {targets: [
+            {
+                level: 'info',
+                target: '#pino/pretty',
+                options: { some: 'options for', the: 'transport' }
+            },
+            {
+                level: 'trace',
+                target: '#pino/file',
+                options: { destination: './test.log' }
+            }
+        ], levels: { foo: 35 }
+    },
+}))
+
+const transportsWithoutOptions = pino.transport({
+    targets: [
+        { target: '#pino/pretty' },
+        { target: '#pino/file' }
+    ], levels: { foo: 35 }
+})
+pino(transports)
+
+expectType<pino.Logger>(pino({
+    transport: {
+        targets: [
+            { target: '#pino/pretty' },
+            { target: '#pino/file' }
+        ], levels: { foo: 35 }
+    },
+}))
+
+const pipelineTransport = pino.transport({
+    pipeline: [{
+        target: './my-transform.js'
+    }, {
+        // Use target: 'pino/file' to write to stdout
+        // without any change.
+        target: 'pino-pretty'
+    }]
+})
+pino(pipelineTransport)
+
+expectType<pino.Logger>(pino({
+    transport: {
+        pipeline: [{
+            target: './my-transform.js'
+        }, {
+            // Use target: 'pino/file' to write to stdout
+            // without any change.
+            target: 'pino-pretty'
+        }]
+    }
+}))
+
+type TransportConfig = {
+    id: string
+}
+
+// Custom transport params
+const customTransport = pino.transport<TransportConfig>({
+    target: 'custom',
+    options: { id: 'abc' }
+})
+pino(customTransport)
+
+// Worker
+pino.transport({
+    target: 'custom',
+    worker: {
+        argv: ['a', 'b'],
+        stdin: false,
+        stderr: true,
+        stdout: false,
+        autoEnd: true,
+    },
+    options: { id: 'abc' }
+})
+
+// Dedupe
+pino.transport({
+    targets: [],
+    dedupe: true,
+})

package/test/types/pino-type-only.test-d.ts

@@ -0,0 +1,64 @@
+import { expectAssignable, expectType, expectNotAssignable } from "tsd";
+
+import pino from "../../";
+import type {LevelWithSilent, Logger, LogFn, P, DestinationStreamWithMetadata,  Level, LevelOrString, LevelWithSilentOrString, LoggerExtras, LoggerOptions } from "../../pino";
+
+// NB: can also use `import * as pino`, but that form is callable as `pino()`
+// under `esModuleInterop: false` or `pino.default()` under `esModuleInterop: true`.
+const log = pino();
+expectAssignable<LoggerExtras>(log);
+expectType<Logger>(log);
+expectType<LogFn>(log.info);
+
+expectType<P.Logger>(log);
+expectType<P.LogFn>(log.info);
+
+expectType<Parameters<typeof log.isLevelEnabled>>([log.level]);
+
+const level: Level = 'debug';
+expectAssignable<string>(level);
+expectAssignable<P.Level>(level);
+
+const levelWithSilent: LevelWithSilent = 'silent';
+expectAssignable<string>(levelWithSilent);
+expectAssignable<P.LevelWithSilent>(levelWithSilent);
+
+const levelOrString: LevelOrString = "myCustomLevel";
+expectAssignable<string>(levelOrString);
+expectNotAssignable<pino.Level>(levelOrString);
+expectNotAssignable<pino.LevelWithSilent>(levelOrString);
+expectAssignable<pino.LevelWithSilentOrString>(levelOrString);
+
+const levelWithSilentOrString: LevelWithSilentOrString = "myCustomLevel";
+expectAssignable<string>(levelWithSilentOrString);
+expectNotAssignable<pino.Level>(levelWithSilentOrString);
+expectNotAssignable<pino.LevelWithSilent>(levelWithSilentOrString);
+expectAssignable<pino.LevelOrString>(levelWithSilentOrString);
+
+function createStream(): DestinationStreamWithMetadata {
+    return { write() {} };
+}
+
+const stream = createStream();
+// Argh. TypeScript doesn't seem to narrow unless we assign the symbol like so, and tsd seems to
+// break without annotating the type explicitly
+const needsMetadata: typeof pino.symbols.needsMetadataGsym = pino.symbols.needsMetadataGsym;
+if (stream[needsMetadata]) {
+    expectType<number>(stream.lastLevel);
+}
+
+const loggerOptions:LoggerOptions = {
+    browser: {
+        formatters: {
+            log(obj) {
+                return obj
+            },
+            level(label, number) {
+                return { label, number}
+            }
+
+        }
+    }
+}
+
+expectType<LoggerOptions>(loggerOptions)