@restura/core 1.0.19 → 1.1.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import winston from 'winston';
+import { SerializerFn } from 'pino';
 import { z } from 'zod';
 import { UUID } from 'crypto';
 import * as express from 'express';
@@ -6,16 +6,40 @@ import { IncomingHttpHeaders } from 'http2';
 import { QueryResultRow, QueryConfigValues, QueryResult, PoolConfig, Pool, ClientConfig, Client } from 'pg';
 import peg from 'pegjs';
 
-declare const logger: winston.Logger;
+type LogFunction = {
+    (msg: string, ...args: unknown[]): void;
+    (msg: unknown): void;
+};
+declare const logger: {
+    level: "fatal" | "error" | "warn" | "info" | "debug" | "silly" | "trace";
+    fatal: LogFunction;
+    error: LogFunction;
+    warn: LogFunction;
+    info: LogFunction;
+    debug: LogFunction;
+    silly: LogFunction;
+    trace: LogFunction;
+};
 
+type ErrorSerializerFactory = (baseSerializer: SerializerFn) => SerializerFn;
 declare const loggerConfigSchema: z.ZodObject<{
     level: z.ZodDefault<z.ZodEnum<{
-        info: "info";
-        warn: "warn";
+        fatal: "fatal";
         error: "error";
+        warn: "warn";
+        info: "info";
         debug: "debug";
         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>>>;
+    serializers: z.ZodOptional<z.ZodObject<{
+        err: z.ZodOptional<z.ZodCustom<ErrorSerializerFactory, ErrorSerializerFactory>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type LoggerConfigSchema = z.infer<typeof loggerConfigSchema>;
 
@@ -943,7 +967,6 @@ declare abstract class PsqlConnection {
     queryOneSchema<T>(query: string, params: unknown[], requesterDetails: RequesterDetails, zodSchema: z.ZodSchema<T>): Promise<T>;
     runQuery<T>(query: string, options: unknown[], requesterDetails: RequesterDetails): Promise<T[]>;
     runQuerySchema<T>(query: string, params: unknown[], requesterDetails: RequesterDetails, zodSchema: z.ZodSchema<T>): Promise<T[]>;
-    private logQueryDuration;
     private logSqlStatement;
 }
 

package/dist/index.js

@@ -11,39 +11,138 @@ var __decorateClass = (decorators, target, key, kind) => {
 
 // src/logger/logger.ts
 import { config } from "@restura/internal";
-import winston from "winston";
-import { format } from "logform";
+import pino from "pino";
 
 // src/logger/loggerConfigSchema.ts
 import { z } from "zod";
 var loggerConfigSchema = z.object({
-  level: z.enum(["info", "warn", "error", "debug", "silly"]).default("info")
+  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(),
+  serializers: z.object({
+    err: z.custom().optional()
+  }).optional()
 });
 
 // src/logger/logger.ts
 var loggerConfig = await config.validate("logger", loggerConfigSchema);
-var consoleFormat = format.combine(
-  format.timestamp({
-    format: "YYYY-MM-DD HH:mm:ss.sss"
+var logLevelMap = {
+  fatal: "fatal",
+  error: "error",
+  warn: "warn",
+  info: "info",
+  debug: "debug",
+  silly: "trace",
+  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 errorSerializer = (() => {
+  try {
+    return loggerConfig.serializers?.err ? loggerConfig.serializers.err(baseErrSerializer) : baseErrSerializer;
+  } catch (error) {
+    console.error("Failed to initialize custom error serializer, falling back to default", error);
+    return baseErrSerializer;
+  }
+})();
+var pinoLogger = pino({
+  level: currentLogLevel,
+  transport: {
+    targets: loggerConfig.transports ?? defaultTransports
+  },
+  serializers: {
+    err: errorSerializer
+  }
+});
+function buildContext(args) {
+  const ctx = {};
+  const prims = [];
+  for (const arg of args) {
+    if (arg instanceof Error && !ctx.err) {
+      ctx.err = arg;
+    } else if (arg && typeof arg === "object" && !Array.isArray(arg)) {
+      Object.assign(ctx, arg);
+    } else {
+      prims.push(arg);
+    }
+  }
+  if (prims.length) ctx.args = prims;
+  return ctx;
+}
+function log(level, message, ...args) {
+  pinoLogger[level](buildContext(args), message);
+}
+var logger = {
+  level: loggerConfig.level,
+  fatal: ((msg, ...args) => {
+    if (typeof msg === "string") {
+      log("fatal", msg, ...args);
+    } else {
+      pinoLogger.fatal(msg);
+    }
+  }),
+  error: ((msg, ...args) => {
+    if (typeof msg === "string") {
+      log("error", msg, ...args);
+    } else {
+      pinoLogger.error(msg);
+    }
+  }),
+  warn: ((msg, ...args) => {
+    if (typeof msg === "string") {
+      log("warn", msg, ...args);
+    } else {
+      pinoLogger.warn(msg);
+    }
   }),
-  format.errors({ stack: true }),
-  format.padLevels(),
-  format.colorize({ all: true }),
-  format.printf((info) => {
-    return `[${info.timestamp}] ${info.level} ${info.message}`;
+  info: ((msg, ...args) => {
+    if (typeof msg === "string") {
+      log("info", msg, ...args);
+    } else {
+      pinoLogger.info(msg);
+    }
+  }),
+  debug: ((msg, ...args) => {
+    if (typeof msg === "string") {
+      log("debug", msg, ...args);
+    } else {
+      pinoLogger.debug(msg);
+    }
+  }),
+  silly: ((msg, ...args) => {
+    if (typeof msg === "string") {
+      log("trace", msg, ...args);
+    } else {
+      pinoLogger.trace(msg);
+    }
+  }),
+  trace: ((msg, ...args) => {
+    if (typeof msg === "string") {
+      log("trace", msg, ...args);
+    } else {
+      pinoLogger.trace(msg);
+    }
   })
-);
-var logger = winston.createLogger({
-  level: loggerConfig.level,
-  format: format.combine(
-    format.timestamp({
-      format: "YYYY-MM-DD HH:mm:ss.sss"
-    }),
-    format.errors({ stack: true }),
-    format.json()
-  ),
-  transports: [new winston.transports.Console({ format: consoleFormat })]
-});
+};
 
 // src/restura/eventManager.ts
 import Bluebird from "bluebird";
@@ -1636,12 +1735,12 @@ import pg from "pg";
 
 // src/restura/sql/PsqlConnection.ts
 import crypto from "crypto";
-import format3 from "pg-format";
+import format2 from "pg-format";
 import { format as sqlFormat } from "sql-formatter";
 import { z as z6 } from "zod";
 
 // src/restura/sql/PsqlUtils.ts
-import format2 from "pg-format";
+import format from "pg-format";
 function escapeColumnName(columnName) {
   if (columnName === void 0) return "";
   return `"${columnName.replace(/"/g, "")}"`.replace(".", '"."');
@@ -1698,9 +1797,9 @@ function SQL(strings, ...values) {
     } else if (typeof value === "number") {
       query += value;
     } else if (Array.isArray(value)) {
-      query += format2.literal(JSON.stringify(value)) + "::jsonb";
+      query += format.literal(JSON.stringify(value)) + "::jsonb";
     } else {
-      query += format2.literal(value);
+      query += format.literal(value);
     }
     query += strings[index + 1];
   });
@@ -1716,17 +1815,17 @@ var PsqlConnection = class {
   async queryOne(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
-    this.logSqlStatement(formattedQuery, options, meta);
     const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
 `;
     const startTime = process.hrtime();
     try {
       const response = await this.query(queryMetadata + formattedQuery, options);
-      this.logQueryDuration(startTime);
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
       if (response.rows.length === 0) throw new RsError("NOT_FOUND", "No results found");
       else if (response.rows.length > 1) throw new RsError("DUPLICATE", "More than one result found");
       return response.rows[0];
     } catch (error) {
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
       if (RsError.isRsError(error)) throw error;
       if (error?.routine === "_bt_check_unique") {
         throw new RsError("DUPLICATE", error.message);
@@ -1752,15 +1851,15 @@ var PsqlConnection = class {
   async runQuery(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
-    this.logSqlStatement(formattedQuery, options, meta);
     const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
 `;
     const startTime = process.hrtime();
     try {
       const response = await this.query(queryMetadata + formattedQuery, options);
-      this.logQueryDuration(startTime);
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
       return response.rows;
     } catch (error) {
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
       if (error?.routine === "_bt_check_unique") {
         throw new RsError("DUPLICATE", error.message);
       }
@@ -1782,15 +1881,8 @@ var PsqlConnection = class {
       throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
     }
   }
-  logQueryDuration(startTime) {
-    if (logger.level === "silly") {
-      const [seconds, nanoseconds] = process.hrtime(startTime);
-      const duration = seconds * 1e3 + nanoseconds / 1e6;
-      logger.silly(`Query duration: ${duration.toFixed(2)}ms`);
-    }
-  }
-  logSqlStatement(query, options, queryMetadata, prefix = "") {
-    if (logger.level !== "silly") return;
+  logSqlStatement(query, options, queryMetadata, startTime, prefix = "") {
+    if (logger.level !== "trace" && logger.level !== "silly") return;
     let sqlStatement = "";
     if (options.length === 0) {
       sqlStatement = query;
@@ -1803,7 +1895,7 @@ var PsqlConnection = class {
         const value = options[paramIndex];
         if (typeof value === "number") return value.toString();
         if (typeof value === "boolean") return value.toString();
-        return format3.literal(value);
+        return format2.literal(value);
       });
     }
     const formattedSql = sqlFormat(sqlStatement, {
@@ -1814,12 +1906,17 @@ var PsqlConnection = class {
       useTabs: true,
       tabWidth: 4
     });
+    const [seconds, nanoseconds] = process.hrtime(startTime);
+    const durationMs = seconds * 1e3 + nanoseconds / 1e6;
     let initiator = "Anonymous";
     if ("userId" in queryMetadata && queryMetadata.userId)
       initiator = `User Id (${queryMetadata.userId.toString()})`;
     if ("isSystemUser" in queryMetadata && queryMetadata.isSystemUser) initiator = "SYSTEM";
     logger.silly(`${prefix}query by ${initiator}, Query ->
-${formattedSql}`);
+${formattedSql}`, {
+      duration: `${durationMs.toFixed(2)}ms`,
+      _meta: { durationNs: nanoseconds }
+    });
   }
 };