test-entity-library-asm 2.8.12 → 2.8.14

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { NextFunction, Request, Response } from 'express';
-import { DataSource, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
-import { CustomRepository } from '.';
-export * from './entities.views.routes';
+import { NextFunction, Request, Response } from "express";
+import { DataSource, EntityTarget, ObjectLiteral, Repository } from "typeorm";
+import { CustomRepository } from ".";
+export * from "./entities.views.routes";
 export declare function createDataBaseSource(): DataSource;
 export declare function showEntityNameEntity<T extends ObjectLiteral>(entity: EntityTarget<T>): Promise<Repository<T>>;
 export declare function showEntity(entityName: string): Promise<any>;

package/dist/index.js

@@ -65,25 +65,25 @@ var connection = null;
 function createDataBaseSource() {
     var _a, _b;
     if (!connection) {
-        (0, dotenv_1.config)({ path: (0, path_1.resolve)(process.cwd(), '.env') });
+        (0, dotenv_1.config)({ path: (0, path_1.resolve)(process.cwd(), ".env") });
         connection = new typeorm_1.DataSource({
             type: process.env.DB_TYPE,
             host: process.env.DB_HOST,
-            port: parseInt((_a = process.env.DB_PORT) !== null && _a !== void 0 ? _a : ''),
+            port: parseInt((_a = process.env.DB_PORT) !== null && _a !== void 0 ? _a : ""),
             username: process.env.DB_USERNAME,
-            password: (_b = process.env.DB_PASSWORD) !== null && _b !== void 0 ? _b : '',
+            password: (_b = process.env.DB_PASSWORD) !== null && _b !== void 0 ? _b : "",
             database: process.env.DB_DATABASE,
-            synchronize: process.env.DB_SYNCHRONIZE === 'true',
-            timezone: 'Z',
+            synchronize: process.env.DB_SYNCHRONIZE === "true",
+            timezone: "Z",
             entities: [
                 __dirname +
                     "/entities".concat(process.env.DB_ENTITIES_ROUTE
                         ? "/".concat(process.env.DB_ENTITIES_ROUTE)
-                        : '', "/*{.js,.ts}"),
+                        : "", "/*{.js,.ts}"),
                 __dirname +
                     "/views".concat(process.env.DB_ENTITIES_ROUTE
                         ? "/".concat(process.env.DB_ENTITIES_ROUTE)
-                        : '', "/*{.js,.ts}"),
+                        : "", "/*{.js,.ts}"),
             ],
             subscribers: [],
             migrations: [],
@@ -99,7 +99,7 @@ function showEntityNameEntity(entity) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    if (!!connection) return [3 /*break*/, 2];
+                    if (!(!connection || !connection.isInitialized)) return [3 /*break*/, 2];
                     connection = createDataBaseSource();
                     return [4 /*yield*/, connection.initialize()];
                 case 1:
@@ -147,7 +147,6 @@ function callStoredProcedure(storedProcedure, elements) {
                     return [2 /*return*/, result];
                 case 4:
                     error_1 = _a.sent();
-                    console.error('Error calling stored procedure:', error_1);
                     throw error_1;
                 case 5: return [2 /*return*/];
             }
@@ -156,12 +155,12 @@ function callStoredProcedure(storedProcedure, elements) {
 }
 exports.callStoredProcedure = callStoredProcedure;
 function timezoneMiddleware(req, res, next) {
-    var userTimeZone = req.headers['user-timezone'];
+    var userTimeZone = req.headers["user-timezone"];
     if (Array.isArray(userTimeZone)) {
         userTimeZone = userTimeZone[0];
     }
-    userTimeZone = userTimeZone || 'UTC';
-    asyncLocalStorage.run(new Map([['timezone', userTimeZone]]), function () {
+    userTimeZone = userTimeZone || "UTC";
+    asyncLocalStorage.run(new Map([["timezone", userTimeZone]]), function () {
         next();
     });
 }
@@ -169,12 +168,12 @@ exports.timezoneMiddleware = timezoneMiddleware;
 function getTimeZone() {
     var _a;
     var store = asyncLocalStorage.getStore();
-    return (_a = store === null || store === void 0 ? void 0 : store.get('timezone')) !== null && _a !== void 0 ? _a : 'UTC';
+    return (_a = store === null || store === void 0 ? void 0 : store.get("timezone")) !== null && _a !== void 0 ? _a : "UTC";
 }
 exports.getTimeZone = getTimeZone;
 function getTimezoneOffset(timezone) {
     var now = moment.tz(timezone);
-    var offset = now.format('Z');
+    var offset = now.format("Z");
     return offset;
 }
 exports.getTimezoneOffset = getTimezoneOffset;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-entity-library-asm",
-  "version": "2.8.12",
+  "version": "2.8.14",
   "description": "Entidades de ejemplo para una base de datos",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,50 +1,50 @@
-import { AsyncLocalStorage } from 'async_hooks'
-import { config } from 'dotenv'
-import { NextFunction, Request, Response } from 'express'
-import { resolve } from 'path'
-import { DataSource, EntityTarget, ObjectLiteral, Repository } from 'typeorm'
-import { IType } from './interfaces'
-import { CustomRepository } from '.'
-import moment = require('moment-timezone')
-export * from './entities.views.routes'
+import { AsyncLocalStorage } from "async_hooks";
+import { config } from "dotenv";
+import { NextFunction, Request, Response } from "express";
+import { resolve } from "path";
+import { DataSource, EntityTarget, ObjectLiteral, Repository } from "typeorm";
+import { CustomRepository } from ".";
+import { IType } from "./interfaces";
+import moment = require("moment-timezone");
+export * from "./entities.views.routes";
 
-const asyncLocalStorage = new AsyncLocalStorage<Map<string, string>>()
+const asyncLocalStorage = new AsyncLocalStorage<Map<string, string>>();
 
-let connection: DataSource | null = null
+let connection: DataSource | null = null;
 
 // DOCUMENTATION: Función para crear la conexión de la base de datos
 // AUTHOR: jgomezp97@gmail.com
 export function createDataBaseSource(): DataSource {
   if (!connection) {
-    config({ path: resolve(process.cwd(), '.env') })
+    config({ path: resolve(process.cwd(), ".env") });
     connection = new DataSource({
       type: process.env.DB_TYPE as unknown as IType,
       host: process.env.DB_HOST,
-      port: parseInt(process.env.DB_PORT ?? ''),
+      port: parseInt(process.env.DB_PORT ?? ""),
       username: process.env.DB_USERNAME,
-      password: process.env.DB_PASSWORD ?? '',
+      password: process.env.DB_PASSWORD ?? "",
       database: process.env.DB_DATABASE,
-      synchronize: process.env.DB_SYNCHRONIZE === 'true',
-      timezone: 'Z',
+      synchronize: process.env.DB_SYNCHRONIZE === "true",
+      timezone: "Z",
       entities: [
         __dirname +
           `/entities${
             process.env.DB_ENTITIES_ROUTE
               ? `/${process.env.DB_ENTITIES_ROUTE}`
-              : ''
+              : ""
           }/*{.js,.ts}`,
         __dirname +
           `/views${
             process.env.DB_ENTITIES_ROUTE
               ? `/${process.env.DB_ENTITIES_ROUTE}`
-              : ''
+              : ""
           }/*{.js,.ts}`,
       ],
       subscribers: [],
       migrations: [],
-    })
+    });
   }
-  return connection
+  return connection;
 }
 
 // DOCUMENTATION: Función para retornar la entidad de una base de datos en específico por medio de un DataSource
@@ -52,35 +52,33 @@ export function createDataBaseSource(): DataSource {
 export async function showEntityNameEntity<T extends ObjectLiteral>(
   entity: EntityTarget<T>
 ): Promise<Repository<T>> {
-  if (!connection) {
-    connection = createDataBaseSource()
-    await connection.initialize()
+  if (!connection || !connection.isInitialized) {
+    connection = createDataBaseSource();
+    await connection.initialize();
   }
-
-  return connection.getRepository(entity)
+  return connection.getRepository(entity);
 }
 
 export async function showEntity(entityName: string): Promise<any> {
   if (!connection) {
-    connection = createDataBaseSource()
-    await connection.initialize()
+    connection = createDataBaseSource();
+    await connection.initialize();
   }
 
-  return connection.getRepository(entityName)
+  return connection.getRepository(entityName);
 }
 
 export async function callStoredProcedure(storedProcedure: any, elements: any) {
   try {
     if (!connection) {
-      connection = createDataBaseSource()
-      await connection.initialize()
+      connection = createDataBaseSource();
+      await connection.initialize();
     }
 
-    const result = await connection.query(`CALL ${storedProcedure}`, elements)
-    return result
+    const result = await connection.query(`CALL ${storedProcedure}`, elements);
+    return result;
   } catch (error) {
-    console.error('Error calling stored procedure:', error)
-    throw error
+    throw error;
   }
 }
 
@@ -89,38 +87,38 @@ export function timezoneMiddleware(
   res: Response,
   next: NextFunction
 ) {
-  let userTimeZone = req.headers['user-timezone']
+  let userTimeZone = req.headers["user-timezone"];
 
   if (Array.isArray(userTimeZone)) {
-    userTimeZone = userTimeZone[0]
+    userTimeZone = userTimeZone[0];
   }
 
-  userTimeZone = userTimeZone || 'UTC'
+  userTimeZone = userTimeZone || "UTC";
 
-  asyncLocalStorage.run(new Map([['timezone', userTimeZone]]), () => {
-    next()
-  })
+  asyncLocalStorage.run(new Map([["timezone", userTimeZone]]), () => {
+    next();
+  });
 }
 
 export function getTimeZone(): string {
-  const store = asyncLocalStorage.getStore()
-  return store?.get('timezone') ?? 'UTC'
+  const store = asyncLocalStorage.getStore();
+  return store?.get("timezone") ?? "UTC";
 }
 
 export function getTimezoneOffset(timezone: string) {
-  const now = moment.tz(timezone)
-  const offset = now.format('Z')
-  return offset
+  const now = moment.tz(timezone);
+  const offset = now.format("Z");
+  return offset;
 }
 
 export const getRepositoryByEntity = async <T extends ObjectLiteral>(
   entity: EntityTarget<T>
 ): Promise<CustomRepository<T>> => {
   if (!connection) {
-    connection = createDataBaseSource()
-    await connection.initialize()
+    connection = createDataBaseSource();
+    await connection.initialize();
   }
   return connection
     .getRepository(entity)
-    .extend(CustomRepository.prototype) as CustomRepository<T>
-}
+    .extend(CustomRepository.prototype) as CustomRepository<T>;
+};