bapig
Version:
Welcome to BAPIG, a powerful backend solution designed to streamline your development process. With over 40 built-in functionalities, BAPIG simplifies CRUD operations, facilitates authentication and encryption, handles communication tasks, and much more.
258 lines • 12.3 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.server = exports.io = exports.mongoose = exports.startServer = void 0;
// src/server.ts
var fs_1 = __importDefault(require("fs"));
var path_1 = __importDefault(require("path"));
var http_1 = __importDefault(require("http"));
var https_1 = __importDefault(require("https"));
var mongoose_1 = __importDefault(require("mongoose"));
exports.mongoose = mongoose_1.default;
var print_1 = require("../helpers/print");
var fast_web_kit_1 = require("fast-web-kit");
var socket_io_1 = require("socket.io");
var helpers_1 = require("../helpers");
// Environment variables and other constants
var databaseRetryCount = 0;
var port = Number(process.env.PORT) || 8080;
var keyPath = process.env.SSL_KEY_PATH || '';
var certPath = process.env.SSL_CERT_PATH || '';
var environment = process.env.ENVIRONMENT || 'development';
var databaseName = process.env.DATABASE_NAME || 'bapig';
var databaseRetrySeconds = Number(process.env.DATABASE_RETRY_SECONDS) || 5;
var databaseMaximumRetries = Number(process.env.DATABASE_MAXIMUM_RETRIES) || 5;
var databaseURI = process.env.DATABASE_URI || "mongodb://127.0.0.1:27017/".concat(databaseName);
var socketIoOrigin = process.env.SOCKET_IO_CORS_ORIGIN || "*";
var connectionPoolSize = Number(process.env.DATABASE_CONNECTION_POOL_SIZE) || 10;
// Socket.IO Server instance
var io;
exports.io = io;
var server;
exports.server = server;
// Define connection options
var databaseConnectionOptions = {
minPoolSize: 5,
bufferCommands: true,
maxIdleTimeMS: connectionPoolSize,
writeConcern: {
w: 'majority',
j: true,
wtimeout: 1000
},
readConcern: {
level: 'local'
},
autoCreate: true, // Automatically create models and schemas if they don't exist
};
// Function to initialize mongoose connection
var initializeMongoose = function () { return __awaiter(void 0, void 0, void 0, function () {
var error_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
// Attempting to connect to MongoDB
print_1.print.log("Connecting '".concat(databaseName, "' (Retry ").concat(databaseRetryCount + 1, "/").concat(databaseMaximumRetries, ")"));
return [4 /*yield*/, mongoose_1.default.connect("".concat(databaseURI, "/").concat(databaseName), databaseConnectionOptions)];
case 1:
_a.sent();
return [3 /*break*/, 3];
case 2:
error_1 = _a.sent();
// Error connecting to MongoDB
print_1.print.error("MongoDB connection attempt failed: ".concat(error_1.message));
return [3 /*break*/, 3];
case 3: return [2 /*return*/];
}
});
}); };
// Handling database retry
var handleRetry = function () {
try {
if (databaseRetryCount < databaseMaximumRetries - 1) {
// Retrying after a delay
print_1.print.log("Retrying MongoDB connection in ".concat(databaseRetrySeconds, " seconds (Retry ").concat(databaseRetryCount + 1, "/").concat(databaseMaximumRetries, ")"));
setTimeout(function () { return initializeMongoose(); }, fast_web_kit_1.number.toMilliseconds(databaseRetrySeconds, 'seconds'));
databaseRetryCount++;
}
else {
// Maximum retry attempts reached, unable to connect
print_1.print.error("Maximum retry attempts reached for MongoDB connection to '".concat(databaseName, "'. Unable to connect."));
}
}
catch (error) {
print_1.print.error("Error handling MongoDB connection retry: ".concat(error.message));
}
};
mongoose_1.default.connection.on('error', function (error) {
try {
// MongoDB connection error, handle retry
print_1.print.error("MongoDB connection error for '".concat(databaseName, "': ").concat(error.message));
}
catch (error) {
print_1.print.error("Error handling MongoDB connection error: ".concat(error.message));
}
finally {
handleRetry();
}
});
// Function to get HTTPS server options
function getServerOptions() {
try {
// Check if SSL key and certificate paths are provided
if (fast_web_kit_1.string.isNotEmpty(keyPath) && fast_web_kit_1.string.isNotEmpty(certPath)) {
var keyExists = fs_1.default.existsSync(path_1.default.join(keyPath));
var certExists = fs_1.default.existsSync(path_1.default.join(certPath));
if (keyExists && certExists) {
// Return options if files exist
return {
key: fs_1.default.readFileSync(keyPath),
cert: fs_1.default.readFileSync(certPath),
};
}
else {
print_1.print.error('SSL key or certificate files not found');
}
}
else {
print_1.print.error('SSL key and certificate paths must be provided for SSL server');
}
return {};
}
catch (error) {
print_1.print.error("Failed to get SSL certificate files: ".concat(error.message));
return {};
}
}
/**
* Start the HTTP or HTTPS server.
* @param application - The Express application instance.
*/
var startServer = function (application) {
try {
// Set the port in the application
if (!application) {
throw new Error("Can't start server without application");
}
// Initialize mongoose connection
initializeMongoose();
// Create an HTTP or HTTPS server based on the environment
var myServer = (environment === null || environment === void 0 ? void 0 : environment.toLowerCase()) === 'production' ?
https_1.default.createServer(getServerOptions(), application) :
http_1.default.createServer(application);
exports.server = server = myServer;
// Create a Socket.IO instance and attach it to the server
exports.io = io = new socket_io_1.Server(server, { cors: { origin: socketIoOrigin } });
// Event listeners for handling connection events
mongoose_1.default.connection.on('connected', function () {
try {
var schemaDirectory = fs_1.default.existsSync(helpers_1.modelsDirectory) ? helpers_1.modelsDirectory : undefined;
if (schemaDirectory) {
// Read all files in the schema directory
var schemaFiles = fs_1.default.readdirSync(schemaDirectory);
if (schemaFiles.length > 0) {
// Iterate through each schema file
for (var _i = 0, schemaFiles_1 = schemaFiles; _i < schemaFiles_1.length; _i++) {
var schemaFile = schemaFiles_1[_i];
try {
// require the schema from the file
require("".concat(schemaDirectory, "/").concat(schemaFile));
}
catch (requireError) {
console.error("Error requiring schema file ".concat(schemaFile, ":"), requireError);
// Handle or log the error as needed
}
}
}
}
// MongoDB connection established
print_1.print.success("MongoDB connected to '".concat(databaseName, "'"));
// Server listening event
server.on('listening', function () {
print_1.print.info("Server is running on port ".concat(port));
});
// Server error event
server.on('error', function (error) {
handleServerError(error);
});
// Start listening for incoming requests
server.listen(port);
// Socket.IO connection event
io.on('connection', function (socket) {
print_1.print.log("New socket connection established");
print_1.print.cyan("User connected: ".concat(socket.id));
socket.on('disconnect', function () {
print_1.print.warn("User disconnected: ".concat(socket.id));
});
});
}
catch (error) {
// Handle errors here, log or take corrective actions
console.error('Error during connection setup:', error);
}
});
}
catch (error) {
print_1.print.error("Error starting server: ".concat(error.message));
}
};
exports.startServer = startServer;
/**
* Handles server error events.
* @param error - The error object.
*/
var handleServerError = function (error) {
if (error.syscall !== 'listen') {
throw error;
}
switch (error.code) {
case 'EACCES':
print_1.print.error("Port ".concat(port, " requires elevated privileges"));
process.exit(1);
case 'EADDRINUSE':
print_1.print.error("Port ".concat(port, " is already in use"));
process.exit(1);
default:
throw error;
}
};
//# sourceMappingURL=server.js.map