@restura/core 1.9.2 → 2.0.0

package/dist/index.js

@@ -10,245 +10,52 @@ 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/restura/RsError.ts
-var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
-  HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
-  HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
-  HtmlStatusCodes2[HtmlStatusCodes2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
-  HtmlStatusCodes2[HtmlStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
-  HtmlStatusCodes2[HtmlStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
-  HtmlStatusCodes2[HtmlStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
-  HtmlStatusCodes2[HtmlStatusCodes2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
-  HtmlStatusCodes2[HtmlStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
-  HtmlStatusCodes2[HtmlStatusCodes2["GONE"] = 410] = "GONE";
-  HtmlStatusCodes2[HtmlStatusCodes2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
-  HtmlStatusCodes2[HtmlStatusCodes2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
-  HtmlStatusCodes2[HtmlStatusCodes2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
-  HtmlStatusCodes2[HtmlStatusCodes2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
-  HtmlStatusCodes2[HtmlStatusCodes2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
-  HtmlStatusCodes2[HtmlStatusCodes2["SERVER_ERROR"] = 500] = "SERVER_ERROR";
-  HtmlStatusCodes2[HtmlStatusCodes2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
-  HtmlStatusCodes2[HtmlStatusCodes2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
-  HtmlStatusCodes2[HtmlStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
-  HtmlStatusCodes2[HtmlStatusCodes2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
-  HtmlStatusCodes2[HtmlStatusCodes2["NETWORK_CONNECT_TIMEOUT"] = 599] = "NETWORK_CONNECT_TIMEOUT";
-  return HtmlStatusCodes2;
-})(HtmlStatusCodes || {});
-var RsError = class _RsError extends Error {
-  err;
-  msg;
-  options;
-  status;
-  constructor(errCode, message, options) {
-    super(message);
-    this.name = "RsError";
-    this.err = errCode;
-    this.msg = message || "";
-    this.status = _RsError.htmlStatus(errCode);
-    this.options = options;
-  }
-  toJSON() {
-    return {
-      type: this.name,
-      err: this.err,
-      message: this.message,
-      msg: this.msg,
-      status: this.status ?? 500,
-      stack: this.stack ?? "",
-      options: this.options
-    };
-  }
-  static htmlStatus(code) {
-    return htmlStatusMap[code];
-  }
-  static isRsError(error) {
-    return error instanceof _RsError;
-  }
-};
-var htmlStatusMap = {
-  // 1:1 mappings to HTTP status codes
-  BAD_REQUEST: 400 /* BAD_REQUEST */,
-  UNAUTHORIZED: 401 /* UNAUTHORIZED */,
-  PAYMENT_REQUIRED: 402 /* PAYMENT_REQUIRED */,
-  FORBIDDEN: 403 /* FORBIDDEN */,
-  NOT_FOUND: 404 /* NOT_FOUND */,
-  METHOD_NOT_ALLOWED: 405 /* METHOD_NOT_ALLOWED */,
-  REQUEST_TIMEOUT: 408 /* REQUEST_TIMEOUT */,
-  CONFLICT: 409 /* CONFLICT */,
-  GONE: 410 /* GONE */,
-  PAYLOAD_TOO_LARGE: 413 /* PAYLOAD_TOO_LARGE */,
-  UNSUPPORTED_MEDIA_TYPE: 415 /* UNSUPPORTED_MEDIA_TYPE */,
-  UPGRADE_REQUIRED: 426 /* UPGRADE_REQUIRED */,
-  UNPROCESSABLE_ENTITY: 422 /* UNPROCESSABLE_ENTITY */,
-  TOO_MANY_REQUESTS: 429 /* TOO_MANY_REQUESTS */,
-  SERVER_ERROR: 500 /* SERVER_ERROR */,
-  NOT_IMPLEMENTED: 501 /* NOT_IMPLEMENTED */,
-  BAD_GATEWAY: 502 /* BAD_GATEWAY */,
-  SERVICE_UNAVAILABLE: 503 /* SERVICE_UNAVAILABLE */,
-  GATEWAY_TIMEOUT: 504 /* GATEWAY_TIMEOUT */,
-  NETWORK_CONNECT_TIMEOUT: 599 /* NETWORK_CONNECT_TIMEOUT */,
-  // Specific business errors mapped to appropriate HTTP codes
-  UNKNOWN_ERROR: 500 /* SERVER_ERROR */,
-  RATE_LIMIT_EXCEEDED: 429 /* TOO_MANY_REQUESTS */,
-  INVALID_TOKEN: 401 /* UNAUTHORIZED */,
-  INCORRECT_EMAIL_OR_PASSWORD: 401 /* UNAUTHORIZED */,
-  DUPLICATE: 409 /* CONFLICT */,
-  CONNECTION_ERROR: 504 /* GATEWAY_TIMEOUT */,
-  SCHEMA_ERROR: 500 /* SERVER_ERROR */,
-  DATABASE_ERROR: 500 /* SERVER_ERROR */
-};
-
-// 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.custom()).optional(),
-  serializers: z.object({
-    err: z.custom().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
-var loggerConfig = await config.validate("logger", loggerConfigSchema);
-var logLevelMap = {
-  fatal: "fatal",
-  error: "error",
-  warn: "warn",
-  info: "info",
-  debug: "debug",
-  silly: "trace",
-  trace: "trace"
-};
-var currentLogLevel = logLevelMap[loggerConfig.level];
-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
-    };
-  }
-  if (RsError.isRsError(error)) {
-    return error.toJSON();
+var LEVEL_ORDER = ["fatal", "error", "warn", "info", "debug", "trace"];
+function isLevelEnabled(configured, requested) {
+  return LEVEL_ORDER.indexOf(requested) <= LEVEL_ORDER.indexOf(configured);
+}
+var envLevel = process.env.RESTURA_LOG_LEVEL;
+var consoleLoggerLevel = LEVEL_ORDER.includes(envLevel) ? envLevel : "info";
+var consoleLogger = {
+  level: consoleLoggerLevel,
+  fatal: (msg, ...args) => {
+    if (isLevelEnabled(consoleLoggerLevel, "fatal")) console.error(msg, ...args);
+  },
+  error: (msg, ...args) => {
+    if (isLevelEnabled(consoleLoggerLevel, "error")) console.error(msg, ...args);
+  },
+  warn: (msg, ...args) => {
+    if (isLevelEnabled(consoleLoggerLevel, "warn")) console.warn(msg, ...args);
+  },
+  info: (msg, ...args) => {
+    if (isLevelEnabled(consoleLoggerLevel, "info")) console.log(msg, ...args);
+  },
+  debug: (msg, ...args) => {
+    if (isLevelEnabled(consoleLoggerLevel, "debug")) console.debug(msg, ...args);
+  },
+  trace: (msg, ...args) => {
+    if (isLevelEnabled(consoleLoggerLevel, "trace")) console.debug(msg, ...args);
   }
-  return baseSerializer(error);
 };
-var errorSerializer = (() => {
-  try {
-    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 defaultSerializer;
-  }
-})();
-var pinoLogger = pino(
-  {
-    level: currentLogLevel,
-    ...loggerConfig.transports ? { transport: { targets: loggerConfig.transports } } : {},
-    serializers: {
-      err: errorSerializer
-    }
+var _impl = consoleLogger;
+var logger = {
+  get level() {
+    return _impl.level;
   },
-  loggerConfig.stream ? loggerConfig.stream : defaultStream
-);
-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);
-    }
+  fatal: (msg, ...args) => _impl.fatal(msg, ...args),
+  error: (msg, ...args) => _impl.error(msg, ...args),
+  warn: (msg, ...args) => _impl.warn(msg, ...args),
+  info: (msg, ...args) => _impl.info(msg, ...args),
+  debug: (msg, ...args) => _impl.debug(msg, ...args),
+  trace: (msg, ...args) => _impl.trace(msg, ...args)
+};
+function setLogger(impl) {
+  if (impl === logger) {
+    throw new Error("setLogger: cannot install the proxy logger as its own implementation");
   }
-  if (prims.length) ctx.args = prims;
-  return ctx;
+  if (impl === _impl) return;
+  _impl = impl;
 }
-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);
-    }
-  }),
-  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);
-    }
-  })
-};
 
 // src/restura/eventManager.ts
 import Bluebird from "bluebird";
@@ -423,6 +230,94 @@ var SqlUtils = class _SqlUtils {
   }
 };
 
+// src/restura/RsError.ts
+var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
+  HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HtmlStatusCodes2[HtmlStatusCodes2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HtmlStatusCodes2[HtmlStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HtmlStatusCodes2[HtmlStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HtmlStatusCodes2[HtmlStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HtmlStatusCodes2[HtmlStatusCodes2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HtmlStatusCodes2[HtmlStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
+  HtmlStatusCodes2[HtmlStatusCodes2["GONE"] = 410] = "GONE";
+  HtmlStatusCodes2[HtmlStatusCodes2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HtmlStatusCodes2[HtmlStatusCodes2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HtmlStatusCodes2[HtmlStatusCodes2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  HtmlStatusCodes2[HtmlStatusCodes2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HtmlStatusCodes2[HtmlStatusCodes2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HtmlStatusCodes2[HtmlStatusCodes2["SERVER_ERROR"] = 500] = "SERVER_ERROR";
+  HtmlStatusCodes2[HtmlStatusCodes2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HtmlStatusCodes2[HtmlStatusCodes2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HtmlStatusCodes2[HtmlStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HtmlStatusCodes2[HtmlStatusCodes2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HtmlStatusCodes2[HtmlStatusCodes2["NETWORK_CONNECT_TIMEOUT"] = 599] = "NETWORK_CONNECT_TIMEOUT";
+  return HtmlStatusCodes2;
+})(HtmlStatusCodes || {});
+var RsError = class _RsError extends Error {
+  err;
+  msg;
+  options;
+  status;
+  constructor(errCode, message, options) {
+    super(message);
+    this.name = "RsError";
+    this.err = errCode;
+    this.msg = message || "";
+    this.status = _RsError.htmlStatus(errCode);
+    this.options = options;
+  }
+  toJSON() {
+    return {
+      type: this.name,
+      err: this.err,
+      message: this.message,
+      msg: this.msg,
+      status: this.status ?? 500,
+      stack: this.stack ?? "",
+      options: this.options
+    };
+  }
+  static htmlStatus(code) {
+    return htmlStatusMap[code];
+  }
+  static isRsError(error) {
+    return error instanceof _RsError;
+  }
+};
+var htmlStatusMap = {
+  // 1:1 mappings to HTTP status codes
+  BAD_REQUEST: 400 /* BAD_REQUEST */,
+  UNAUTHORIZED: 401 /* UNAUTHORIZED */,
+  PAYMENT_REQUIRED: 402 /* PAYMENT_REQUIRED */,
+  FORBIDDEN: 403 /* FORBIDDEN */,
+  NOT_FOUND: 404 /* NOT_FOUND */,
+  METHOD_NOT_ALLOWED: 405 /* METHOD_NOT_ALLOWED */,
+  REQUEST_TIMEOUT: 408 /* REQUEST_TIMEOUT */,
+  CONFLICT: 409 /* CONFLICT */,
+  GONE: 410 /* GONE */,
+  PAYLOAD_TOO_LARGE: 413 /* PAYLOAD_TOO_LARGE */,
+  UNSUPPORTED_MEDIA_TYPE: 415 /* UNSUPPORTED_MEDIA_TYPE */,
+  UPGRADE_REQUIRED: 426 /* UPGRADE_REQUIRED */,
+  UNPROCESSABLE_ENTITY: 422 /* UNPROCESSABLE_ENTITY */,
+  TOO_MANY_REQUESTS: 429 /* TOO_MANY_REQUESTS */,
+  SERVER_ERROR: 500 /* SERVER_ERROR */,
+  NOT_IMPLEMENTED: 501 /* NOT_IMPLEMENTED */,
+  BAD_GATEWAY: 502 /* BAD_GATEWAY */,
+  SERVICE_UNAVAILABLE: 503 /* SERVICE_UNAVAILABLE */,
+  GATEWAY_TIMEOUT: 504 /* GATEWAY_TIMEOUT */,
+  NETWORK_CONNECT_TIMEOUT: 599 /* NETWORK_CONNECT_TIMEOUT */,
+  // Specific business errors mapped to appropriate HTTP codes
+  UNKNOWN_ERROR: 500 /* SERVER_ERROR */,
+  RATE_LIMIT_EXCEEDED: 429 /* TOO_MANY_REQUESTS */,
+  INVALID_TOKEN: 401 /* UNAUTHORIZED */,
+  INCORRECT_EMAIL_OR_PASSWORD: 401 /* UNAUTHORIZED */,
+  DUPLICATE: 409 /* CONFLICT */,
+  CONNECTION_ERROR: 504 /* GATEWAY_TIMEOUT */,
+  SCHEMA_ERROR: 500 /* SERVER_ERROR */,
+  DATABASE_ERROR: 500 /* SERVER_ERROR */
+};
+
 // src/restura/validators/ResponseValidator.ts
 var ResponseValidator = class _ResponseValidator {
   rootMap;
@@ -905,7 +800,7 @@ declare namespace Restura {
 
 // src/restura/restura.ts
 import { ObjectUtils as ObjectUtils4, StringUtils as StringUtils3 } from "@redskytech/core-utils";
-import { config as config2 } from "@restura/internal";
+import { config } from "@restura/internal";
 
 // ../../node_modules/.pnpm/autobind-decorator@2.4.0/node_modules/autobind-decorator/lib/esm/index.js
 function _typeof(obj) {
@@ -1259,12 +1154,12 @@ function customTypeValidationGenerator(currentSchema, ignoreGeneratedTypes = fal
     return type;
   });
   fs2.writeFileSync(temporaryFile.name, additionalImports + typesWithExport.join("\n"));
-  const config3 = {
+  const config2 = {
     path: resolve(temporaryFile.name),
     tsconfig: path2.join(process.cwd(), "tsconfig.json"),
     skipTypeCheck: true
   };
-  const generator = createGenerator(config3);
+  const generator = createGenerator(config2);
   customInterfaceNames.forEach((item) => {
     try {
       const ddlSchema = generator.createSchema(item);
@@ -1392,30 +1287,30 @@ var getMulterUpload = (directory) => {
 };
 
 // src/restura/schemas/resturaSchema.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
 // src/restura/schemas/validatorDataSchema.ts
-import { z as z2 } from "zod";
-var validatorDataSchemeValue = z2.union([z2.string(), z2.array(z2.string()), z2.number(), z2.array(z2.number())]);
-var validatorDataSchema = z2.object({
-  type: z2.enum(["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]),
+import { z } from "zod";
+var validatorDataSchemeValue = z.union([z.string(), z.array(z.string()), z.number(), z.array(z.number())]);
+var validatorDataSchema = z.object({
+  type: z.enum(["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]),
   value: validatorDataSchemeValue
 }).strict();
 
 // src/restura/schemas/resturaSchema.ts
-var orderBySchema = z3.object({
-  columnName: z3.string(),
-  order: z3.enum(["ASC", "DESC"]),
-  tableName: z3.string()
+var orderBySchema = z2.object({
+  columnName: z2.string(),
+  order: z2.enum(["ASC", "DESC"]),
+  tableName: z2.string()
 }).strict();
-var groupBySchema = z3.object({
-  columnName: z3.string(),
-  tableName: z3.string()
+var groupBySchema = z2.object({
+  columnName: z2.string(),
+  tableName: z2.string()
 }).strict();
-var whereDataSchema = z3.object({
-  tableName: z3.string().optional(),
-  columnName: z3.string().optional(),
-  operator: z3.enum([
+var whereDataSchema = z2.object({
+  tableName: z2.string().optional(),
+  columnName: z2.string().optional(),
+  operator: z2.enum([
     "=",
     "<",
     ">",
@@ -1431,79 +1326,79 @@ var whereDataSchema = z3.object({
     "IS",
     "IS NOT"
   ]).optional(),
-  value: z3.string().or(z3.number()).optional(),
-  custom: z3.string().optional(),
-  conjunction: z3.enum(["AND", "OR"]).optional()
+  value: z2.string().or(z2.number()).optional(),
+  custom: z2.string().optional(),
+  conjunction: z2.enum(["AND", "OR"]).optional()
 }).strict();
-var assignmentDataSchema = z3.object({
-  name: z3.string(),
-  value: z3.string()
+var assignmentDataSchema = z2.object({
+  name: z2.string(),
+  value: z2.string()
 }).strict();
-var joinDataSchema = z3.object({
-  table: z3.string(),
-  localTable: z3.string().optional(),
+var joinDataSchema = z2.object({
+  table: z2.string(),
+  localTable: z2.string().optional(),
   // Defaults to base table if not specificed
-  localTableAlias: z3.string().optional(),
+  localTableAlias: z2.string().optional(),
   // If we are joining a table off of a previous join, this is the alias of the previous join
-  localColumnName: z3.string().optional(),
-  foreignColumnName: z3.string().optional(),
-  custom: z3.string().optional(),
-  type: z3.enum(["LEFT", "INNER", "RIGHT"]),
-  alias: z3.string()
+  localColumnName: z2.string().optional(),
+  foreignColumnName: z2.string().optional(),
+  custom: z2.string().optional(),
+  type: z2.enum(["LEFT", "INNER", "RIGHT"]),
+  alias: z2.string()
 }).strict();
-var requestDataSchema = z3.object({
-  name: z3.string(),
-  required: z3.boolean(),
-  isNullable: z3.boolean().optional(),
-  validator: z3.array(validatorDataSchema)
+var requestDataSchema = z2.object({
+  name: z2.string(),
+  required: z2.boolean(),
+  isNullable: z2.boolean().optional(),
+  validator: z2.array(validatorDataSchema)
 }).strict();
-var responseDataSchema = z3.object({
-  name: z3.string(),
-  selector: z3.string().optional(),
-  subquery: z3.object({
-    table: z3.string(),
-    joins: z3.array(joinDataSchema),
-    where: z3.array(whereDataSchema),
+var responseDataSchema = z2.object({
+  name: z2.string(),
+  selector: z2.string().optional(),
+  subquery: z2.object({
+    table: z2.string(),
+    joins: z2.array(joinDataSchema),
+    where: z2.array(whereDataSchema),
     get properties() {
-      return z3.array(responseDataSchema);
+      return z2.array(responseDataSchema);
     },
     groupBy: groupBySchema.optional(),
     orderBy: orderBySchema.optional()
   }).optional(),
-  type: z3.string().optional()
+  type: z2.string().optional()
   // Type allows you to override the type of the response, used in custom selectors
 }).strict();
-var routeDataBaseSchema = z3.object({
-  method: z3.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
-  name: z3.string(),
-  description: z3.string(),
-  path: z3.string(),
-  deprecation: z3.object({
-    date: z3.iso.datetime(),
-    message: z3.string().optional()
+var routeDataBaseSchema = z2.object({
+  method: z2.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+  name: z2.string(),
+  description: z2.string(),
+  path: z2.string(),
+  deprecation: z2.object({
+    date: z2.iso.datetime(),
+    message: z2.string().optional()
   }).optional(),
-  roles: z3.array(z3.string()),
-  scopes: z3.array(z3.string())
+  roles: z2.array(z2.string()),
+  scopes: z2.array(z2.string())
 }).strict();
 var standardRouteSchema = routeDataBaseSchema.extend({
-  type: z3.enum(["ONE", "ARRAY", "PAGED"]),
-  table: z3.string(),
-  joins: z3.array(joinDataSchema),
-  assignments: z3.array(assignmentDataSchema),
-  where: z3.array(whereDataSchema),
-  request: z3.array(requestDataSchema),
-  response: z3.array(responseDataSchema),
+  type: z2.enum(["ONE", "ARRAY", "PAGED"]),
+  table: z2.string(),
+  joins: z2.array(joinDataSchema),
+  assignments: z2.array(assignmentDataSchema),
+  where: z2.array(whereDataSchema),
+  request: z2.array(requestDataSchema),
+  response: z2.array(responseDataSchema),
   groupBy: groupBySchema.optional(),
   orderBy: orderBySchema.optional()
 }).strict();
 var customRouteSchema = routeDataBaseSchema.extend({
-  type: z3.enum(["CUSTOM_ONE", "CUSTOM_ARRAY", "CUSTOM_PAGED"]),
-  responseType: z3.union([z3.string(), z3.enum(["string", "number", "boolean"])]),
-  requestType: z3.string().optional(),
-  request: z3.array(requestDataSchema).optional(),
-  fileUploadType: z3.enum(["SINGLE", "MULTIPLE"]).optional()
+  type: z2.enum(["CUSTOM_ONE", "CUSTOM_ARRAY", "CUSTOM_PAGED"]),
+  responseType: z2.union([z2.string(), z2.enum(["string", "number", "boolean"])]),
+  requestType: z2.string().optional(),
+  request: z2.array(requestDataSchema).optional(),
+  fileUploadType: z2.enum(["SINGLE", "MULTIPLE"]).optional()
 }).strict();
-var postgresColumnNumericTypesSchema = z3.enum([
+var postgresColumnNumericTypesSchema = z2.enum([
   "SMALLINT",
   // 2 bytes, -32,768 to 32,767
   "INTEGER",
@@ -1523,7 +1418,7 @@ var postgresColumnNumericTypesSchema = z3.enum([
   "BIGSERIAL"
   // auto-incrementing big integer
 ]);
-var postgresColumnStringTypesSchema = z3.enum([
+var postgresColumnStringTypesSchema = z2.enum([
   "CHAR",
   // fixed-length, blank-padded
   "VARCHAR",
@@ -1533,7 +1428,7 @@ var postgresColumnStringTypesSchema = z3.enum([
   "BYTEA"
   // binary data
 ]);
-var postgresColumnDateTypesSchema = z3.enum([
+var postgresColumnDateTypesSchema = z2.enum([
   "DATE",
   // calendar date (year, month, day)
   "TIMESTAMP",
@@ -1545,13 +1440,13 @@ var postgresColumnDateTypesSchema = z3.enum([
   "INTERVAL"
   // time span
 ]);
-var postgresColumnJsonTypesSchema = z3.enum([
+var postgresColumnJsonTypesSchema = z2.enum([
   "JSON",
   // stores JSON data as raw text
   "JSONB"
   // stores JSON data in a binary format, optimized for query performance
 ]);
-var mariaDbColumnNumericTypesSchema = z3.enum([
+var mariaDbColumnNumericTypesSchema = z2.enum([
   "BOOLEAN",
   // 1-byte A synonym for "TINYINT(1)". Supported from version 1.2.0 onwards.
   "TINYINT",
@@ -1571,7 +1466,7 @@ var mariaDbColumnNumericTypesSchema = z3.enum([
   "DOUBLE"
   // 8 bytes Stored in 64-bit IEEE-754 floating point format. As such, the number of significant digits is about 15 and the range of values is approximately +/-1e308.
 ]);
-var mariaDbColumnStringTypesSchema = z3.enum([
+var mariaDbColumnStringTypesSchema = z2.enum([
   "CHAR",
   // 1, 2, 4, or 8 bytes Holds letters and special characters of fixed length. Max length is 255. Default and minimum size is 1 byte.
   "VARCHAR",
@@ -1597,7 +1492,7 @@ var mariaDbColumnStringTypesSchema = z3.enum([
   "ENUM"
   // Enum type
 ]);
-var mariaDbColumnDateTypesSchema = z3.enum([
+var mariaDbColumnDateTypesSchema = z2.enum([
   "DATE",
   // 4-bytes Date has year, month, and day.
   "DATETIME",
@@ -1607,9 +1502,9 @@ var mariaDbColumnDateTypesSchema = z3.enum([
   "TIMESTAMP"
   // 4-bytes Values are stored as the number of seconds since 1970-01-01 00:00:00 UTC, and optionally microseconds.
 ]);
-var columnDataSchema = z3.object({
-  name: z3.string(),
-  type: z3.union([
+var columnDataSchema = z2.object({
+  name: z2.string(),
+  type: z2.union([
     postgresColumnNumericTypesSchema,
     postgresColumnStringTypesSchema,
     postgresColumnDateTypesSchema,
@@ -1618,26 +1513,26 @@ var columnDataSchema = z3.object({
     mariaDbColumnStringTypesSchema,
     mariaDbColumnDateTypesSchema
   ]),
-  isNullable: z3.boolean(),
-  roles: z3.array(z3.string()),
-  scopes: z3.array(z3.string()),
-  comment: z3.string().optional(),
-  default: z3.string().optional(),
-  value: z3.string().optional(),
-  isPrimary: z3.boolean().optional(),
-  isUnique: z3.boolean().optional(),
-  hasAutoIncrement: z3.boolean().optional(),
-  length: z3.number().optional()
+  isNullable: z2.boolean(),
+  roles: z2.array(z2.string()),
+  scopes: z2.array(z2.string()),
+  comment: z2.string().optional(),
+  default: z2.string().optional(),
+  value: z2.string().optional(),
+  isPrimary: z2.boolean().optional(),
+  isUnique: z2.boolean().optional(),
+  hasAutoIncrement: z2.boolean().optional(),
+  length: z2.number().optional()
 }).strict();
-var indexDataSchema = z3.object({
-  name: z3.string(),
-  columns: z3.array(z3.string()),
-  isUnique: z3.boolean(),
-  isPrimaryKey: z3.boolean(),
-  order: z3.enum(["ASC", "DESC"]),
-  where: z3.string().optional()
+var indexDataSchema = z2.object({
+  name: z2.string(),
+  columns: z2.array(z2.string()),
+  isUnique: z2.boolean(),
+  isPrimaryKey: z2.boolean(),
+  order: z2.enum(["ASC", "DESC"]),
+  where: z2.string().optional()
 }).strict();
-var foreignKeyActionsSchema = z3.enum([
+var foreignKeyActionsSchema = z2.enum([
   "CASCADE",
   // CASCADE action for foreign keys
   "SET NULL",
@@ -1649,50 +1544,50 @@ var foreignKeyActionsSchema = z3.enum([
   "SET DEFAULT"
   // SET DEFAULT action for foreign keys
 ]);
-var foreignKeyDataSchema = z3.object({
-  name: z3.string(),
-  column: z3.string(),
-  refTable: z3.string(),
-  refColumn: z3.string(),
+var foreignKeyDataSchema = z2.object({
+  name: z2.string(),
+  column: z2.string(),
+  refTable: z2.string(),
+  refColumn: z2.string(),
   onDelete: foreignKeyActionsSchema,
   onUpdate: foreignKeyActionsSchema
 }).strict();
-var checkConstraintDataSchema = z3.object({
-  name: z3.string(),
-  check: z3.string()
+var checkConstraintDataSchema = z2.object({
+  name: z2.string(),
+  check: z2.string()
 }).strict();
-var tableDataSchema = z3.object({
-  name: z3.string(),
-  columns: z3.array(columnDataSchema),
-  indexes: z3.array(indexDataSchema),
-  foreignKeys: z3.array(foreignKeyDataSchema),
-  checkConstraints: z3.array(checkConstraintDataSchema),
-  roles: z3.array(z3.string()),
-  scopes: z3.array(z3.string()),
-  notify: z3.union([z3.literal("ALL"), z3.array(z3.string())]).optional()
+var tableDataSchema = z2.object({
+  name: z2.string(),
+  columns: z2.array(columnDataSchema),
+  indexes: z2.array(indexDataSchema),
+  foreignKeys: z2.array(foreignKeyDataSchema),
+  checkConstraints: z2.array(checkConstraintDataSchema),
+  roles: z2.array(z2.string()),
+  scopes: z2.array(z2.string()),
+  notify: z2.union([z2.literal("ALL"), z2.array(z2.string())]).optional()
 }).strict();
-var endpointDataSchema = z3.object({
-  name: z3.string(),
-  description: z3.string(),
-  baseUrl: z3.string(),
-  routes: z3.array(z3.union([standardRouteSchema, customRouteSchema]))
+var endpointDataSchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  baseUrl: z2.string(),
+  routes: z2.array(z2.union([standardRouteSchema, customRouteSchema]))
 }).strict();
-var resturaSchema = z3.object({
-  database: z3.array(tableDataSchema),
-  endpoints: z3.array(endpointDataSchema),
-  globalParams: z3.array(z3.string()),
-  roles: z3.array(z3.string()),
-  scopes: z3.array(z3.string()),
-  customTypes: z3.array(z3.string())
+var resturaSchema = z2.object({
+  database: z2.array(tableDataSchema),
+  endpoints: z2.array(endpointDataSchema),
+  globalParams: z2.array(z2.string()),
+  roles: z2.array(z2.string()),
+  scopes: z2.array(z2.string()),
+  customTypes: z2.array(z2.string())
 }).strict();
 async function isSchemaValid(schemaToCheck) {
   try {
     resturaSchema.parse(schemaToCheck);
     return true;
   } catch (error) {
-    if (error instanceof z3.ZodError) {
+    if (error instanceof z2.ZodError) {
       logger.error("Schema failed to validate with the following error:");
-      console.error(z3.prettifyError(error));
+      console.error(z2.prettifyError(error));
     } else {
       logger.error(error);
     }
@@ -1903,33 +1798,23 @@ async function schemaValidation(req, res, next) {
 }
 
 // src/restura/schemas/resturaConfigSchema.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 var isTsx = process.argv[1]?.endsWith(".ts");
 var isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
 var customApiFolderPath = isTsx || isTsNode ? "/src/api" : "/dist/api";
-var resturaConfigSchema = z4.object({
-  authToken: z4.string().min(1, "Missing Restura Auth Token"),
-  sendErrorStackTrace: z4.boolean().default(false),
-  schemaFilePath: z4.string().default(process.cwd() + "/restura.schema.json"),
-  customApiFolderPath: z4.string().default(process.cwd() + customApiFolderPath),
-  generatedTypesPath: z4.string().default(process.cwd() + "/src/@types"),
-  fileTempCachePath: z4.string().optional(),
-  scratchDatabaseSuffix: z4.string().optional()
+var resturaConfigSchema = z3.object({
+  authToken: z3.string().min(1, "Missing Restura Auth Token"),
+  sendErrorStackTrace: z3.boolean().default(false),
+  schemaFilePath: z3.string().default(process.cwd() + "/restura.schema.json"),
+  customApiFolderPath: z3.string().default(process.cwd() + customApiFolderPath),
+  generatedTypesPath: z3.string().default(process.cwd() + "/src/@types"),
+  fileTempCachePath: z3.string().optional(),
+  scratchDatabaseSuffix: z3.string().optional()
 });
 
 // src/restura/sql/PsqlEngine.ts
 import { ObjectUtils as ObjectUtils3 } from "@redskytech/core-utils";
-import getDiff from "@wmfs/pg-diff-sync";
-import pgInfo from "@wmfs/pg-info";
-import pg2 from "pg";
-
-// src/restura/sql/PsqlPool.ts
-import pg from "pg";
-
-// src/restura/sql/PsqlConnection.ts
-import crypto from "crypto";
-import { format as sqlFormat } from "sql-formatter";
-import { z as z5 } from "zod";
+import pg3 from "pg";
 
 // src/restura/sql/PsqlUtils.ts
 import format from "pg-format";
@@ -2020,135 +1905,6 @@ function toSqlLiteral(value) {
   return format.literal(value);
 }
 
-// src/restura/sql/PsqlConnection.ts
-var PsqlConnection = class {
-  instanceId;
-  constructor(instanceId) {
-    this.instanceId = instanceId || crypto.randomUUID();
-  }
-  async queryOne(query, options, requesterDetails) {
-    const formattedQuery = questionMarksToOrderedParams(query);
-    const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
-    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
-`;
-    const startTime = process.hrtime();
-    try {
-      const response = await this.query(queryMetadata + formattedQuery, options);
-      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");
-      this.logSqlStatement(formattedQuery, options, meta, startTime);
-      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);
-      }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
-    }
-  }
-  async queryOneSchema(query, params, requesterDetails, zodSchema) {
-    const result = await this.queryOne(query, params, requesterDetails);
-    try {
-      return zodSchema.parse(result);
-    } catch (error) {
-      if (error instanceof z5.ZodError) {
-        logger.error("Invalid data returned from database:");
-        logger.silly("\n" + JSON.stringify(result, null, 2));
-        logger.error("\n" + z5.prettifyError(error));
-      } else {
-        logger.error(error);
-      }
-      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
-    }
-  }
-  async runQuery(query, options, requesterDetails) {
-    const formattedQuery = questionMarksToOrderedParams(query);
-    const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
-    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
-`;
-    const startTime = process.hrtime();
-    try {
-      const response = await this.query(queryMetadata + formattedQuery, options);
-      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);
-      }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
-    }
-  }
-  async runQuerySchema(query, params, requesterDetails, zodSchema) {
-    const result = await this.runQuery(query, params, requesterDetails);
-    try {
-      return z5.array(zodSchema).parse(result);
-    } catch (error) {
-      if (error instanceof z5.ZodError) {
-        logger.error("Invalid data returned from database:");
-        logger.silly("\n" + JSON.stringify(result, null, 2));
-        logger.error("\n" + z5.prettifyError(error));
-      } else {
-        logger.error(error);
-      }
-      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
-    }
-  }
-  logSqlStatement(query, options, queryMetadata, startTime, prefix = "") {
-    if (logger.level !== "trace" && logger.level !== "silly") return;
-    const sqlStatement = query.replace(/\$(\d+)/g, (_, num) => {
-      const paramIndex = parseInt(num) - 1;
-      if (paramIndex >= options.length) return "INVALID_PARAM_INDEX";
-      return toSqlLiteral(options[paramIndex]);
-    });
-    const formattedSql = sqlFormat(sqlStatement, {
-      language: "postgresql",
-      linesBetweenQueries: 2,
-      indentStyle: "standard",
-      keywordCase: "upper",
-      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}`, {
-      durationMs
-    });
-  }
-};
-
-// src/restura/sql/PsqlPool.ts
-var { Pool } = pg;
-var PsqlPool = class extends PsqlConnection {
-  constructor(poolConfig) {
-    super();
-    this.poolConfig = poolConfig;
-    this.pool = new Pool(poolConfig);
-    this.queryOne("SELECT NOW();", [], {
-      isSystemUser: true,
-      role: "",
-      host: "localhost",
-      ipAddress: "",
-      scopes: []
-    }).then(() => {
-      logger.info("Connected to PostgreSQL database");
-    }).catch((error) => {
-      logger.error("Error connecting to database", error);
-      process.exit(1);
-    });
-  }
-  pool;
-  async query(query, values) {
-    return this.pool.query(query, values);
-  }
-};
-
 // src/restura/sql/SqlEngine.ts
 import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
 var SqlEngine = class {
@@ -2530,7 +2286,15 @@ NullOperator
     / "null"i { return function(col) { return formatColumn(col) + ' IS NULL'; }; }
 
 OperatorWithValue
-    = "in"i _ "," _ val:CastedValueWithPipes { return function(col) { return buildInClauseWithCast(formatColumn(col), val.value, val.cast); }; }
+    = "in"i _ "," _ vals:InValueList cast:TypeCast? { return function(col) { 
+        var formattedCol = formatColumn(col);
+        var literals = vals.map(function(v) {
+            var unescaped = unescapeValue(v);
+            var formatted = formatValue(unescaped);
+            return cast ? formatted + '::' + cast : formatted;
+        });
+        return formattedCol + ' IN (' + literals.join(', ') + ')';
+    }; }
     / "ne"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' <> ' + formatValueWithCast(val.value, val.cast); }; }
     / "gte"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' >= ' + formatValueWithCast(val.value, val.cast); }; }
     / "gt"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' > ' + formatValueWithCast(val.value, val.cast); }; }
@@ -2540,6 +2304,26 @@ OperatorWithValue
     / "sw"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal(unescapeValue(val.value) + '%'); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
     / "ew"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal('%' + unescapeValue(val.value)); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
 
+InValueList
+    = first:InValue rest:("|" InValue)* {
+        var values = [first];
+        for (var i = 0; i < rest.length; i++) {
+            values.push(rest[i][1]);
+        }
+        return values;
+    }
+
+InValue
+    = QuotedString
+    / chars:InValueChar+ { return chars.join(''); }
+
+InValueChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" ]
+    / c:":" !":"  { return c; }
+
 CastedValue
     = val:Value cast:TypeCast? { return { value: val, cast: cast }; }
 
@@ -2550,24 +2334,40 @@ TypeCast
     = "::" type:("timestamptz"i / "timestamp"i / "boolean"i / "numeric"i / "bigint"i / "text"i / "date"i / "int"i)
         { return type.toLowerCase(); }
 
+QuotedString
+    = '"' chars:DoubleQuotedChar* '"' { return chars.join(''); }
+    / "'" chars:SingleQuotedChar* "'" { return chars.join(''); }
+
+DoubleQuotedChar
+    = '\\\\"' { return '"'; }
+    / '\\\\\\\\' { return '\\\\'; }
+    / [^"\\\\]
+
+SingleQuotedChar
+    = "\\\\'" { return "'"; }
+    / '\\\\\\\\' { return '\\\\'; }
+    / [^'\\\\]
+
 Value
-    = chars:ValueChar+ { return chars.join(''); }
+    = QuotedString
+    / chars:ValueChar+ { return chars.join(''); }
 
 ValueChar
     = "\\\\\\\\" { return '\\\\\\\\'; }
     / "\\\\," { return '\\\\,'; }
     / "\\\\|" { return '\\\\|'; }
-    / [^,()\\\\|:]
+    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" ]
     / c:":" !":"  { return c; }
 
 ValueWithPipes
-    = chars:ValueWithPipesChar+ { return chars.join(''); }
+    = QuotedString
+    / chars:ValueWithPipesChar+ { return chars.join(''); }
 
 ValueWithPipesChar
     = "\\\\\\\\" { return '\\\\\\\\'; }
     / "\\\\," { return '\\\\,'; }
     / "\\\\|" { return '\\\\|'; }
-    / [^,()\\\\:]
+    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" |]
     / c:":" !":"  { return c; }
 `;
 var fullGrammar = entryGrammar + oldGrammar + newGrammar;
@@ -2577,278 +2377,654 @@ var filterPsqlParser = peg.generate(fullGrammar, {
 });
 var filterPsqlParser_default = filterPsqlParser;
 
-// src/restura/sql/PsqlEngine.ts
-var { Client, types } = pg2;
-var systemUser = {
-  role: "",
-  scopes: [],
-  host: "",
-  ipAddress: "",
-  isSystemUser: true
-};
-var PsqlEngine = class extends SqlEngine {
-  // 5 seconds
-  constructor(psqlConnectionPool, shouldListenForDbTriggers = false, scratchDatabaseSuffix = "") {
-    super();
-    this.psqlConnectionPool = psqlConnectionPool;
-    this.setupPgReturnTypes();
-    if (shouldListenForDbTriggers) {
-      this.setupTriggerListeners = this.listenForDbTriggers();
-    }
-    this.scratchDbName = `${psqlConnectionPool.poolConfig.database}_scratch${scratchDatabaseSuffix ? `_${scratchDatabaseSuffix}` : ""}`;
+// src/restura/sql/psqlSchemaUtils.ts
+import getDiff from "@wmfs/pg-diff-sync";
+import pgInfo from "@wmfs/pg-info";
+import pg2 from "pg";
+
+// src/restura/sql/PsqlPool.ts
+import pg from "pg";
+
+// src/restura/sql/PsqlConnection.ts
+import crypto from "crypto";
+import { format as sqlFormat } from "sql-formatter";
+import { z as z4 } from "zod";
+var PsqlConnection = class {
+  instanceId;
+  constructor(instanceId) {
+    this.instanceId = instanceId || crypto.randomUUID();
   }
-  setupTriggerListeners;
-  triggerClient;
-  scratchDbName = "";
-  reconnectAttempts = 0;
-  MAX_RECONNECT_ATTEMPTS = 5;
-  INITIAL_RECONNECT_DELAY = 5e3;
-  async close() {
-    if (this.triggerClient) {
-      await this.triggerClient.end();
+  async queryOne(query, options, requesterDetails) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
+`;
+    const startTime = process.hrtime();
+    try {
+      const response = await this.query(queryMetadata + formattedQuery, options);
+      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");
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
+      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);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
     }
   }
-  /**
-   * Setup the return types for the PostgreSQL connection.
-   * For example return DATE as a string instead of a Date object and BIGINT as a number instead of a string.
-   */
-  setupPgReturnTypes() {
-    const PG_TYPE_OID = {
-      BIGINT: 20,
-      DATE: 1082,
-      TIME: 1083,
-      TIMESTAMP: 1114,
-      TIMESTAMPTZ: 1184,
-      TIMETZ: 1266
-    };
-    types.setTypeParser(PG_TYPE_OID.BIGINT, (val) => val === null ? null : Number(val));
-    types.setTypeParser(PG_TYPE_OID.DATE, (val) => val);
-    types.setTypeParser(PG_TYPE_OID.TIME, (val) => val);
-    types.setTypeParser(PG_TYPE_OID.TIMETZ, (val) => val);
-    types.setTypeParser(PG_TYPE_OID.TIMESTAMP, (val) => val === null ? null : new Date(val).toISOString());
-    types.setTypeParser(PG_TYPE_OID.TIMESTAMPTZ, (val) => val === null ? null : new Date(val).toISOString());
-  }
-  async reconnectTriggerClient() {
-    if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
-      logger.error("Max reconnection attempts reached for trigger client. Stopping reconnection attempts.");
-      return;
-    }
-    if (this.triggerClient) {
-      try {
-        await this.triggerClient.end();
-      } catch (error) {
-        logger.error(`Error closing trigger client: ${error}`);
+  async queryOneSchema(query, params, requesterDetails, zodSchema) {
+    const result = await this.queryOne(query, params, requesterDetails);
+    try {
+      return zodSchema.parse(result);
+    } catch (error) {
+      if (error instanceof z4.ZodError) {
+        logger.error("Invalid data returned from database:");
+        logger.trace("\n" + JSON.stringify(result, null, 2));
+        logger.error("\n" + z4.prettifyError(error));
+      } else {
+        logger.error(error);
       }
+      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
     }
-    const delay = this.INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts);
-    logger.info(
-      `Attempting to reconnect trigger client in ${delay / 1e3} seconds... (Attempt ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS})`
-    );
-    await new Promise((resolve2) => setTimeout(resolve2, delay));
-    this.reconnectAttempts++;
+  }
+  async runQuery(query, options, requesterDetails) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
+`;
+    const startTime = process.hrtime();
     try {
-      await this.listenForDbTriggers();
-      this.reconnectAttempts = 0;
+      const response = await this.query(queryMetadata + formattedQuery, options);
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
+      return response.rows;
     } catch (error) {
-      logger.error(`Reconnection attempt ${this.reconnectAttempts} failed: ${error}`);
-      if (this.reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS) {
-        await this.reconnectTriggerClient();
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
+      if (error?.routine === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
       }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
     }
   }
-  async listenForDbTriggers() {
-    this.triggerClient = new Client({
-      user: this.psqlConnectionPool.poolConfig.user,
-      host: this.psqlConnectionPool.poolConfig.host,
-      database: this.psqlConnectionPool.poolConfig.database,
-      password: this.psqlConnectionPool.poolConfig.password,
-      port: this.psqlConnectionPool.poolConfig.port,
-      connectionTimeoutMillis: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
-    });
+  async runQuerySchema(query, params, requesterDetails, zodSchema) {
+    const result = await this.runQuery(query, params, requesterDetails);
     try {
-      await this.triggerClient.connect();
-      const promises = [];
-      promises.push(this.triggerClient.query("LISTEN insert"));
-      promises.push(this.triggerClient.query("LISTEN update"));
-      promises.push(this.triggerClient.query("LISTEN delete"));
-      await Promise.all(promises);
-      this.triggerClient.on("error", async (error) => {
-        logger.error(`Trigger client error: ${error}`);
-        await this.reconnectTriggerClient();
-      });
-      this.triggerClient.on("notification", async (msg) => {
-        if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
-          const payload = ObjectUtils3.safeParse(msg.payload);
-          await this.handleTrigger(payload, msg.channel.toUpperCase());
-        }
-      });
-      logger.info("Successfully connected to database triggers");
+      return z4.array(zodSchema).parse(result);
     } catch (error) {
-      logger.error(`Failed to setup trigger listeners: ${error}`);
-      await this.reconnectTriggerClient();
+      if (error instanceof z4.ZodError) {
+        logger.error("Invalid data returned from database:");
+        logger.trace("\n" + JSON.stringify(result, null, 2));
+        logger.error("\n" + z4.prettifyError(error));
+      } else {
+        logger.error(error);
+      }
+      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
     }
   }
-  async handleTrigger(payload, mutationType) {
-    if (payload.queryMetadata && payload.queryMetadata.connectionInstanceId === this.psqlConnectionPool.instanceId) {
-      await eventManager_default.fireActionFromDbTrigger({ queryMetadata: payload.queryMetadata, mutationType }, payload);
+  logSqlStatement(query, options, queryMetadata, startTime, prefix = "") {
+    if (logger.level !== "trace") return;
+    const sqlStatement = query.replace(/\$(\d+)/g, (_, num) => {
+      const paramIndex = parseInt(num) - 1;
+      if (paramIndex >= options.length) return "INVALID_PARAM_INDEX";
+      return toSqlLiteral(options[paramIndex]);
+    });
+    const formattedSql = sqlFormat(sqlStatement, {
+      language: "postgresql",
+      linesBetweenQueries: 2,
+      indentStyle: "standard",
+      keywordCase: "upper",
+      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.trace(`${prefix}query by ${initiator}, Query ->
+${formattedSql}`, {
+      durationMs
+    });
+  }
+};
+
+// src/restura/sql/PsqlPool.ts
+var { Pool } = pg;
+var PsqlPool = class extends PsqlConnection {
+  constructor(poolConfig) {
+    super();
+    this.poolConfig = poolConfig;
+    if (poolConfig.connectionString) {
+      let url;
+      try {
+        url = new URL(poolConfig.connectionString);
+      } catch {
+        throw new Error(`Invalid connectionString: ${poolConfig.connectionString}`);
+      }
+      poolConfig.host = url.hostname;
+      poolConfig.port = url.port ? parseInt(url.port) : 5432;
+      poolConfig.user = url.username;
+      poolConfig.password = url.password;
+      poolConfig.database = url.pathname.replace(/^\//, "");
     }
+    this.pool = new Pool(poolConfig);
+    this.queryOne("SELECT NOW();", [], {
+      isSystemUser: true,
+      role: "",
+      host: "localhost",
+      ipAddress: "",
+      scopes: []
+    }).then(() => {
+      logger.info("Connected to PostgreSQL database");
+    }).catch((error) => {
+      logger.error("Error connecting to database", error);
+      process.exit(1);
+    });
   }
-  async createDatabaseFromSchema(schema, connection) {
-    const sqlFullStatement = this.generateDatabaseSchemaFromSchema(schema);
-    await connection.runQuery(sqlFullStatement, [], systemUser);
-    return sqlFullStatement;
+  pool;
+  async query(query, values) {
+    return this.pool.query(query, values);
   }
-  generateDatabaseSchemaFromSchema(schema) {
-    const sqlStatements = [];
-    const indexes = [];
-    const triggers = [];
-    for (const table of schema.database) {
-      if (table.notify) {
-        triggers.push(this.createInsertTriggers(table.name, table.notify));
-        triggers.push(this.createUpdateTrigger(table.name, table.notify));
-        triggers.push(this.createDeleteTrigger(table.name, table.notify));
-      }
-      let sql = `CREATE TABLE "${table.name}"
-					   ( `;
-      const tableColumns = [];
-      for (const column of table.columns) {
-        let columnSql = "";
-        columnSql += `	"${column.name}" ${this.schemaToPsqlType(column)}`;
-        let value = column.value;
-        if (column.type === "JSON") value = "";
-        if (column.type === "JSONB") value = "";
-        if (column.type === "DECIMAL" && value) {
-          value = value.replace("-", ",").replace(/['"]/g, "");
-        }
-        if (value && column.type !== "ENUM") {
-          columnSql += `(${value})`;
-        } else if (column.length) columnSql += `(${column.length})`;
-        if (column.isPrimary) {
-          columnSql += " PRIMARY KEY ";
-        }
-        if (column.isUnique) {
-          columnSql += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE `;
-        }
-        if (column.isNullable) columnSql += " NULL";
-        else columnSql += " NOT NULL";
-        if (column.default) columnSql += ` DEFAULT ${column.default}`;
-        if (value && column.type === "ENUM") {
-          columnSql += ` CHECK ("${column.name}" IN (${value}))`;
-        }
-        tableColumns.push(columnSql);
-      }
-      sql += tableColumns.join(", \n");
-      for (const index of table.indexes) {
-        if (!index.isPrimaryKey) {
-          let unique = " ";
-          if (index.isUnique) unique = "UNIQUE ";
-          let indexSQL = `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}"`;
-          indexSQL += ` (${index.columns.map((item) => `"${item}" ${index.order}`).join(", ")})`;
-          indexSQL += index.where ? ` WHERE ${index.where}` : "";
-          indexSQL += ";";
-          indexes.push(indexSQL);
-        }
+};
+
+// src/restura/sql/psqlSchemaUtils.ts
+var { Client } = pg2;
+var systemUser = {
+  role: "",
+  scopes: [],
+  host: "",
+  ipAddress: "",
+  isSystemUser: true
+};
+function schemaToPsqlType(column) {
+  if (column.hasAutoIncrement) return "BIGSERIAL";
+  if (column.type === "ENUM") return "TEXT";
+  if (column.type === "DATETIME") return "TIMESTAMPTZ";
+  if (column.type === "MEDIUMINT") return "INT";
+  return column.type;
+}
+function createInsertTriggerSql(tableName, notify) {
+  if (!notify) return "";
+  if (notify === "ALL") {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'insert',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'insertedId', NEW.id,
+						'record', NEW
+		)::text
+		);
+
+	RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_insert"
+	AFTER INSERT ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+`;
+  }
+  const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
+  return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'insert',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'insertedId', NEW.id,
+						'record', json_build_object(
+							${notifyColumnNewBuildString}
+						)
+		)::text
+		);
+
+	RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_insert"
+	AFTER INSERT ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+`;
+}
+function createUpdateTriggerSql(tableName, notify) {
+  if (!notify) return "";
+  if (notify === "ALL") {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_update()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+				(regexp_match(
+						current_query(),
+						'^--QUERY_METADATA\\(({.*})', 'n'
+				))[1]::json;
+
+	PERFORM pg_notify(
+		'update',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'changedId', NEW.id,
+						'record', NEW,
+						'previousRecord', OLD
+		)::text
+		);
+	RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER ${tableName}_update
+	AFTER UPDATE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+`;
+  }
+  const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
+  const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
+  return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_update()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+				(regexp_match(
+						current_query(),
+						'^--QUERY_METADATA\\(({.*})', 'n'
+				))[1]::json;
+
+	PERFORM pg_notify(
+		'update',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'changedId', NEW.id,
+						'record', json_build_object(
+							${notifyColumnNewBuildString}
+						),
+						'previousRecord', json_build_object(
+							${notifyColumnOldBuildString}
+						)
+		)::text
+		);
+	RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER ${tableName}_update
+	AFTER UPDATE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+		`;
+}
+function createDeleteTriggerSql(tableName, notify) {
+  if (!notify) return "";
+  if (notify === "ALL") {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'delete',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'deletedId', OLD.id,
+						'previousRecord', OLD
+		)::text
+		);
+	RETURN OLD;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_delete"
+	AFTER DELETE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_delete();
+`;
+  }
+  const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
+  return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'delete',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'deletedId', OLD.id,
+						'previousRecord', json_build_object(
+							${notifyColumnOldBuildString}
+						)
+		)::text
+		);
+	RETURN OLD;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_delete"
+	AFTER DELETE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_delete();
+		`;
+}
+function generateDatabaseSchemaFromSchema(schema) {
+  const sqlStatements = [];
+  const indexes = [];
+  const triggers = [];
+  for (const table of schema.database) {
+    if (table.notify) {
+      triggers.push(createInsertTriggerSql(table.name, table.notify));
+      triggers.push(createUpdateTriggerSql(table.name, table.notify));
+      triggers.push(createDeleteTriggerSql(table.name, table.notify));
+    }
+    let sql = `CREATE TABLE "${table.name}"
+				   ( `;
+    const tableColumns = [];
+    for (const column of table.columns) {
+      let columnSql = "";
+      columnSql += `	"${column.name}" ${schemaToPsqlType(column)}`;
+      let value = column.value;
+      if (column.type === "JSON") value = "";
+      if (column.type === "JSONB") value = "";
+      if (column.type === "DECIMAL" && value) {
+        value = value.replace("-", ",").replace(/['"]/g, "");
+      }
+      if (value && column.type !== "ENUM") {
+        columnSql += `(${value})`;
+      } else if (column.length) columnSql += `(${column.length})`;
+      if (column.isPrimary) {
+        columnSql += " PRIMARY KEY ";
+      }
+      if (column.isUnique) {
+        columnSql += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE `;
+      }
+      if (column.isNullable) columnSql += " NULL";
+      else columnSql += " NOT NULL";
+      if (column.default) columnSql += ` DEFAULT ${column.default}`;
+      if (value && column.type === "ENUM") {
+        columnSql += ` CHECK ("${column.name}" IN (${value}))`;
+      }
+      tableColumns.push(columnSql);
+    }
+    sql += tableColumns.join(", \n");
+    for (const index of table.indexes) {
+      if (!index.isPrimaryKey) {
+        let unique = " ";
+        if (index.isUnique) unique = "UNIQUE ";
+        let indexSQL = `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}"`;
+        indexSQL += ` (${index.columns.map((item) => `"${item}" ${index.order}`).join(", ")})`;
+        indexSQL += index.where ? ` WHERE ${index.where}` : "";
+        indexSQL += ";";
+        indexes.push(indexSQL);
       }
-      sql += "\n);";
-      sqlStatements.push(sql);
     }
-    for (const table of schema.database) {
-      if (!table.foreignKeys.length) continue;
-      const sql = `ALTER TABLE "${table.name}" `;
-      const constraints = [];
-      for (const foreignKey of table.foreignKeys) {
-        let constraint = `	 ADD CONSTRAINT "${foreignKey.name}"
+    sql += "\n);";
+    sqlStatements.push(sql);
+  }
+  for (const table of schema.database) {
+    if (!table.foreignKeys.length) continue;
+    const sql = `ALTER TABLE "${table.name}" `;
+    const constraints = [];
+    for (const foreignKey of table.foreignKeys) {
+      let constraint = `	 ADD CONSTRAINT "${foreignKey.name}"
         FOREIGN KEY ("${foreignKey.column}") REFERENCES "${foreignKey.refTable}" ("${foreignKey.refColumn}")`;
-        constraint += ` ON DELETE ${foreignKey.onDelete}`;
-        constraint += ` ON UPDATE ${foreignKey.onUpdate}`;
-        constraints.push(constraint);
-      }
-      sqlStatements.push(sql + constraints.join(",\n") + ";");
-    }
-    for (const table of schema.database) {
-      if (!table.checkConstraints.length) continue;
-      const sql = `ALTER TABLE "${table.name}" `;
-      const constraints = [];
-      for (const check of table.checkConstraints) {
-        const constraint = `ADD CONSTRAINT "${check.name}" CHECK (${check.check})`;
-        constraints.push(constraint);
-      }
-      sqlStatements.push(sql + constraints.join(",\n") + ";");
-    }
-    sqlStatements.push(indexes.join("\n"));
-    sqlStatements.push(triggers.join("\n"));
-    return sqlStatements.join("\n\n");
-  }
-  async getNewPublicSchemaAndScratchPool() {
-    const scratchDbExists = await this.psqlConnectionPool.runQuery(
-      `SELECT *
-             FROM pg_database
-             WHERE datname = '${this.scratchDbName}';`,
-      [],
-      systemUser
+      constraint += ` ON DELETE ${foreignKey.onDelete}`;
+      constraint += ` ON UPDATE ${foreignKey.onUpdate}`;
+      constraints.push(constraint);
+    }
+    sqlStatements.push(sql + constraints.join(",\n") + ";");
+  }
+  for (const table of schema.database) {
+    if (!table.checkConstraints.length) continue;
+    const sql = `ALTER TABLE "${table.name}" `;
+    const constraints = [];
+    for (const check of table.checkConstraints) {
+      const constraint = `ADD CONSTRAINT "${check.name}" CHECK (${check.check})`;
+      constraints.push(constraint);
+    }
+    sqlStatements.push(sql + constraints.join(",\n") + ";");
+  }
+  sqlStatements.push(indexes.join("\n"));
+  sqlStatements.push(triggers.join("\n"));
+  return sqlStatements.join("\n\n");
+}
+async function getNewPublicSchemaAndScratchPool(targetPool, scratchDbName) {
+  const scratchDbExists = await targetPool.runQuery(
+    `SELECT * FROM pg_database WHERE datname = ?;`,
+    [scratchDbName],
+    systemUser
+  );
+  if (scratchDbExists.length === 0) {
+    await targetPool.runQuery(`CREATE DATABASE ${escapeColumnName(scratchDbName)};`, [], systemUser);
+  }
+  const scratchPool = new PsqlPool({
+    host: targetPool.poolConfig.host,
+    port: targetPool.poolConfig.port,
+    user: targetPool.poolConfig.user,
+    database: scratchDbName,
+    password: targetPool.poolConfig.password,
+    max: targetPool.poolConfig.max,
+    idleTimeoutMillis: targetPool.poolConfig.idleTimeoutMillis,
+    connectionTimeoutMillis: targetPool.poolConfig.connectionTimeoutMillis
+  });
+  await scratchPool.runQuery(`DROP SCHEMA public CASCADE;`, [], systemUser);
+  await scratchPool.runQuery(`CREATE SCHEMA public AUTHORIZATION ${escapeColumnName(targetPool.poolConfig.user)};`, [], systemUser);
+  const schemaComment = await targetPool.runQuery(
+    `
+		SELECT pg_description.description
+		FROM pg_description
+		JOIN pg_namespace ON pg_namespace.oid = pg_description.objoid
+		WHERE pg_namespace.nspname = 'public';`,
+    [],
+    systemUser
+  );
+  if (schemaComment[0]?.description) {
+    await scratchPool.runQuery(`COMMENT ON SCHEMA public IS $1;`, [schemaComment[0].description], systemUser);
+  }
+  return scratchPool;
+}
+async function diffDatabaseToSchema(schema, targetPool, scratchDbName) {
+  let scratchPool;
+  let originalClient;
+  let scratchClient;
+  try {
+    scratchPool = await getNewPublicSchemaAndScratchPool(targetPool, scratchDbName);
+    const sqlFullStatement = generateDatabaseSchemaFromSchema(schema);
+    await scratchPool.runQuery(sqlFullStatement, [], systemUser);
+    const connectionConfig = {
+      host: targetPool.poolConfig.host,
+      port: targetPool.poolConfig.port,
+      user: targetPool.poolConfig.user,
+      password: targetPool.poolConfig.password,
+      ssl: targetPool.poolConfig.ssl
+    };
+    originalClient = new Client({ ...connectionConfig, database: targetPool.poolConfig.database });
+    scratchClient = new Client({ ...connectionConfig, database: scratchDbName });
+    await Promise.all([originalClient.connect(), scratchClient.connect()]);
+    const [info1, info2] = await Promise.all([
+      pgInfo({ client: originalClient }),
+      pgInfo({ client: scratchClient })
+    ]);
+    const diff = getDiff(info1, info2);
+    return diff.join("\n");
+  } finally {
+    const cleanups = [];
+    if (originalClient) cleanups.push(originalClient.end());
+    if (scratchClient) cleanups.push(scratchClient.end());
+    if (scratchPool) cleanups.push(scratchPool.pool.end());
+    await Promise.allSettled(cleanups);
+  }
+}
+
+// src/restura/sql/PsqlEngine.ts
+var { Client: Client2, types } = pg3;
+var PsqlEngine = class extends SqlEngine {
+  // 5 seconds
+  constructor(psqlConnectionPool, shouldListenForDbTriggers = false, scratchDatabaseSuffix = "") {
+    super();
+    this.psqlConnectionPool = psqlConnectionPool;
+    this.setupPgReturnTypes();
+    if (shouldListenForDbTriggers) {
+      this.setupTriggerListeners = this.listenForDbTriggers();
+    }
+    this.scratchDbName = `${psqlConnectionPool.poolConfig.database}_scratch${scratchDatabaseSuffix ? `_${scratchDatabaseSuffix}` : ""}`;
+  }
+  setupTriggerListeners;
+  triggerClient;
+  scratchDbName = "";
+  reconnectAttempts = 0;
+  MAX_RECONNECT_ATTEMPTS = 5;
+  INITIAL_RECONNECT_DELAY = 5e3;
+  async close() {
+    if (this.triggerClient) {
+      await this.triggerClient.end();
+    }
+  }
+  /**
+   * Setup the return types for the PostgreSQL connection.
+   * For example return DATE as a string instead of a Date object and BIGINT as a number instead of a string.
+   */
+  setupPgReturnTypes() {
+    const PG_TYPE_OID = {
+      BIGINT: 20,
+      DATE: 1082,
+      TIME: 1083,
+      TIMESTAMP: 1114,
+      TIMESTAMPTZ: 1184,
+      TIMETZ: 1266
+    };
+    types.setTypeParser(PG_TYPE_OID.BIGINT, (val) => val === null ? null : Number(val));
+    types.setTypeParser(PG_TYPE_OID.DATE, (val) => val);
+    types.setTypeParser(PG_TYPE_OID.TIME, (val) => val);
+    types.setTypeParser(PG_TYPE_OID.TIMETZ, (val) => val);
+    types.setTypeParser(PG_TYPE_OID.TIMESTAMP, (val) => val === null ? null : new Date(val).toISOString());
+    types.setTypeParser(PG_TYPE_OID.TIMESTAMPTZ, (val) => val === null ? null : new Date(val).toISOString());
+  }
+  async reconnectTriggerClient() {
+    if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
+      logger.error("Max reconnection attempts reached for trigger client. Stopping reconnection attempts.");
+      return;
+    }
+    if (this.triggerClient) {
+      try {
+        await this.triggerClient.end();
+      } catch (error) {
+        logger.error(`Error closing trigger client: ${error}`);
+      }
+    }
+    const delay = this.INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts);
+    logger.info(
+      `Attempting to reconnect trigger client in ${delay / 1e3} seconds... (Attempt ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS})`
     );
-    if (scratchDbExists.length === 0) {
-      await this.psqlConnectionPool.runQuery(`CREATE DATABASE ${this.scratchDbName};`, [], systemUser);
+    await new Promise((resolve2) => setTimeout(resolve2, delay));
+    this.reconnectAttempts++;
+    try {
+      await this.listenForDbTriggers();
+      this.reconnectAttempts = 0;
+    } catch (error) {
+      logger.error(`Reconnection attempt ${this.reconnectAttempts} failed: ${error}`);
+      if (this.reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS) {
+        await this.reconnectTriggerClient();
+      }
     }
-    const scratchPool = new PsqlPool({
-      host: this.psqlConnectionPool.poolConfig.host,
-      port: this.psqlConnectionPool.poolConfig.port,
+  }
+  async listenForDbTriggers() {
+    this.triggerClient = new Client2({
       user: this.psqlConnectionPool.poolConfig.user,
-      database: this.scratchDbName,
+      host: this.psqlConnectionPool.poolConfig.host,
+      database: this.psqlConnectionPool.poolConfig.database,
       password: this.psqlConnectionPool.poolConfig.password,
-      max: this.psqlConnectionPool.poolConfig.max,
-      idleTimeoutMillis: this.psqlConnectionPool.poolConfig.idleTimeoutMillis,
+      port: this.psqlConnectionPool.poolConfig.port,
       connectionTimeoutMillis: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
     });
-    await scratchPool.runQuery(`DROP SCHEMA public CASCADE;`, [], systemUser);
-    await scratchPool.runQuery(
-      `CREATE SCHEMA public AUTHORIZATION ${this.psqlConnectionPool.poolConfig.user};`,
-      [],
-      systemUser
-    );
-    const schemaComment = await this.psqlConnectionPool.runQuery(
-      `
-			SELECT pg_description.description
-			FROM pg_description
-			JOIN pg_namespace ON pg_namespace.oid = pg_description.objoid
-			WHERE pg_namespace.nspname = 'public';`,
-      [],
-      systemUser
-    );
-    if (schemaComment[0]?.description) {
-      await scratchPool.runQuery(
-        `COMMENT ON SCHEMA public IS '${schemaComment[0]?.description}';`,
-        [],
-        systemUser
-      );
+    try {
+      await this.triggerClient.connect();
+      const promises = [];
+      promises.push(this.triggerClient.query("LISTEN insert"));
+      promises.push(this.triggerClient.query("LISTEN update"));
+      promises.push(this.triggerClient.query("LISTEN delete"));
+      await Promise.all(promises);
+      this.triggerClient.on("error", async (error) => {
+        logger.error(`Trigger client error: ${error}`);
+        await this.reconnectTriggerClient();
+      });
+      this.triggerClient.on("notification", async (msg) => {
+        if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
+          const payload = ObjectUtils3.safeParse(msg.payload);
+          await this.handleTrigger(payload, msg.channel.toUpperCase());
+        }
+      });
+      logger.info("Successfully connected to database triggers");
+    } catch (error) {
+      logger.error(`Failed to setup trigger listeners: ${error}`);
+      await this.reconnectTriggerClient();
+    }
+  }
+  async handleTrigger(payload, mutationType) {
+    if (payload.queryMetadata && payload.queryMetadata.connectionInstanceId === this.psqlConnectionPool.instanceId) {
+      await eventManager_default.fireActionFromDbTrigger({ queryMetadata: payload.queryMetadata, mutationType }, payload);
     }
-    return scratchPool;
+  }
+  async createDatabaseFromSchema(schema, connection) {
+    const sqlFullStatement = this.generateDatabaseSchemaFromSchema(schema);
+    await connection.runQuery(sqlFullStatement, [], systemUser);
+    return sqlFullStatement;
+  }
+  generateDatabaseSchemaFromSchema(schema) {
+    return generateDatabaseSchemaFromSchema(schema);
   }
   async diffDatabaseToSchema(schema) {
-    const scratchPool = await this.getNewPublicSchemaAndScratchPool();
-    await this.createDatabaseFromSchema(schema, scratchPool);
-    const originalClient = new Client({
-      database: this.psqlConnectionPool.poolConfig.database,
-      user: this.psqlConnectionPool.poolConfig.user,
-      password: this.psqlConnectionPool.poolConfig.password,
-      host: this.psqlConnectionPool.poolConfig.host,
-      port: this.psqlConnectionPool.poolConfig.port
-    });
-    const scratchClient = new Client({
-      database: this.scratchDbName,
-      user: this.psqlConnectionPool.poolConfig.user,
-      password: this.psqlConnectionPool.poolConfig.password,
-      host: this.psqlConnectionPool.poolConfig.host,
-      port: this.psqlConnectionPool.poolConfig.port
-    });
-    const promises = [originalClient.connect(), scratchClient.connect()];
-    await Promise.all(promises);
-    const infoPromises = [pgInfo({ client: originalClient }), pgInfo({ client: scratchClient })];
-    const [info1, info2] = await Promise.all(infoPromises);
-    const diff = getDiff(info1, info2);
-    const endPromises = [originalClient.end(), scratchClient.end()];
-    await Promise.all(endPromises);
-    return diff.join("\n");
+    return diffDatabaseToSchema(schema, this.psqlConnectionPool, this.scratchDbName);
   }
   createNestedSelect(req, schema, item, routeData, sqlParams) {
     if (!item.subquery) return "";
@@ -3112,316 +3288,98 @@ DELETE FROM "${routeData.table}" ${joinStatement} ${whereClause}`;
     });
     return joinStatements;
   }
-  generateGroupBy(routeData) {
-    let groupBy = "";
-    if (routeData.groupBy) {
-      groupBy = `GROUP BY ${escapeColumnName(routeData.groupBy.tableName)}.${escapeColumnName(routeData.groupBy.columnName)}
-`;
-    }
-    return groupBy;
-  }
-  generateOrderBy(req, routeData) {
-    let orderBy = "";
-    const orderOptions = {
-      ASC: "ASC",
-      DESC: "DESC"
-    };
-    const data = req.data;
-    if (routeData.type === "PAGED" && "sortBy" in data) {
-      const sortOrder = orderOptions[data.sortOrder] || "ASC";
-      orderBy = `ORDER BY ${escapeColumnName(data.sortBy)} ${sortOrder}
-`;
-    } else if (routeData.orderBy) {
-      const sortOrder = orderOptions[routeData.orderBy.order] || "ASC";
-      orderBy = `ORDER BY ${escapeColumnName(routeData.orderBy.tableName)}.${escapeColumnName(routeData.orderBy.columnName)} ${sortOrder}
-`;
-    }
-    return orderBy;
-  }
-  generateWhereClause(req, where, routeData, sqlParams) {
-    let whereClause = "";
-    where.forEach((item, index) => {
-      if (index === 0) whereClause = "WHERE ";
-      if (item.custom) {
-        const customReplaced = this.replaceParamKeywords(item.custom, routeData, req, sqlParams);
-        whereClause += `	${item.conjunction || ""} ${customReplaced}
-`;
-        return;
-      }
-      if (item.operator === void 0 || item.value === void 0 || item.columnName === void 0 || item.tableName === void 0)
-        throw new RsError(
-          "SCHEMA_ERROR",
-          `Invalid where clause in route ${routeData.name}, missing required fields if not custom`
-        );
-      let operator = item.operator;
-      let value = item.value;
-      if (operator === "LIKE") {
-        value = `'%' || ${value} || '%'`;
-      } else if (operator === "NOT LIKE") {
-        value = `'%' || ${value} || '%'`;
-      } else if (operator === "STARTS WITH") {
-        operator = "LIKE";
-        value = `${value} || '%'`;
-      } else if (operator === "ENDS WITH") {
-        operator = "LIKE";
-        value = `'%' || ${value}`;
-      }
-      const replacedValue = this.replaceParamKeywords(value, routeData, req, sqlParams);
-      whereClause += `	${item.conjunction || ""} "${item.tableName}"."${item.columnName}" ${operator.replace("LIKE", "ILIKE")} ${["IN", "NOT IN"].includes(operator) ? `(${replacedValue})` : replacedValue}
-`;
-    });
-    const data = req.data;
-    if (routeData.type === "PAGED" && !!data?.filter) {
-      let statement = data.filter.replace(/\$[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
-        const requestParam = routeData.request.find((item) => {
-          return item.name === value.replace("$", "");
-        });
-        if (!requestParam)
-          throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
-        return data[requestParam.name]?.toString() || "";
-      });
-      statement = statement.replace(/#[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
-        const requestParam = routeData.request.find((item) => {
-          return item.name === value.replace("#", "");
-        });
-        if (!requestParam)
-          throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
-        return data[requestParam.name]?.toString() || "";
-      });
-      const parseResult = filterPsqlParser_default.parse(statement);
-      if (parseResult.usedOldSyntax) {
-        logger.warn(
-          `Deprecated filter syntax detected in route "${routeData.name}" (${routeData.path}). Please migrate to the new filter syntax.`
-        );
-      }
-      statement = parseResult.sql;
-      if (whereClause.startsWith("WHERE")) {
-        whereClause += ` AND (${statement})
-`;
-      } else {
-        whereClause += `WHERE ${statement}
-`;
-      }
-    }
-    return whereClause;
-  }
-  createUpdateTrigger(tableName, notify) {
-    if (!notify) return "";
-    if (notify === "ALL") {
-      return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_update()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-				(regexp_match(
-						current_query(),
-						'^--QUERY_METADATA\\(({.*})', 'n'
-				))[1]::json;
-
-	PERFORM pg_notify(
-		'update',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'changedId', NEW.id,
-						'record', NEW,
-						'previousRecord', OLD
-		)::text
-		);
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE TRIGGER ${tableName}_update
-	AFTER UPDATE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_update();
-`;
-    }
-    const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
-    const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
-    return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_update()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-				(regexp_match(
-						current_query(),
-						'^--QUERY_METADATA\\(({.*})', 'n'
-				))[1]::json;
-
-	PERFORM pg_notify(
-		'update',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'changedId', NEW.id,
-						'record', json_build_object(
-							${notifyColumnNewBuildString}
-						),
-						'previousRecord', json_build_object(
-							${notifyColumnOldBuildString}
-						)
-		)::text
-		);
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE TRIGGER ${tableName}_update
-	AFTER UPDATE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_update();
-		`;
-  }
-  createDeleteTrigger(tableName, notify) {
-    if (!notify) return "";
-    if (notify === "ALL") {
-      return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
-
-	PERFORM pg_notify(
-		'delete',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'deletedId', OLD.id,
-						'previousRecord', OLD
-		)::text
-		);
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE TRIGGER "${tableName}_delete"
-	AFTER DELETE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_delete();
-`;
-    }
-    const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
-    return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
-
-	PERFORM pg_notify(
-		'delete',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'deletedId', OLD.id,
-						'previousRecord', json_build_object(
-							${notifyColumnOldBuildString}
-						)
-		)::text
-		);
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE TRIGGER "${tableName}_delete"
-	AFTER DELETE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_delete();
-		`;
-  }
-  createInsertTriggers(tableName, notify) {
-    if (!notify) return "";
-    if (notify === "ALL") {
-      return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
-
-	PERFORM pg_notify(
-		'insert',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'insertedId', NEW.id,
-						'record', NEW
-		)::text
-		);
-
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE TRIGGER "${tableName}_insert"
-	AFTER INSERT ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_insert();
+  generateGroupBy(routeData) {
+    let groupBy = "";
+    if (routeData.groupBy) {
+      groupBy = `GROUP BY ${escapeColumnName(routeData.groupBy.tableName)}.${escapeColumnName(routeData.groupBy.columnName)}
 `;
     }
-    const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
-    return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
-
-	PERFORM pg_notify(
-		'insert',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'insertedId', NEW.id,
-						'record', json_build_object(
-							${notifyColumnNewBuildString}
-						)
-		)::text
-		);
-
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE TRIGGER "${tableName}_insert"
-	AFTER INSERT ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_insert();
+    return groupBy;
+  }
+  generateOrderBy(req, routeData) {
+    let orderBy = "";
+    const orderOptions = {
+      ASC: "ASC",
+      DESC: "DESC"
+    };
+    const data = req.data;
+    if (routeData.type === "PAGED" && "sortBy" in data) {
+      const sortOrder = orderOptions[data.sortOrder] || "ASC";
+      orderBy = `ORDER BY ${escapeColumnName(data.sortBy)} ${sortOrder}
+`;
+    } else if (routeData.orderBy) {
+      const sortOrder = orderOptions[routeData.orderBy.order] || "ASC";
+      orderBy = `ORDER BY ${escapeColumnName(routeData.orderBy.tableName)}.${escapeColumnName(routeData.orderBy.columnName)} ${sortOrder}
 `;
+    }
+    return orderBy;
   }
-  schemaToPsqlType(column) {
-    if (column.hasAutoIncrement) return "BIGSERIAL";
-    if (column.type === "ENUM") return `TEXT`;
-    if (column.type === "DATETIME") return "TIMESTAMPTZ";
-    if (column.type === "MEDIUMINT") return "INT";
-    return column.type;
+  generateWhereClause(req, where, routeData, sqlParams) {
+    let whereClause = "";
+    where.forEach((item, index) => {
+      if (index === 0) whereClause = "WHERE ";
+      if (item.custom) {
+        const customReplaced = this.replaceParamKeywords(item.custom, routeData, req, sqlParams);
+        whereClause += `	${item.conjunction || ""} ${customReplaced}
+`;
+        return;
+      }
+      if (item.operator === void 0 || item.value === void 0 || item.columnName === void 0 || item.tableName === void 0)
+        throw new RsError(
+          "SCHEMA_ERROR",
+          `Invalid where clause in route ${routeData.name}, missing required fields if not custom`
+        );
+      let operator = item.operator;
+      let value = item.value;
+      if (operator === "LIKE") {
+        value = `'%' || ${value} || '%'`;
+      } else if (operator === "NOT LIKE") {
+        value = `'%' || ${value} || '%'`;
+      } else if (operator === "STARTS WITH") {
+        operator = "LIKE";
+        value = `${value} || '%'`;
+      } else if (operator === "ENDS WITH") {
+        operator = "LIKE";
+        value = `'%' || ${value}`;
+      }
+      const replacedValue = this.replaceParamKeywords(value, routeData, req, sqlParams);
+      whereClause += `	${item.conjunction || ""} "${item.tableName}"."${item.columnName}" ${operator.replace("LIKE", "ILIKE")} ${["IN", "NOT IN"].includes(operator) ? `(${replacedValue})` : replacedValue}
+`;
+    });
+    const data = req.data;
+    if (routeData.type === "PAGED" && !!data?.filter) {
+      let statement = data.filter.replace(/\$[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
+        const requestParam = routeData.request.find((item) => {
+          return item.name === value.replace("$", "");
+        });
+        if (!requestParam)
+          throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
+        return data[requestParam.name]?.toString() || "";
+      });
+      statement = statement.replace(/#[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
+        const requestParam = routeData.request.find((item) => {
+          return item.name === value.replace("#", "");
+        });
+        if (!requestParam)
+          throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
+        return data[requestParam.name]?.toString() || "";
+      });
+      const parseResult = filterPsqlParser_default.parse(statement);
+      if (parseResult.usedOldSyntax) {
+        logger.warn(
+          `Deprecated filter syntax detected in route "${routeData.name}" (${routeData.path}). Please migrate to the new filter syntax.`
+        );
+      }
+      statement = parseResult.sql;
+      if (whereClause.startsWith("WHERE")) {
+        whereClause += ` AND (${statement})
+`;
+      } else {
+        whereClause += `WHERE ${statement}
+`;
+      }
+    }
+    return whereClause;
   }
 };
 
@@ -3498,8 +3456,9 @@ var ResturaEngine = class {
    * @param app - The Express application instance to initialize with Restura.
    * @returns A promise that resolves when the initialization is complete.
    */
-  async init(app, authenticationHandler, psqlConnectionPool) {
-    this.resturaConfig = await config2.validate("restura", resturaConfigSchema);
+  async init(app, authenticationHandler, psqlConnectionPool, options) {
+    if (options?.logger) setLogger(options.logger);
+    this.resturaConfig = await config.validate("restura", resturaConfigSchema);
     this.multerCommonUpload = getMulterUpload(this.resturaConfig.fileTempCachePath);
     new TempCache(this.resturaConfig.fileTempCachePath);
     this.psqlConnectionPool = psqlConnectionPool;
@@ -3853,14 +3812,556 @@ __decorateClass([
 ], ResturaEngine.prototype, "runCustomRouteLogic", 1);
 var restura = new ResturaEngine();
 
+// src/restura/sql/psqlIntrospect.ts
+var RESTURA_TO_PG_UDT = {
+  BIGSERIAL: "int8",
+  SERIAL: "int4",
+  BIGINT: "int8",
+  INTEGER: "int4",
+  INT: "int4",
+  SMALLINT: "int2",
+  DECIMAL: "numeric",
+  NUMERIC: "numeric",
+  REAL: "float4",
+  "DOUBLE PRECISION": "float8",
+  FLOAT: "float8",
+  DOUBLE: "float8",
+  BOOLEAN: "bool",
+  TEXT: "text",
+  VARCHAR: "varchar",
+  CHAR: "bpchar",
+  BYTEA: "bytea",
+  JSON: "json",
+  JSONB: "jsonb",
+  DATE: "date",
+  TIME: "time",
+  TIMESTAMP: "timestamp",
+  TIMESTAMPTZ: "timestamptz",
+  INTERVAL: "interval",
+  ENUM: "text",
+  DATETIME: "timestamptz",
+  MEDIUMINT: "int4",
+  TINYINT: "int2"
+};
+function resturaTypeToUdt(column) {
+  const psqlType = schemaToPsqlType(column);
+  return RESTURA_TO_PG_UDT[psqlType] ?? psqlType.toLowerCase();
+}
+var PG_FK_ACTION = {
+  a: "NO ACTION",
+  r: "RESTRICT",
+  c: "CASCADE",
+  n: "SET NULL",
+  d: "SET DEFAULT"
+};
+async function introspectDatabase(pool) {
+  const [tableRows, columnRows, indexRows, fkRows, checkRows] = await Promise.all([
+    pool.runQuery(
+      `SELECT table_name
+			 FROM information_schema.tables
+			 WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+			 ORDER BY table_name`,
+      [],
+      systemUser
+    ),
+    pool.runQuery(
+      `SELECT table_name, column_name, udt_name, is_nullable, column_default,
+			        character_maximum_length, numeric_precision, numeric_scale
+			 FROM information_schema.columns
+			 WHERE table_schema = 'public'
+			 ORDER BY table_name, ordinal_position`,
+      [],
+      systemUser
+    ),
+    pool.runQuery(
+      `SELECT pi.tablename, pi.indexname, pi.indexdef, ix.indisprimary
+			 FROM pg_indexes pi
+			 JOIN pg_class ic ON ic.relname = pi.indexname
+			 JOIN pg_index ix ON ix.indexrelid = ic.oid
+			 WHERE pi.schemaname = 'public'
+			 ORDER BY pi.tablename, pi.indexname`,
+      [],
+      systemUser
+    ),
+    pool.runQuery(
+      `SELECT
+				constraint_def.conname AS constraint_name,
+				source_table.relname AS table_name,
+				source_column.attname AS column_name,
+				referenced_table.relname AS ref_table,
+				referenced_column.attname AS ref_column,
+				constraint_def.confdeltype AS delete_rule,
+				constraint_def.confupdtype AS update_rule
+			 FROM pg_constraint constraint_def
+			 JOIN pg_class source_table ON source_table.oid = constraint_def.conrelid
+			 JOIN pg_namespace schema_ns ON schema_ns.oid = source_table.relnamespace
+			 JOIN pg_class referenced_table ON referenced_table.oid = constraint_def.confrelid
+			 JOIN pg_attribute source_column ON source_column.attrelid = constraint_def.conrelid AND source_column.attnum = ANY(constraint_def.conkey)
+			 JOIN pg_attribute referenced_column ON referenced_column.attrelid = constraint_def.confrelid AND referenced_column.attnum = ANY(constraint_def.confkey)
+			 WHERE constraint_def.contype = 'f' AND schema_ns.nspname = 'public'
+			 ORDER BY source_table.relname, constraint_def.conname`,
+      [],
+      systemUser
+    ),
+    pool.runQuery(
+      `SELECT
+				constraint_def.conname AS constraint_name,
+				parent_table.relname AS table_name,
+				pg_get_constraintdef(constraint_def.oid) AS check_clause
+			 FROM pg_constraint constraint_def
+			 JOIN pg_class parent_table ON parent_table.oid = constraint_def.conrelid
+			 JOIN pg_namespace schema_ns ON schema_ns.oid = parent_table.relnamespace
+			 WHERE constraint_def.contype = 'c' AND schema_ns.nspname = 'public'
+			   AND constraint_def.conname NOT LIKE '%_not_null'
+			 ORDER BY parent_table.relname, constraint_def.conname`,
+      [],
+      systemUser
+    )
+  ]);
+  const tableMap = /* @__PURE__ */ new Map();
+  for (const row of tableRows) {
+    tableMap.set(row.table_name, {
+      name: row.table_name,
+      columns: [],
+      indexes: [],
+      foreignKeys: [],
+      checkConstraints: []
+    });
+  }
+  for (const row of columnRows) {
+    const table = tableMap.get(row.table_name);
+    if (!table) continue;
+    table.columns.push({
+      name: row.column_name,
+      udtName: row.udt_name,
+      isNullable: row.is_nullable === "YES",
+      columnDefault: row.column_default,
+      characterMaximumLength: row.character_maximum_length,
+      numericPrecision: row.numeric_precision,
+      numericScale: row.numeric_scale
+    });
+  }
+  for (const row of indexRows) {
+    const table = tableMap.get(row.tablename);
+    if (!table) continue;
+    const isPrimary = row.indisprimary;
+    const unique = /CREATE UNIQUE INDEX/i.test(row.indexdef);
+    const order = row.indexdef.toUpperCase().includes(" DESC") ? "DESC" : "ASC";
+    const columnMatch = row.indexdef.match(/\((.+?)\)(?:\s+WHERE\s+(.+))?$/i);
+    const columns = columnMatch ? columnMatch[1].split(",").map(
+      (colExpr) => colExpr.trim().replace(/^"(.*)"$/, "$1").replace(/\s+(ASC|DESC)$/i, "")
+    ) : [];
+    const whereClause = columnMatch?.[2] ?? null;
+    table.indexes.push({
+      name: row.indexname,
+      tableName: row.tablename,
+      isUnique: unique,
+      isPrimary,
+      columns,
+      order,
+      where: whereClause
+    });
+  }
+  for (const row of fkRows) {
+    const table = tableMap.get(row.table_name);
+    if (!table) continue;
+    table.foreignKeys.push({
+      name: row.constraint_name,
+      tableName: row.table_name,
+      column: row.column_name,
+      refTable: row.ref_table,
+      refColumn: row.ref_column,
+      onDelete: PG_FK_ACTION[row.delete_rule] ?? "NO ACTION",
+      onUpdate: PG_FK_ACTION[row.update_rule] ?? "NO ACTION"
+    });
+  }
+  for (const row of checkRows) {
+    const table = tableMap.get(row.table_name);
+    if (!table) continue;
+    table.checkConstraints.push({
+      name: row.constraint_name,
+      tableName: row.table_name,
+      expression: row.check_clause
+    });
+  }
+  return { tables: Array.from(tableMap.values()) };
+}
+function diffSchemaToDatabase(schema, snapshot) {
+  const statements = [];
+  const desiredTables = new Map(schema.database.map((table) => [table.name, table]));
+  const liveTableMap = new Map(snapshot.tables.map((table) => [table.name, table]));
+  const tablesToCreate = schema.database.filter((table) => !liveTableMap.has(table.name));
+  const tablesToDrop = snapshot.tables.filter((table) => !desiredTables.has(table.name));
+  const tablesToAlter = schema.database.filter((table) => liveTableMap.has(table.name));
+  const changedChecksPerTable = /* @__PURE__ */ new Map();
+  for (const desired of tablesToAlter) {
+    const live = liveTableMap.get(desired.name);
+    const desiredFkNames = new Set(desired.foreignKeys.map((fk) => fk.name));
+    for (const liveFk of live.foreignKeys) {
+      if (!desiredFkNames.has(liveFk.name) || isFkChanged(desired, liveFk)) {
+        statements.push(`ALTER TABLE "${desired.name}" DROP CONSTRAINT "${liveFk.name}";`);
+      }
+    }
+    const desiredCheckExprMap = /* @__PURE__ */ new Map();
+    for (const check of desired.checkConstraints) {
+      desiredCheckExprMap.set(check.name, check.check);
+    }
+    for (const col of desired.columns) {
+      if (col.type === "ENUM" && col.value) {
+        desiredCheckExprMap.set(`${desired.name}_${col.name}_check`, `"${col.name}" IN (${col.value})`);
+      }
+    }
+    const changedChecks = /* @__PURE__ */ new Set();
+    for (const liveCheck of live.checkConstraints) {
+      if (!desiredCheckExprMap.has(liveCheck.name)) {
+        statements.push(`ALTER TABLE "${desired.name}" DROP CONSTRAINT "${liveCheck.name}";`);
+      } else if (normalizeCheckExpression(desiredCheckExprMap.get(liveCheck.name)) !== normalizeCheckExpression(liveCheck.expression)) {
+        statements.push(`ALTER TABLE "${desired.name}" DROP CONSTRAINT "${liveCheck.name}";`);
+        changedChecks.add(liveCheck.name);
+      }
+    }
+    changedChecksPerTable.set(desired.name, changedChecks);
+    const desiredIdxSignatures = /* @__PURE__ */ new Map();
+    for (const idx of desired.indexes) {
+      if (idx.isPrimaryKey) continue;
+      desiredIdxSignatures.set(idx.name, indexSignature(idx.name, idx.columns, idx.isUnique, idx.order, idx.where));
+    }
+    const autoUniqueNames = /* @__PURE__ */ new Set();
+    for (const col of desired.columns) {
+      if (col.isUnique) {
+        autoUniqueNames.add(`${desired.name}_${col.name}_unique_index`);
+      }
+    }
+    for (const liveIdx of live.indexes) {
+      if (liveIdx.isPrimary) continue;
+      if (autoUniqueNames.has(liveIdx.name)) continue;
+      const liveSig = indexSignature(liveIdx.name, liveIdx.columns, liveIdx.isUnique, liveIdx.order, liveIdx.where);
+      const desiredSig = desiredIdxSignatures.get(liveIdx.name);
+      if (!desiredSig || desiredSig !== liveSig) {
+        statements.push(`DROP INDEX "${liveIdx.name}";`);
+      }
+    }
+    diffColumns(desired, live, statements);
+  }
+  for (const table of tablesToDrop) {
+    statements.push(`DROP TABLE "${table.name}";`);
+  }
+  const { sorted: sortedTablesToCreate, deferredFkNames } = topologicalSortTables(tablesToCreate);
+  for (const table of sortedTablesToCreate) {
+    statements.push(buildCreateTable(table, deferredFkNames));
+  }
+  for (const table of sortedTablesToCreate) {
+    for (const index of table.indexes) {
+      if (!index.isPrimaryKey) {
+        statements.push(buildCreateIndex(table.name, index));
+      }
+    }
+  }
+  for (const desired of tablesToAlter) {
+    const live = liveTableMap.get(desired.name);
+    const liveIdxSignatures = /* @__PURE__ */ new Map();
+    for (const idx of live.indexes) {
+      liveIdxSignatures.set(idx.name, indexSignature(idx.name, idx.columns, idx.isUnique, idx.order, idx.where));
+    }
+    for (const index of desired.indexes) {
+      if (index.isPrimaryKey) continue;
+      const desiredSig = indexSignature(index.name, index.columns, index.isUnique, index.order, index.where);
+      const liveSig = liveIdxSignatures.get(index.name);
+      if (!liveSig || liveSig !== desiredSig) {
+        statements.push(buildCreateIndex(desired.name, index));
+      }
+    }
+  }
+  for (const table of sortedTablesToCreate) {
+    for (const fk of table.foreignKeys) {
+      if (deferredFkNames.has(fk.name)) {
+        statements.push(buildAddForeignKey(table.name, fk));
+      }
+    }
+  }
+  for (const desired of tablesToAlter) {
+    const live = liveTableMap.get(desired.name);
+    const liveFkNames = new Set(live.foreignKeys.map((fk) => fk.name));
+    for (const fk of desired.foreignKeys) {
+      if (!liveFkNames.has(fk.name) || isFkChanged(
+        desired,
+        liveTableMap.get(desired.name).foreignKeys.find((liveFk) => liveFk.name === fk.name)
+      )) {
+        statements.push(buildAddForeignKey(desired.name, fk));
+      }
+    }
+  }
+  for (const desired of tablesToAlter) {
+    const live = liveTableMap.get(desired.name);
+    const liveCheckNames = new Set(live.checkConstraints.map((check) => check.name));
+    const changedChecks = changedChecksPerTable.get(desired.name) ?? /* @__PURE__ */ new Set();
+    for (const check of desired.checkConstraints) {
+      if (!liveCheckNames.has(check.name) || changedChecks.has(check.name)) {
+        statements.push(buildAddCheckConstraint(desired.name, check));
+      }
+    }
+    for (const col of desired.columns) {
+      if (col.type === "ENUM" && col.value) {
+        const checkName = `${desired.name}_${col.name}_check`;
+        if (!liveCheckNames.has(checkName) || changedChecks.has(checkName)) {
+          statements.push(
+            `ALTER TABLE "${desired.name}" ADD CONSTRAINT "${checkName}" CHECK ("${col.name}" IN (${col.value}));`
+          );
+        }
+      }
+    }
+  }
+  return statements;
+}
+function diffColumns(desired, live, statements) {
+  const liveColMap = new Map(live.columns.map((col) => [col.name, col]));
+  const desiredColNames = new Set(desired.columns.map((col) => col.name));
+  for (const liveCol of live.columns) {
+    if (!desiredColNames.has(liveCol.name)) {
+      statements.push(`ALTER TABLE "${desired.name}" DROP COLUMN "${liveCol.name}";`);
+    }
+  }
+  for (const column of desired.columns) {
+    const liveColumn = liveColMap.get(column.name);
+    if (!liveColumn) {
+      statements.push(buildAddColumn(desired.name, column));
+      continue;
+    }
+    const desiredUdt = resturaTypeToUdt(column);
+    const udtMismatch = liveColumn.udtName !== desiredUdt && !isSerialMatch(column, liveColumn);
+    if (udtMismatch || !udtMismatch && modifiersDiffer(column, liveColumn)) {
+      const pgType = resturaTypeToPgCast(column);
+      statements.push(
+        `ALTER TABLE "${desired.name}" ALTER COLUMN "${column.name}" TYPE ${pgType} USING "${column.name}"::${pgType};`
+      );
+    }
+    if (column.isNullable && !liveColumn.isNullable) {
+      statements.push(`ALTER TABLE "${desired.name}" ALTER COLUMN "${column.name}" DROP NOT NULL;`);
+    } else if (!column.isNullable && liveColumn.isNullable) {
+      statements.push(`ALTER TABLE "${desired.name}" ALTER COLUMN "${column.name}" SET NOT NULL;`);
+    }
+    const desiredDefault = getDesiredDefault(column);
+    const liveDefault = liveColumn.columnDefault;
+    if (!defaultsMatch(desiredDefault, liveDefault, column)) {
+      if (desiredDefault === null) {
+        statements.push(`ALTER TABLE "${desired.name}" ALTER COLUMN "${column.name}" DROP DEFAULT;`);
+      } else {
+        statements.push(
+          `ALTER TABLE "${desired.name}" ALTER COLUMN "${column.name}" SET DEFAULT ${desiredDefault};`
+        );
+      }
+    }
+  }
+}
+function topologicalSortTables(tables) {
+  const tableNames = new Set(tables.map((t) => t.name));
+  const tableMap = new Map(tables.map((t) => [t.name, t]));
+  const inDegree = /* @__PURE__ */ new Map();
+  const tableDeps = /* @__PURE__ */ new Map();
+  const reverseDeps = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    inDegree.set(table.name, 0);
+    tableDeps.set(table.name, /* @__PURE__ */ new Set());
+    reverseDeps.set(table.name, /* @__PURE__ */ new Set());
+  }
+  for (const table of tables) {
+    for (const fk of table.foreignKeys) {
+      if (tableNames.has(fk.refTable) && fk.refTable !== table.name && !tableDeps.get(table.name).has(fk.refTable)) {
+        tableDeps.get(table.name).add(fk.refTable);
+        inDegree.set(table.name, (inDegree.get(table.name) ?? 0) + 1);
+        reverseDeps.get(fk.refTable).add(table.name);
+      }
+    }
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) queue.push(name);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    sorted.push(name);
+    for (const dependent of reverseDeps.get(name) ?? []) {
+      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) queue.push(dependent);
+    }
+  }
+  const sortedSet = new Set(sorted);
+  const deferredFkNames = /* @__PURE__ */ new Set();
+  const cycleTables = tables.filter((t) => !sortedSet.has(t.name));
+  const placed = new Set(sorted);
+  for (const table of cycleTables) {
+    sorted.push(table.name);
+    for (const fk of table.foreignKeys) {
+      if (fk.refTable !== table.name && tableNames.has(fk.refTable) && !placed.has(fk.refTable)) {
+        deferredFkNames.add(fk.name);
+      }
+    }
+    placed.add(table.name);
+  }
+  return { sorted: sorted.map((name) => tableMap.get(name)), deferredFkNames };
+}
+function buildCreateTable(table, deferredFkNames = /* @__PURE__ */ new Set()) {
+  const definitions = [];
+  for (const column of table.columns) {
+    let definition = `"${column.name}" ${buildColumnType(column)}`;
+    if (column.isPrimary) definition += " PRIMARY KEY";
+    if (column.isUnique) definition += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE`;
+    if (!column.isNullable) definition += " NOT NULL";
+    else definition += " NULL";
+    if (column.default) definition += ` DEFAULT ${column.default}`;
+    definitions.push(definition);
+  }
+  for (const fk of table.foreignKeys) {
+    if (deferredFkNames.has(fk.name)) continue;
+    definitions.push(
+      `CONSTRAINT "${fk.name}" FOREIGN KEY ("${fk.column}") REFERENCES "${fk.refTable}" ("${fk.refColumn}") ON DELETE ${fk.onDelete} ON UPDATE ${fk.onUpdate}`
+    );
+  }
+  for (const check of table.checkConstraints) {
+    definitions.push(`CONSTRAINT "${check.name}" CHECK (${check.check})`);
+  }
+  for (const col of table.columns) {
+    if (col.type === "ENUM" && col.value) {
+      definitions.push(
+        `CONSTRAINT "${table.name}_${col.name}_check" CHECK ("${col.name}" IN (${col.value}))`
+      );
+    }
+  }
+  return `CREATE TABLE "${table.name}" (
+	${definitions.join(",\n	")}
+);`;
+}
+function buildColumnType(column) {
+  const baseType = schemaToPsqlType(column);
+  let value = column.value;
+  if (column.type === "JSON" || column.type === "JSONB") value = "";
+  if (column.type === "DECIMAL" && value) {
+    value = value.replace("-", ",").replace(/['"]/g, "");
+  }
+  if (value && column.type !== "ENUM") {
+    return `${baseType}(${value})`;
+  }
+  if (column.length) return `${baseType}(${column.length})`;
+  return baseType;
+}
+function buildAddColumn(tableName, column) {
+  let definition = `ALTER TABLE "${tableName}" ADD COLUMN "${column.name}" ${buildColumnType(column)}`;
+  if (column.isPrimary) definition += " PRIMARY KEY";
+  if (column.isUnique) definition += ` CONSTRAINT "${tableName}_${column.name}_unique_index" UNIQUE`;
+  if (!column.isNullable) definition += " NOT NULL";
+  else definition += " NULL";
+  if (column.default) definition += ` DEFAULT ${column.default}`;
+  definition += ";";
+  return definition;
+}
+function buildCreateIndex(tableName, index) {
+  const unique = index.isUnique ? "UNIQUE " : "";
+  let sql = `CREATE ${unique}INDEX "${index.name}" ON "${tableName}" (${index.columns.map((column) => `"${column}" ${index.order}`).join(", ")})`;
+  if (index.where) sql += ` WHERE ${index.where}`;
+  sql += ";";
+  return sql;
+}
+function buildAddForeignKey(tableName, foreignKey) {
+  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${foreignKey.name}" FOREIGN KEY ("${foreignKey.column}") REFERENCES "${foreignKey.refTable}" ("${foreignKey.refColumn}") ON DELETE ${foreignKey.onDelete} ON UPDATE ${foreignKey.onUpdate};`;
+}
+function buildAddCheckConstraint(tableName, constraint) {
+  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${constraint.name}" CHECK (${constraint.check});`;
+}
+function indexSignature(name, columns, isUnique, order, where) {
+  return `${name}|${columns.join(",")}|${isUnique}|${order}|${where || ""}`;
+}
+function isFkChanged(desired, liveFk) {
+  const desiredFk = desired.foreignKeys.find((fk) => fk.name === liveFk.name);
+  if (!desiredFk) return true;
+  return desiredFk.column !== liveFk.column || desiredFk.refTable !== liveFk.refTable || desiredFk.refColumn !== liveFk.refColumn || desiredFk.onDelete !== liveFk.onDelete || desiredFk.onUpdate !== liveFk.onUpdate;
+}
+function normalizeCheckExpression(expr) {
+  let s = expr;
+  const checkMatch = s.match(/^CHECK\s*\(([\s\S]*)\)\s*$/i);
+  if (checkMatch) s = checkMatch[1];
+  s = s.replace(/::\w+(\[\])?/g, "");
+  s = s.replace(/=\s*ANY\s*\(\s*\(?\s*ARRAY\s*\[([^\]]*)\]\s*\)?\s*\)/gi, "IN ($1)");
+  s = s.replace(/"(\w+)"/g, "$1");
+  s = s.replace(/\((\w+)\)/g, "$1");
+  s = s.replace(/\s+/g, " ").trim().toLowerCase();
+  while (s.startsWith("(") && s.endsWith(")")) {
+    const inner = s.slice(1, -1);
+    let depth = 0;
+    let balanced = true;
+    for (const char of inner) {
+      if (char === "(") depth++;
+      if (char === ")") depth--;
+      if (depth < 0) {
+        balanced = false;
+        break;
+      }
+    }
+    if (balanced && depth === 0) s = inner.trim();
+    else break;
+  }
+  s = s.replace(/\s*,\s*/g, ", ");
+  return s;
+}
+function isSerialMatch(column, liveCol) {
+  if (column.hasAutoIncrement || column.type === "BIGSERIAL" || column.type === "SERIAL") {
+    const serialUdt = column.type === "SERIAL" ? "int4" : "int8";
+    return liveCol.udtName === serialUdt && liveCol.columnDefault?.startsWith("nextval(") === true;
+  }
+  return false;
+}
+function modifiersDiffer(column, liveColumn) {
+  const desiredLength = column.length ?? null;
+  if (desiredLength !== liveColumn.characterMaximumLength) return true;
+  if (column.type === "DECIMAL" && column.value) {
+    const parts = column.value.replace(/['"]/g, "").split("-");
+    const desiredPrecision = parseInt(parts[0], 10);
+    const desiredScale = parts.length > 1 ? parseInt(parts[1], 10) : 0;
+    if (liveColumn.numericPrecision !== desiredPrecision || liveColumn.numericScale !== desiredScale) return true;
+  }
+  return false;
+}
+function resturaTypeToPgCast(column) {
+  const baseType = schemaToPsqlType(column);
+  const castMap = {
+    BIGSERIAL: "BIGINT",
+    SERIAL: "INTEGER",
+    INT: "INTEGER",
+    TIMESTAMPTZ: "TIMESTAMPTZ",
+    TIMESTAMP: "TIMESTAMP",
+    "DOUBLE PRECISION": "DOUBLE PRECISION"
+  };
+  let pgType = castMap[baseType] ?? baseType;
+  let value = column.value;
+  if (column.type === "DECIMAL" && value) {
+    value = value.replace("-", ",").replace(/['"]/g, "");
+    pgType = `${pgType}(${value})`;
+  } else if (column.length) {
+    pgType = `${pgType}(${column.length})`;
+  }
+  return pgType;
+}
+function getDesiredDefault(column) {
+  if (column.hasAutoIncrement || column.type === "BIGSERIAL" || column.type === "SERIAL") return null;
+  return column.default ?? null;
+}
+function defaultsMatch(desired, live, column) {
+  if (column.hasAutoIncrement || column.type === "BIGSERIAL" || column.type === "SERIAL") return true;
+  if (desired === null && live === null) return true;
+  if (desired === null || live === null) return false;
+  const normalizedLive = live.replace(/::[^\s]+$/g, "").trim();
+  return desired.trim() === normalizedLive;
+}
+
 // src/restura/sql/PsqlTransaction.ts
-import pg3 from "pg";
-var { Client: Client2 } = pg3;
+import pg4 from "pg";
+var { Client: Client3 } = pg4;
 var PsqlTransaction = class extends PsqlConnection {
   constructor(clientConfig, instanceId) {
     super(instanceId);
     this.clientConfig = clientConfig;
-    this.client = new Client2(clientConfig);
+    this.client = new Client3(clientConfig);
     this.connectPromise = this.client.connect();
     this.beginTransactionPromise = this.beginTransaction();
   }
@@ -3900,10 +4401,18 @@ export {
   RsError,
   SQL,
   apiGenerator,
+  createDeleteTriggerSql,
+  createInsertTriggerSql,
+  createUpdateTriggerSql,
+  diffDatabaseToSchema,
+  diffSchemaToDatabase,
   escapeColumnName,
   eventManager_default as eventManager,
   filterPsqlParser_default as filterPsqlParser,
+  generateDatabaseSchemaFromSchema,
+  getNewPublicSchemaAndScratchPool,
   insertObjectQuery,
+  introspectDatabase,
   isSchemaValid,
   isValueNumber,
   logger,
@@ -3912,6 +4421,9 @@ export {
   restura,
   resturaGlobalTypesGenerator,
   resturaSchema,
+  schemaToPsqlType,
+  setLogger,
+  systemUser,
   toSqlLiteral,
   updateObjectQuery
 };