@restura/core 1.1.1 → 1.2.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SerializerFn } from 'pino';
+import { TransportTargetOptions, SerializerFn, DestinationStream } from 'pino';
 import { z } from 'zod';
 import { UUID } from 'crypto';
 import * as express from 'express';
@@ -32,14 +32,11 @@ declare const loggerConfigSchema: z.ZodObject<{
         silly: "silly";
         trace: "trace";
     }>>;
-    transports: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        target: z.ZodString;
-        level: z.ZodOptional<z.ZodString>;
-        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>>;
+    transports: z.ZodOptional<z.ZodArray<z.ZodCustom<TransportTargetOptions<Record<string, any>>, TransportTargetOptions<Record<string, any>>>>>;
     serializers: z.ZodOptional<z.ZodObject<{
         err: z.ZodOptional<z.ZodCustom<ErrorSerializerFactory, ErrorSerializerFactory>>;
     }, z.core.$strip>>;
+    stream: z.ZodOptional<z.ZodCustom<DestinationStream, DestinationStream>>;
 }, z.core.$strip>;
 type LoggerConfigSchema = z.infer<typeof loggerConfigSchema>;
 

package/dist/index.js

@@ -12,21 +12,20 @@ var __decorateClass = (decorators, target, key, kind) => {
 // src/logger/logger.ts
 import { config } from "@restura/internal";
 import pino from "pino";
+import pinoPretty from "pino-pretty";
 
 // src/logger/loggerConfigSchema.ts
 import { z } from "zod";
 var loggerConfigSchema = z.object({
   level: z.enum(["fatal", "error", "warn", "info", "debug", "silly", "trace"]).default("info"),
-  transports: z.array(
-    z.object({
-      target: z.string(),
-      level: z.string().optional(),
-      options: z.record(z.string(), z.unknown()).optional()
-    })
-  ).optional(),
+  transports: z.array(z.custom()).optional(),
   serializers: z.object({
     err: z.custom().optional()
-  }).optional()
+  }).optional(),
+  stream: z.custom().optional()
+}).refine((data) => !(data.transports && data.stream), {
+  message: "You must provide either a transports array or a stream object, but not both",
+  path: ["transports"]
 });
 
 // src/logger/logger.ts
@@ -41,38 +40,54 @@ var logLevelMap = {
   trace: "trace"
 };
 var currentLogLevel = logLevelMap[loggerConfig.level];
-var defaultTransports = [
-  {
-    target: "pino-pretty",
-    options: {
-      colorize: true,
-      translateTime: "yyyy-mm-dd HH:MM:ss.l",
-      ignore: "pid,hostname,_meta",
-      // _meta allows a user to pass in metadata for JSON but not print it to the console
-      messageFormat: "{msg}",
-      levelFirst: true,
-      customColors: "error:red,warn:yellow,info:green,debug:blue,trace:magenta"
-    }
-  }
-];
-var baseErrSerializer = pino.stdSerializers.err;
+var defaultStream = pinoPretty({
+  colorize: true,
+  translateTime: "yyyy-mm-dd HH:MM:ss.l",
+  ignore: "pid,hostname,_meta",
+  // _meta allows a user to pass in metadata for JSON but not print it to the console
+  messageFormat: "{msg}",
+  levelFirst: true,
+  customColors: "error:red,warn:yellow,info:green,debug:blue,trace:magenta",
+  destination: process.stdout
+});
+function isAxiosError(error) {
+  const isObject = (error2) => error2 !== null && typeof error2 === "object";
+  return isObject(error) && "isAxiosError" in error && error.isAxiosError === true;
+}
+var baseSerializer = pino.stdSerializers.err;
+var defaultSerializer = (error) => {
+  if (isAxiosError(error)) {
+    const err = error;
+    return {
+      type: "AxiosError",
+      message: err.message,
+      stack: err.stack,
+      url: err.config?.url,
+      method: err.config?.method?.toUpperCase(),
+      status: err.response?.status,
+      responseData: err.response?.data
+    };
+  }
+  return baseSerializer(error);
+};
 var errorSerializer = (() => {
   try {
-    return loggerConfig.serializers?.err ? loggerConfig.serializers.err(baseErrSerializer) : baseErrSerializer;
+    return loggerConfig.serializers?.err ? loggerConfig.serializers.err(baseSerializer) : defaultSerializer;
   } catch (error) {
     console.error("Failed to initialize custom error serializer, falling back to default", error);
-    return baseErrSerializer;
+    return defaultSerializer;
   }
 })();
-var pinoLogger = pino({
-  level: currentLogLevel,
-  transport: {
-    targets: loggerConfig.transports ?? defaultTransports
+var pinoLogger = pino(
+  {
+    level: currentLogLevel,
+    ...loggerConfig.transports ? { transport: { targets: loggerConfig.transports } } : {},
+    serializers: {
+      err: errorSerializer
+    }
   },
-  serializers: {
-    err: errorSerializer
-  }
-});
+  loggerConfig.stream ? loggerConfig.stream : defaultStream
+);
 function buildContext(args) {
   const ctx = {};
   const prims = [];