@adaptic/backend-legacy 0.0.45 → 0.0.46

package/server.cjs

@@ -22,12 +22,14 @@ const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const auth_1 = require("./middleware/auth.cjs");
 const jwtConfig_1 = require("./config/jwtConfig.cjs");
 const prismaClient_1 = __importDefault(require("./prismaClient.cjs"));
+const health_1 = require("./health.cjs");
 const child_process_1 = require("child_process");
+const logger_1 = require("./utils/logger.cjs");
 let dbUnreachableCount = 0;
 let lastRestartAttempt = 0;
 async function restartDatabase() {
     return new Promise((resolve, reject) => {
-        console.log("Attempting to redeploy the Railway Postgres service in production...");
+        logger_1.logger.info('Attempting to redeploy the Railway Postgres service in production');
         // Check for both types of tokens
         const projectToken = process.env.RAILWAY_TOKEN;
         const apiToken = process.env.RAILWAY_API_TOKEN;
@@ -41,12 +43,10 @@ async function restartDatabase() {
             shell: '/bin/sh'
         }, (error, stdout, stderr) => {
             if (error) {
-                console.error('Failed to redeploy DB via Railway CLI:', error);
-                console.error('Command output:', stdout);
-                console.error('Command errors:', stderr);
+                logger_1.logger.error('Failed to redeploy DB via Railway CLI', { error: String(error), stdout, stderr });
                 return reject(error);
             }
-            console.log('Railway deployment output:', stdout);
+            logger_1.logger.info('Railway deployment output', { stdout });
             resolve();
         });
     });
