@restura/core 1.1.1 → 1.3.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>;
 
@@ -1073,6 +1070,20 @@ declare abstract class SqlEngine {
     protected abstract generateOrderBy(req: RsRequest<unknown>, routeData: StandardRouteData): string;
     protected abstract generateWhereClause(req: RsRequest<unknown>, where: WhereData[], routeData: StandardRouteData, sqlParams: string[]): string;
     protected replaceParamKeywords(value: string | number, routeData: RouteData, req: RsRequest<unknown>, sqlParams: string[]): string | number;
+    /**
+     * Replaces local parameter keywords (e.g., $paramName) in SQL query strings with '?' placeholders
+     * and adds the corresponding parameter values to the sqlParams array for parameterized queries.
+     *
+     * Validates that each parameter keyword exists in the route's request schema before processing.
+     * If the value is not a string or routeData has no request schema, returns the value unchanged.
+     *
+     * @param value - The string or number value that may contain parameter keywords (e.g., "$userId")
+     * @param routeData - The route data containing the request schema for parameter validation
+     * @param req - The request object containing the actual parameter values in req.data
+     * @param sqlParams - Array to which parameter values are appended (modified by reference)
+     * @returns The value with parameter keywords replaced by '?' placeholders, or the original value if unchanged
+     * @throws {RsError} If a parameter keyword is found that doesn't exist in the route's request schema
+     */
     protected replaceLocalParamKeywords(value: string | number, routeData: RouteData, req: RsRequest<unknown>, sqlParams: string[]): string | number;
     protected replaceGlobalParamKeywords(value: string | number, routeData: RouteData, req: RsRequest<unknown>, sqlParams: string[]): string | number;
     abstract generateDatabaseSchemaFromSchema(schema: ResturaSchema): string;

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 = [];
@@ -2027,6 +2042,20 @@ var SqlEngine = class {
     returnValue = this.replaceGlobalParamKeywords(returnValue, routeData, req, sqlParams);
     return returnValue;
   }
+  /**
+   * Replaces local parameter keywords (e.g., $paramName) in SQL query strings with '?' placeholders
+   * and adds the corresponding parameter values to the sqlParams array for parameterized queries.
+   *
+   * Validates that each parameter keyword exists in the route's request schema before processing.
+   * If the value is not a string or routeData has no request schema, returns the value unchanged.
+   *
+   * @param value - The string or number value that may contain parameter keywords (e.g., "$userId")
+   * @param routeData - The route data containing the request schema for parameter validation
+   * @param req - The request object containing the actual parameter values in req.data
+   * @param sqlParams - Array to which parameter values are appended (modified by reference)
+   * @returns The value with parameter keywords replaced by '?' placeholders, or the original value if unchanged
+   * @throws {RsError} If a parameter keyword is found that doesn't exist in the route's request schema
+   */
   replaceLocalParamKeywords(value, routeData, req, sqlParams) {
     if (!routeData.request) return value;
     const data = req.data;
@@ -2605,7 +2634,7 @@ var PsqlEngine = class extends SqlEngine {
   }
   async executeUpdateRequest(req, routeData, schema) {
     const sqlParams = [];
-    const { id, ...bodyNoId } = req.body;
+    const { id, baseModifiedOn, ...bodyNoId } = req.body;
     const table = schema.database.find((item) => {
       return item.name === routeData.table;
     });
@@ -2621,9 +2650,37 @@ var PsqlEngine = class extends SqlEngine {
         bodyNoId[assignmentEscaped] = Number(assignment.value);
       else bodyNoId[assignmentEscaped] = assignment.value;
     }
-    const whereClause = this.generateWhereClause(req, routeData.where, routeData, sqlParams);
+    let whereClause = this.generateWhereClause(req, routeData.where, routeData, sqlParams);
+    const originalWhereClause = whereClause;
+    const originalSqlParams = [...sqlParams];
+    if (baseModifiedOn) {
+      const replacedBaseModifiedOn = this.replaceParamKeywords(baseModifiedOn, routeData, req, sqlParams);
+      const modifiedOnCheck = whereClause ? `${whereClause} AND "modifiedOn" = ?` : `"modifiedOn" = ?`;
+      sqlParams.push(replacedBaseModifiedOn.toString());
+      whereClause = modifiedOnCheck;
+    }
     const query = updateObjectQuery(routeData.table, bodyNoId, whereClause);
-    await this.psqlConnectionPool.queryOne(query, [...sqlParams], req.requesterDetails);
+    try {
+      await this.psqlConnectionPool.queryOne(query, [...sqlParams], req.requesterDetails);
+    } catch (error) {
+      if (!baseModifiedOn || !(error instanceof RsError) || error.err !== "NOT_FOUND") throw error;
+      let isConflict = false;
+      try {
+        await this.psqlConnectionPool.queryOne(
+          `SELECT 1 FROM "${routeData.table}" ${originalWhereClause};`,
+          originalSqlParams,
+          req.requesterDetails
+        );
+        isConflict = true;
+      } catch {
+      }
+      if (isConflict)
+        throw new RsError(
+          "CONFLICT",
+          "The record has been modified since the baseModifiedOn value was provided."
+        );
+      throw error;
+    }
     return this.executeGetRequest(req, routeData, schema);
   }
   async executeDeleteRequest(req, routeData, schema) {