@grupodiariodaregiao/bunstone 0.7.0 → 0.7.1

package/dist/index.d.ts

@@ -33,6 +33,7 @@ export * from "./lib/cqrs/interfaces/event.interface";
 export * from "./lib/cqrs/interfaces/query.interface";
 export * from "./lib/cqrs/query-bus";
 export { SqlModule, SqlService } from "./lib/database/sql-module";
+export type { SqlConnectionOptions, SqlPoolOptions, SqlRegisterOptions, } from "./lib/database/sql-module";
 export { BullMqModule } from "./lib/bullmq/bullmq-module";
 export { QueueService } from "./lib/bullmq/queue.service";
 export * from "./lib/bullmq/decorators/processor.decorator";

package/dist/index.js

@@ -13473,7 +13473,7 @@ var require_tracestate_impl = __commonJS((exports) => {
           const value = listMember.slice(i + 1, part.length);
           if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
             agg.set(key, value);
-          } else {}
+          }
         }
         return agg;
       }, new Map);
@@ -103227,7 +103227,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -103475,7 +103475,7 @@ var literalProcessor = (schema, ctx, json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -109939,8 +109939,6 @@ if (!nativeAccelerationDisabled) {
   try {
     if (true)
       extractor = require_msgpackr_extract();
-    else
-      ;
     if (extractor)
       setExtractor(extractor.extractStrings);
   } catch (error48) {}
@@ -123877,7 +123875,7 @@ class AppStartup {
       for (const timeout of timeouts) {
         AppStartup.logger.log(`Scheduling timeout for method: ${timeout.methodName} with delay: ${timeout.delay}ms`);
         setTimeout(() => {
-          provider[timeout.methodName]();
+          AppStartup.invokeScheduledHandler(provider, timeout.methodName, "timeout");
         }, timeout.delay);
       }
     }
@@ -123894,11 +123892,24 @@ class AppStartup {
       for (const cron of crons) {
         AppStartup.logger.log(`Scheduling cron for method: ${cron.methodName}`);
         import_node_cron.default.schedule(cron.expression, () => {
-          provider[cron.methodName]();
+          AppStartup.invokeScheduledHandler(provider, cron.methodName, "cron");
         });
       }
     }
   }
+  static async invokeScheduledHandler(provider, methodName, kind) {
+    const handler = provider[methodName];
+    if (typeof handler !== "function") {
+      AppStartup.logger.error(`${kind === "cron" ? "Cron" : "Timeout"} job "${methodName}" is not a method on the provider`);
+      return;
+    }
+    try {
+      const result = handler.call(provider);
+      await Promise.resolve(result);
+    } catch (err) {
+      AppStartup.logger.error(`${kind === "cron" ? "Cron" : "Timeout"} job "${methodName}" failed`, err);
+    }
+  }
   static registerBullMqWorkers(module) {
     const providersBullMq = Reflect.getMetadata("dip:bullmq", module);
     if (!providersBullMq) {
@@ -124420,6 +124431,10 @@ CqrsModule = __legacyDecorateClassTS([
 // lib/database/sql-module.ts
 var import_api5 = __toESM(require_src(), 1);
 var {SQL } = globalThis.Bun;
+var CONNECTION_CLOSED_CODES = new Set([
+  "ERR_MYSQL_CONNECTION_CLOSED",
+  "ERR_POSTGRES_CONNECTION_CLOSED"
+]);
 function detectProvider(url2) {
   if (url2.startsWith("mysql://") || url2.startsWith("mysql2://")) {
     return "mysql";
@@ -124439,9 +124454,47 @@ function buildConnectionConfig(provider, timezone) {
   }
   return;
 }
+function pickPoolOptions(source) {
+  if (!source) {
+    return;
+  }
+  const pool = {};
+  if (source.max !== undefined)
+    pool.max = source.max;
+  if (source.idleTimeout !== undefined)
+    pool.idleTimeout = source.idleTimeout;
+  if (source.maxLifetime !== undefined)
+    pool.maxLifetime = source.maxLifetime;
+  if (source.connectionTimeout !== undefined) {
+    pool.connectionTimeout = source.connectionTimeout;
+  }
+  return Object.keys(pool).length > 0 ? pool : undefined;
+}
+function isConnectionClosedError(err) {
+  return typeof err === "object" && err !== null && "code" in err && CONNECTION_CLOSED_CODES.has(String(err.code));
+}
+async function withConnectionRetry(fn3) {
+  try {
+    return await fn3();
+  } catch (err) {
+    if (!isConnectionClosedError(err)) {
+      throw err;
+    }
+  }
+  return await fn3();
+}
 
 class SqlService {
   async query(query, params) {
+    return withConnectionRetry(() => this.executeQuery(query, params));
+  }
+  async transaction(queries) {
+    return withConnectionRetry(() => this.executeTransaction(queries));
+  }
+  async bulkInsert(table, values) {
+    return withConnectionRetry(() => this.executeBulkInsert(table, values));
+  }
+  async executeQuery(query, params) {
     const sql = this.getSqlInstance();
     const tracer = import_api5.trace.getTracer("bunstone.db");
     const operation = detectOperation(query);
@@ -124468,7 +124521,7 @@ class SqlService {
       }
     });
   }
-  async transaction(queries) {
+  async executeTransaction(queries) {
     const sql = this.getSqlInstance();
     const tracer = import_api5.trace.getTracer("bunstone.db");
     const span = tracer.startSpan("db.transaction", {
@@ -124497,7 +124550,7 @@ class SqlService {
       }
     });
   }
-  async bulkInsert(table, values) {
+  async executeBulkInsert(table, values) {
     const sql = this.getSqlInstance();
     const tracer = import_api5.trace.getTracer("bunstone.db");
     const span = tracer.startSpan("db.INSERT", {
@@ -124538,14 +124591,28 @@ SqlService = __legacyDecorateClassTS([
 class SqlModule {
   static sqlInstance;
   static provider;
-  static register(connection2, timezone) {
+  static register(connection2, second) {
     const url2 = typeof connection2 === "string" ? connection2 : `${connection2.provider}://${connection2.username}:${connection2.password}@${connection2.host}:${connection2.port}/${connection2.database}`;
     const provider = typeof connection2 === "string" ? detectProvider(connection2) : connection2.provider;
     SqlModule.provider = provider;
-    const tz = typeof connection2 === "string" ? timezone ?? "UTC" : connection2.timezone ?? "UTC";
-    const connectionConfig = buildConnectionConfig(provider, tz);
+    let timezone = "UTC";
+    let poolOptions;
+    if (typeof connection2 === "string") {
+      if (typeof second === "string") {
+        timezone = second;
+      } else if (second) {
+        timezone = second.timezone ?? "UTC";
+        poolOptions = pickPoolOptions(second);
+      }
+    } else {
+      timezone = connection2.timezone ?? "UTC";
+      poolOptions = pickPoolOptions(connection2);
+    }
+    const connectionConfig = buildConnectionConfig(provider, timezone);
+    const pool = poolOptions ?? {};
     SqlModule.sqlInstance = new SQL({
       url: url2,
+      ...pool,
       ...connectionConfig && { connection: connectionConfig }
     });
     return SqlModule;

package/dist/lib/app-startup.d.ts

@@ -86,6 +86,7 @@ export declare class AppStartup {
     private static buildEffectiveRateLimit;
     private static registerTimeouts;
     private static registerCronJobs;
+    private static invokeScheduledHandler;
     private static registerBullMqWorkers;
     /**
      * Sets up RabbitMQ consumers for every provider that has `@RabbitSubscribe`

package/dist/lib/database/sql-module.d.ts

@@ -1,5 +1,21 @@
 import { SQL } from "bun";
-type ConnectionOptions = {
+export type SqlPoolOptions = {
+    /** Maximum connections in the pool. Bun default: 10 */
+    max?: number;
+    /**
+     * Seconds before closing idle pool connections. Bun default: 0 (no limit).
+     * For MariaDB/MySQL, set below the server `wait_timeout` (often 28800 = 8h).
+     */
+    idleTimeout?: number;
+    /**
+     * Max connection lifetime in seconds. Bun default: 0 (no limit).
+     * Forces periodic reconnection before the server drops stale sockets.
+     */
+    maxLifetime?: number;
+    /** Seconds to wait when opening a new connection. Bun default: 30 */
+    connectionTimeout?: number;
+};
+export type SqlConnectionOptions = SqlPoolOptions & {
     host: string;
     port: number;
     username: string;
@@ -13,6 +29,9 @@ type ConnectionOptions = {
      */
     timezone?: string;
 };
+export type SqlRegisterOptions = SqlPoolOptions & {
+    timezone?: string;
+};
 type Provider = "postgresql" | "mysql" | "sqlite";
 export declare class SqlService {
     query<T = any>(query: string, params?: any[]): Promise<T[]>;
@@ -21,13 +40,17 @@ export declare class SqlService {
         params?: any[];
     }>): Promise<void>;
     bulkInsert<T = any>(table: string, values: T[]): Promise<void>;
+    private executeQuery;
+    private executeTransaction;
+    private executeBulkInsert;
     private getSqlInstance;
 }
 export declare class SqlModule {
     private static sqlInstance;
     private static provider;
-    static register(connection: ConnectionOptions): typeof SqlModule;
+    static register(connection: SqlConnectionOptions): typeof SqlModule;
     static register(connection: string, timezone?: string): typeof SqlModule;
+    static register(connection: string, options: SqlRegisterOptions): typeof SqlModule;
     static getSqlInstance(): SQL;
     static getProvider(): Provider | undefined;
 }

package/lib/app-startup.ts

@@ -906,7 +906,11 @@ export class AppStartup {
 					`Scheduling timeout for method: ${timeout.methodName} with delay: ${timeout.delay}ms`,
 				);
 				setTimeout(() => {
-					provider[timeout.methodName]();
+					void AppStartup.invokeScheduledHandler(
+						provider,
+						timeout.methodName,
+						"timeout",
+					);
 				}, timeout.delay);
 			}
 		}
@@ -935,12 +939,40 @@ export class AppStartup {
 			for (const cron of crons) {
 				AppStartup.logger.log(`Scheduling cron for method: ${cron.methodName}`);
 				scheduler.schedule(cron.expression, () => {
-					provider[cron.methodName]();
+					void AppStartup.invokeScheduledHandler(
+						provider,
+						cron.methodName,
+						"cron",
+					);
 				});
 			}
 		}
 	}
 
+	private static async invokeScheduledHandler(
+		provider: Record<string, unknown>,
+		methodName: string,
+		kind: "cron" | "timeout",
+	): Promise<void> {
+		const handler = provider[methodName];
+		if (typeof handler !== "function") {
+			AppStartup.logger.error(
+				`${kind === "cron" ? "Cron" : "Timeout"} job "${methodName}" is not a method on the provider`,
+			);
+			return;
+		}
+
+		try {
+			const result = handler.call(provider);
+			await Promise.resolve(result);
+		} catch (err) {
+			AppStartup.logger.error(
+				`${kind === "cron" ? "Cron" : "Timeout"} job "${methodName}" failed`,
+				err,
+			);
+		}
+	}
+
 	private static registerBullMqWorkers(module: any) {
 		const providersBullMq: Map<any, { name?: string; methodName: string }[]> =
 			Reflect.getMetadata("dip:bullmq", module);

package/lib/database/sql-module.ts

@@ -9,7 +9,24 @@ import { DatabaseError } from "../errors";
 import { Injectable } from "../injectable";
 import { Module } from "../module";
 
-type ConnectionOptions = {
+export type SqlPoolOptions = {
+	/** Maximum connections in the pool. Bun default: 10 */
+	max?: number;
+	/**
+	 * Seconds before closing idle pool connections. Bun default: 0 (no limit).
+	 * For MariaDB/MySQL, set below the server `wait_timeout` (often 28800 = 8h).
+	 */
+	idleTimeout?: number;
+	/**
+	 * Max connection lifetime in seconds. Bun default: 0 (no limit).
+	 * Forces periodic reconnection before the server drops stale sockets.
+	 */
+	maxLifetime?: number;
+	/** Seconds to wait when opening a new connection. Bun default: 30 */
+	connectionTimeout?: number;
+};
+
+export type SqlConnectionOptions = SqlPoolOptions & {
 	host: string;
 	port: number;
 	username: string;
@@ -24,8 +41,17 @@ type ConnectionOptions = {
 	timezone?: string;
 };
 
+export type SqlRegisterOptions = SqlPoolOptions & {
+	timezone?: string;
+};
+
 type Provider = "postgresql" | "mysql" | "sqlite";
 
+const CONNECTION_CLOSED_CODES = new Set([
+	"ERR_MYSQL_CONNECTION_CLOSED",
+	"ERR_POSTGRES_CONNECTION_CLOSED",
+]);
+
 function detectProvider(url: string): Provider {
 	if (url.startsWith("mysql://") || url.startsWith("mysql2://")) {
 		return "mysql";
@@ -57,9 +83,65 @@ function buildConnectionConfig(
 	return undefined;
 }
 
+function pickPoolOptions(
+	source: SqlPoolOptions | undefined,
+): SqlPoolOptions | undefined {
+	if (!source) {
+		return undefined;
+	}
+
+	const pool: SqlPoolOptions = {};
+	if (source.max !== undefined) pool.max = source.max;
+	if (source.idleTimeout !== undefined) pool.idleTimeout = source.idleTimeout;
+	if (source.maxLifetime !== undefined) pool.maxLifetime = source.maxLifetime;
+	if (source.connectionTimeout !== undefined) {
+		pool.connectionTimeout = source.connectionTimeout;
+	}
+
+	return Object.keys(pool).length > 0 ? pool : undefined;
+}
+
+function isConnectionClosedError(err: unknown): boolean {
+	return (
+		typeof err === "object" &&
+		err !== null &&
+		"code" in err &&
+		CONNECTION_CLOSED_CODES.has(String((err as { code: unknown }).code))
+	);
+}
+
+async function withConnectionRetry<T>(fn: () => Promise<T>): Promise<T> {
+	try {
+		return await fn();
+	} catch (err) {
+		if (!isConnectionClosedError(err)) {
+			throw err;
+		}
+	}
+
+	return await fn();
+}
+
 @Injectable()
 export class SqlService {
 	async query<T = any>(query: string, params?: any[]): Promise<T[]> {
+		return withConnectionRetry(() => this.executeQuery<T>(query, params));
+	}
+
+	async transaction(
+		queries: Array<{ query: string; params?: any[] }>,
+	): Promise<void> {
+		return withConnectionRetry(() => this.executeTransaction(queries));
+	}
+
+	async bulkInsert<T = any>(table: string, values: T[]): Promise<void> {
+		return withConnectionRetry(() => this.executeBulkInsert(table, values));
+	}
+
+	private async executeQuery<T>(
+		query: string,
+		params?: any[],
+	): Promise<T[]> {
 		const sql = this.getSqlInstance();
 		const tracer = trace.getTracer("bunstone.db");
 		const operation = detectOperation(query);
@@ -91,7 +173,7 @@ export class SqlService {
 		);
 	}
 
-	async transaction(
+	private async executeTransaction(
 		queries: Array<{ query: string; params?: any[] }>,
 	): Promise<void> {
 		const sql = this.getSqlInstance();
@@ -127,7 +209,7 @@ export class SqlService {
 		);
 	}
 
-	async bulkInsert<T = any>(table: string, values: T[]): Promise<void> {
+	private async executeBulkInsert<T>(table: string, values: T[]): Promise<void> {
 		const sql = this.getSqlInstance();
 		const tracer = trace.getTracer("bunstone.db");
 		const span = tracer.startSpan("db.INSERT", {
@@ -175,9 +257,16 @@ export class SqlModule {
 	private static sqlInstance: SQL;
 	private static provider: Provider | undefined;
 
-	static register(connection: ConnectionOptions): typeof SqlModule;
+	static register(connection: SqlConnectionOptions): typeof SqlModule;
 	static register(connection: string, timezone?: string): typeof SqlModule;
-	static register(connection: string | ConnectionOptions, timezone?: string) {
+	static register(
+		connection: string,
+		options: SqlRegisterOptions,
+	): typeof SqlModule;
+	static register(
+		connection: string | SqlConnectionOptions,
+		second?: string | SqlRegisterOptions,
+	) {
 		const url =
 			typeof connection === "string"
 				? connection
@@ -190,15 +279,27 @@ export class SqlModule {
 
 		SqlModule.provider = provider;
 
-		const tz =
-			typeof connection === "string"
-				? (timezone ?? "UTC")
-				: (connection.timezone ?? "UTC");
+		let timezone = "UTC";
+		let poolOptions: SqlPoolOptions | undefined;
+
+		if (typeof connection === "string") {
+			if (typeof second === "string") {
+				timezone = second;
+			} else if (second) {
+				timezone = second.timezone ?? "UTC";
+				poolOptions = pickPoolOptions(second);
+			}
+		} else {
+			timezone = connection.timezone ?? "UTC";
+			poolOptions = pickPoolOptions(connection);
+		}
 
-		const connectionConfig = buildConnectionConfig(provider, tz);
+		const connectionConfig = buildConnectionConfig(provider, timezone);
+		const pool = poolOptions ?? {};
 
 		SqlModule.sqlInstance = new SQL({
 			url,
+			...pool,
 			...(connectionConfig && { connection: connectionConfig }),
 		});
 

package/package.json

@@ -13,7 +13,7 @@
       "types": "./dist/*.d.ts"
     }
   },
-  "version": "0.7.0",
+  "version": "0.7.1",
   "homepage": "https://bunstone.diario.one/",
   "repository": {
     "url": "https://github.com/diariodaregiao/bunstone.git",