@@ -65,12 +65,12 @@ const startServer = async () => {
         plugins: [(0, drainHttpServer_1.ApolloServerPluginDrainHttpServer)({ httpServer })],
         formatError: (err) => {
             var _a;
-            console.error('GraphQL Error:', JSON.stringify(err, null, 2));
+            logger_1.logger.error('GraphQL Error', { graphqlError: err });
             // Check if this error is due to unreachable DB
             const message = err.message || '';
             if (message.includes("Can't reach database server")) {
                 dbUnreachableCount += 1;
-                console.log(`DB unreachable count: ${dbUnreachableCount}`);
+                logger_1.logger.warn('Database unreachable', { dbUnreachableCount });
                 // If we've hit 3 (for example) attempts
                 if (dbUnreachableCount >= 3) {
                     const now = Date.now();
@@ -78,22 +78,22 @@ const startServer = async () => {
                     if (now - lastRestartAttempt > 5 * 60 * 1000) {
                         lastRestartAttempt = now;
                         try {
-                            restartDatabase();
+                            void restartDatabase();
                             // Reset the counter after attempting a restart
                             dbUnreachableCount = 0;
                         }
                         catch (restartError) {
-                            console.error('Error trying to restart DB:', restartError);
+                            logger_1.logger.error('Error trying to restart DB', { restartError: String(restartError) });
                             // If the restart fails, we can try again after a delay
                             const backoffTime = Math.min(30000, 1000 * Math.pow(2, dbUnreachableCount - 3)); // Exponential backoff with a max of 30 seconds
-                            console.log(`Waiting for ${backoffTime / 1000} seconds before next restart attempt...`);
+                            logger_1.logger.info('Waiting before next restart attempt', { backoffSeconds: backoffTime / 1000 });
                             setTimeout(() => {
                                 restartDatabase()
                                     .then(() => {
                                     dbUnreachableCount = 0; // Reset the counter after a successful restart
                                 })
                                     .catch((restartError) => {
-                                    console.error('Error trying to restart DB:', restartError);
+                                    logger_1.logger.error('Error trying to restart DB', { restartError: String(restartError) });
                                     // We do not reset the counter here if the restart fails,
                                     // so it can try again next time.
                                 });
@@ -119,6 +119,8 @@ const startServer = async () => {
         },
     });
     await server.start();
+    // Health check endpoint - mounted before Apollo middleware so it's not behind GraphQL or auth
+    app.use((0, health_1.createHealthRouter)());
     // Configure CORS with allowed origins
     const allowedOrigins = (process.env.ALLOWED_ORIGINS || 'http://localhost:3000,http://localhost:3001').split(',').map(o => o.trim());
     const corsOptions = {
@@ -142,7 +144,7 @@ const startServer = async () => {
         context: async ({ req }) => {
             // Ensure we're using the global prisma instance and never disconnecting it between requests
             if (!global.prisma) {
-                console.warn('Prisma client not found in global scope, reinitializing');
+                logger_1.logger.warn('Prisma client not found in global scope, reinitializing');
                 global.prisma = prismaClient_1.default;
             }
             // Extract token from Authorization header
@@ -163,7 +165,7 @@ const startServer = async () => {
                     if (tokenParts.length !== 3) {
                         // Log only once per unique malformed token to avoid log spam
                         const tokenPreview = token.length > 20 ? `${token.substring(0, 20)}...` : token;
-                        console.warn(`[Auth] Received malformed token (not a valid JWT format): ${tokenPreview}`);
+                        logger_1.logger.warn('Received malformed token (not a valid JWT format)', { tokenPreview });
                         // Continue without authentication - don't fail the request
                         return { prisma: global.prisma, req, authError: 'Malformed token: expected JWT format (header.payload.signature)' };
                     }
@@ -181,7 +183,7 @@ const startServer = async () => {
                     catch (e) {
                         // Only log verification failures at warn level with minimal info
                         const errorMessage = e instanceof Error ? e.message : 'Unknown error';
-                        console.warn(`[Auth] JWT verification failed: ${errorMessage}`);
+                        logger_1.logger.warn('JWT verification failed', { errorMessage });
                         return { prisma: global.prisma, req, authError: 'Invalid token' };
                     }
                 }
@@ -190,12 +192,12 @@ const startServer = async () => {
         },
     }));
     // Custom error handling middleware for express
-    app.use((err, req, res, next) => {
-        console.error('Express error:', err);
+    app.use((err, req, res, _next) => {
+        logger_1.logger.error('Express error', { error: err.message, stack: err.stack });
         res.status(500).json({ error: 'An internal server error occurred' });
     });
     app.use((req, res, next) => {
-        console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
+        logger_1.logger.debug('Incoming request', { method: req.method, url: req.url });
         next();
     });
     const wsServer = new ws_1.WebSocketServer({
@@ -204,11 +206,11 @@ const startServer = async () => {
     });
     (0, ws_2.useServer)({
         schema,
-        context: async (ctx, msg, args) => {
+        context: async (ctx, _msg, _args) => {
             var _a;
             // Ensure we're using the global prisma instance for WebSocket connections too
             if (!global.prisma) {
-                console.warn('Prisma client not found in global scope for WebSocket context, reinitializing');
+                logger_1.logger.warn('Prisma client not found in global scope for WebSocket context, reinitializing');
                 global.prisma = prismaClient_1.default;
             }
             const authHeader = ((_a = ctx.connectionParams) === null || _a === void 0 ? void 0 : _a.authorization) || '';
@@ -218,7 +220,7 @@ const startServer = async () => {
                 // Check if token is a Google OAuth token (starts with ya29.)
                 if (token.startsWith('ya29.')) {
                     // For Google OAuth tokens, we should validate differently or pass them through
-                    console.log('Detected Google OAuth token in WebSocket, skipping JWT verification');
+                    logger_1.logger.info('Detected Google OAuth token in WebSocket, skipping JWT verification');
                     user = { provider: 'google', token };
                 }
                 else {
@@ -235,7 +237,7 @@ const startServer = async () => {
                     }
                     catch (e) {
                         const errorMessage = e instanceof Error ? e.message : 'Unknown error';
-                        console.warn(`[Auth] WebSocket JWT verification failed: ${errorMessage}`);
+                        logger_1.logger.warn('WebSocket JWT verification failed', { errorMessage });
                         return { prisma: global.prisma, authError: 'Invalid token' };
                     }
                 }
@@ -245,50 +247,44 @@ const startServer = async () => {
     }, wsServer);
     const PORT = process.env.PORT || 4000;
     httpServer.listen(PORT, () => {
-        console.log(`🚀 Server ready at http://localhost:${PORT}/graphql`);
-        console.log(`🚀 Subscriptions ready at ws://localhost:${PORT}/subscriptions`);
+        logger_1.logger.info('Server ready', { graphql: `http://localhost:${PORT}/graphql`, health: `http://localhost:${PORT}/health` });
+        logger_1.logger.info('Subscriptions ready', { endpoint: `ws://localhost:${PORT}/subscriptions` });
     });
 };
 startServer().catch((error) => {
-    console.error('Error starting the server', error);
+    logger_1.logger.error('Error starting the server', { error: error instanceof Error ? error.message : String(error) });
     process.exit(1);
 });
-process.on('unhandledRejection', (reason, promise) => {
-    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+process.on('unhandledRejection', (reason, _promise) => {
+    logger_1.logger.error('Unhandled Rejection', { reason: reason instanceof Error ? reason.message : String(reason) });
 });
 process.on('uncaughtException', (error) => {
-    console.error('Uncaught Exception:', error);
+    logger_1.logger.error('Uncaught Exception', { error: error.message, stack: error.stack });
 });
 // Only disconnect Prisma when the process is truly shutting down
 process.on('SIGINT', async () => {
     var _a;
-    console.log('Gracefully shutting down and closing database connections...');
+    logger_1.logger.info('Gracefully shutting down and closing database connections');
     try {
         await ((_a = global.prisma) === null || _a === void 0 ? void 0 : _a.$disconnect());
-        console.log('Database connections closed successfully');
+        logger_1.logger.info('Database connections closed successfully');
     }
     catch (e) {
-        console.error('Error disconnecting from database:', e);
+        logger_1.logger.error('Error disconnecting from database', { error: e instanceof Error ? e.message : String(e) });
     }
     process.exit(0);
 });
 // Also handle SIGTERM for containerized environments
 process.on('SIGTERM', async () => {
     var _a;
-    console.log('Received SIGTERM, gracefully shutting down...');
+    logger_1.logger.info('Received SIGTERM, gracefully shutting down');
     try {
         await ((_a = global.prisma) === null || _a === void 0 ? void 0 : _a.$disconnect());
-        console.log('Database connections closed successfully');
+        logger_1.logger.info('Database connections closed successfully');
     }
     catch (e) {
-        console.error('Error disconnecting from database:', e);
+        logger_1.logger.error('Error disconnecting from database', { error: e instanceof Error ? e.message : String(e) });
     }
     process.exit(0);
 });
-// // run restartDatabase() function
-// restartDatabase().then(() => {
-//   console.log('Database restarted successfully');
-// }).catch((error) => {
-//   console.error('Error restarting database:', error);
-// });
 //# sourceMappingURL=server.js.map

package/utils.cjs

@@ -1,6 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeUndefinedProps = removeUndefinedProps;
+/**
+ * Recursively removes undefined and null properties from an object or array.
+ *
+ * This utility is called by generated CRUD functions to clean GraphQL variables
+ * before passing them to Apollo Client. The input objects contain Prisma-typed
+ * fields (Date, Decimal, bigint, JsonValue, nested relations, etc.) which cannot
+ * be enumerated exhaustively. The return value is used as Apollo OperationVariables.
+ *
+ * We use Record<string, unknown> for the parameter to accept all generated Prisma
+ * input shapes without needing to enumerate every possible field type.
+ */
 function removeUndefinedProps(obj) {
     if (Array.isArray(obj)) {
         return obj
@@ -9,15 +20,17 @@ function removeUndefinedProps(obj) {
             item !== null &&
             (typeof item !== 'object' || Object.keys(item).length > 0));
     }
-    else if (typeof obj === 'object' && obj !== null) {
-        return Object.keys(obj).reduce((acc, key) => {
-            let value = obj[key];
+    else if (typeof obj === 'object' && obj !== null && !(obj instanceof Date)) {
+        const record = obj;
+        return Object.keys(record).reduce((acc, key) => {
+            const value = record[key];
             if (value !== undefined && value !== null) {
                 let cleanedValue;
-                if (key === 'where' && typeof value === 'object' && value !== null) {
-                    if (value.hasOwnProperty('id') && value.id !== undefined) {
+                if (key === 'where' && typeof value === 'object' && value !== null && !(value instanceof Date)) {
+                    const whereObj = value;
+                    if (Object.prototype.hasOwnProperty.call(whereObj, 'id') && whereObj.id !== undefined) {
                         // Retain only the 'id' field within 'where'
-                        cleanedValue = { id: removeUndefinedProps(value.id) };
+                        cleanedValue = { id: removeUndefinedProps(whereObj.id) };
                     }
                     else {
                         // Process 'where' object normally if 'id' is undefined or doesn't exist
@@ -30,7 +43,7 @@ function removeUndefinedProps(obj) {
                 }
                 if (cleanedValue !== undefined &&
                     cleanedValue !== null &&
-                    (typeof cleanedValue !== 'object' || Object.keys(cleanedValue).length > 0)) {
+                    (typeof cleanedValue !== 'object' || cleanedValue instanceof Date || Object.keys(cleanedValue).length > 0)) {
                     acc[key] = cleanedValue;
                 }
             }

package/utils.d.ts

@@ -1,2 +1,13 @@
-export declare function removeUndefinedProps(obj: any): any;
+/**
+ * Recursively removes undefined and null properties from an object or array.
+ *
+ * This utility is called by generated CRUD functions to clean GraphQL variables
+ * before passing them to Apollo Client. The input objects contain Prisma-typed
+ * fields (Date, Decimal, bigint, JsonValue, nested relations, etc.) which cannot
+ * be enumerated exhaustively. The return value is used as Apollo OperationVariables.
+ *
+ * We use Record<string, unknown> for the parameter to accept all generated Prisma
+ * input shapes without needing to enumerate every possible field type.
+ */
+export declare function removeUndefinedProps(obj: Record<string, unknown> | Record<string, unknown>[] | unknown): Record<string, unknown> | undefined;
 //# sourceMappingURL=utils.d.ts.map