Updated config.sh and new workflow for getting online.

map/app/Dockerfile

@@ -0,0 +1,41 @@
+# Build stage
+FROM node:18-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production && npm cache clean --force
+
+# Runtime stage
+FROM node:18-alpine
+
+# Install wget for healthcheck
+RUN apk add --no-cache wget
+
+WORKDIR /app
+
+# Copy dependencies from builder
+COPY --from=builder /app/node_modules ./node_modules
+
+# Copy application files
+COPY package*.json ./
+COPY server.js ./
+COPY public ./public
+COPY routes ./routes
+COPY services ./services
+
+# Create non-root user
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+
+# Change ownership
+RUN chown -R nodejs:nodejs /app
+
+USER nodejs
+
+EXPOSE 3000
+
+CMD ["node", "server.js"]

map/app/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "nocodb-map-viewer",
+  "version": "1.0.0",
+  "description": "Interactive map viewer for NocoDB geographic data",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "nocodb",
+    "map",
+    "leaflet",
+    "gis",
+    "location"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.1.4",
+    "express-session": "^1.18.1",
+    "helmet": "^7.1.0",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

map/app/public/css/style.css

@@ -0,0 +1,628 @@
+/* CSS Variables for theming */
+:root {
+    --primary-color: #2c5aa0;
+    --success-color: #27ae60;
+    --danger-color: #e74c3c;
+    --warning-color: #f39c12;
+    --secondary-color: #95a5a6;
+    --dark-color: #2c3e50;
+    --light-color: #ecf0f1;
+    --border-radius: 4px;
+    --transition: all 0.3s ease;
+    --header-height: 60px;
+}
+
+/* Reset and base styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+    font-size: 16px;
+    line-height: 1.5;
+    color: var(--dark-color);
+    background-color: var(--light-color);
+}
+
+/* App container */
+#app {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    position: relative;
+}
+
+/* Header */
+.header {
+    height: var(--header-height);
+    background-color: var(--dark-color);
+    color: white;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0 20px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    z-index: 1000;
+}
+
+.header h1 {
+    font-size: 24px;
+    font-weight: 600;
+}
+
+.header-actions {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+}
+
+.location-count {
+    background-color: rgba(255,255,255,0.1);
+    padding: 5px 15px;
+    border-radius: 20px;
+    font-size: 14px;
+}
+
+/* User info in header */
+.user-info {
+    display: flex;
+    align-items: center;
+    gap: 15px;
+    padding: 0 15px;
+    border-right: 1px solid rgba(255,255,255,0.2);
+    margin-right: 15px;
+}
+
+.user-email {
+    font-size: 14px;
+    color: rgba(255,255,255,0.9);
+}
+
+/* Map container */
+#map-container {
+    flex: 1;
+    position: relative;
+    overflow: hidden;
+}
+
+#map {
+    width: 100%;
+    height: 100%;
+    background-color: #f0f0f0;
+}
+
+/* Map controls */
+.map-controls {
+    position: absolute;
+    top: 20px;
+    right: 20px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    z-index: 1000;
+}
+
+/* Buttons */
+.btn {
+    padding: 10px 16px;
+    border: none;
+    border-radius: var(--border-radius);
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: var(--transition);
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    white-space: nowrap;
+    outline: none;
+}
+
+.btn:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(0,0,0,0.15);
+}
+
+.btn:active {
+    transform: translateY(0);
+}
+
+.btn-primary {
+    background-color: var(--primary-color);
+    color: white;
+}
+
+.btn-primary:hover {
+    background-color: #2471a3;
+}
+
+.btn-success {
+    background-color: var(--success-color);
+    color: white;
+}
+
+.btn-success:hover {
+    background-color: #229954;
+}
+
+.btn-secondary {
+    background-color: var(--secondary-color);
+    color: white;
+}
+
+.btn-secondary:hover {
+    background-color: #7f8c8d;
+}
+
+.btn-sm {
+    padding: 6px 12px;
+    font-size: 13px;
+}
+
+.btn-danger {
+    background-color: var(--danger-color);
+    color: white;
+}
+
+.btn-danger:hover {
+    background-color: #c0392b;
+}
+
+/* Crosshair for location selection */
+.crosshair {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    pointer-events: none;
+    z-index: 999;
+}
+
+.crosshair.hidden {
+    display: none;
+}
+
+.crosshair-x,
+.crosshair-y {
+    position: absolute;
+    background-color: rgba(44, 90, 160, 0.8);
+}
+
+.crosshair-x {
+    width: 40px;
+    height: 2px;
+    left: -20px;
+    top: -1px;
+}
+
+.crosshair-y {
+    width: 2px;
+    height: 40px;
+    left: -1px;
+    top: -20px;
+}
+
+.crosshair-info {
+    position: absolute;
+    top: 30px;
+    left: 50%;
+    transform: translateX(-50%);
+    background-color: rgba(44, 62, 80, 0.9);
+    color: white;
+    padding: 5px 10px;
+    border-radius: var(--border-radius);
+    font-size: 12px;
+    white-space: nowrap;
+}
+
+/* Status messages */
+.status-container {
+    position: fixed;
+    top: calc(var(--header-height) + 20px);
+    left: 50%;
+    transform: translateX(-50%);
+    z-index: 2000;
+    max-width: 400px;
+    width: 90%;
+}
+
+.status-message {
+    padding: 12px 20px;
+    border-radius: var(--border-radius);
+    margin-bottom: 10px;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    animation: slideIn 0.3s ease;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+}
+
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.status-message.success {
+    background-color: var(--success-color);
+    color: white;
+}
+
+.status-message.error {
+    background-color: var(--danger-color);
+    color: white;
+}
+
+.status-message.warning {
+    background-color: var(--warning-color);
+    color: white;
+}
+
+.status-message.info {
+    background-color: var(--primary-color);
+    color: white;
+}
+
+/* Modal */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0,0,0,0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 3000;
+    animation: fadeIn 0.3s ease;
+}
+
+.modal.hidden {
+    display: none;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+.modal-content {
+    background-color: white;
+    border-radius: var(--border-radius);
+    width: 90%;
+    max-width: 500px;
+    max-height: 90vh;
+    overflow: auto;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.15);
+    animation: slideUp 0.3s ease;
+}
+
+@keyframes slideUp {
+    from {
+        opacity: 0;
+        transform: translateY(50px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.modal-header {
+    padding: 20px;
+    border-bottom: 1px solid #e0e0e0;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.modal-header h2 {
+    font-size: 20px;
+    font-weight: 600;
+    color: var(--dark-color);
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    font-size: 24px;
+    cursor: pointer;
+    color: var(--secondary-color);
+    width: 30px;
+    height: 30px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    transition: var(--transition);
+}
+
+.modal-close:hover {
+    background-color: var(--light-color);
+    color: var(--dark-color);
+}
+
+.modal-body {
+    padding: 20px;
+}
+
+/* Edit Footer Form */
+.edit-footer {
+    position: fixed;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background-color: white;
+    border-top: 2px solid var(--primary-color);
+    box-shadow: 0 -2px 10px rgba(0,0,0,0.1);
+    z-index: 1500;
+    transition: transform 0.3s ease;
+    max-height: 60vh;
+    overflow-y: auto;
+}
+
+.edit-footer.hidden {
+    transform: translateY(100%);
+}
+
+.edit-footer-content {
+    padding: 20px;
+    max-width: 800px;
+    margin: 0 auto;
+}
+
+.edit-footer-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 20px;
+    padding-bottom: 15px;
+    border-bottom: 1px solid #e0e0e0;
+}
+
+.edit-footer-header h2 {
+    margin: 0;
+    font-size: 20px;
+    color: var(--dark-color);
+}
+
+/* Form styles */
+.form-group {
+    margin-bottom: 15px;
+}
+
+.form-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 15px;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 5px;
+    font-weight: 500;
+    color: var(--dark-color);
+    font-size: 14px;
+}
+
+.form-group input,
+.form-group textarea {
+    width: 100%;
+    padding: 8px 12px;
+    border: 1px solid #ddd;
+    border-radius: var(--border-radius);
+    font-size: 14px;
+    transition: var(--transition);
+}
+
+.form-group input:focus,
+.form-group textarea:focus {
+    outline: none;
+    border-color: var(--primary-color);
+    box-shadow: 0 0 0 2px rgba(44, 90, 160, 0.1);
+}
+
+.form-group input.valid {
+    border-color: var(--success-color);
+}
+
+.form-group input.invalid {
+    border-color: var(--danger-color);
+}
+
+.form-group input[readonly] {
+    background-color: #f5f5f5;
+    cursor: not-allowed;
+}
+
+.form-group select {
+    width: 100%;
+    padding: 8px 12px;
+    border: 1px solid #ddd;
+    border-radius: var(--border-radius);
+    font-size: 14px;
+    transition: var(--transition);
+    background-color: white;
+    cursor: pointer;
+}
+
+.form-group select:focus {
+    outline: none;
+    border-color: var(--primary-color);
+    box-shadow: 0 0 0 2px rgba(44, 90, 160, 0.1);
+}
+
+.form-group input[type="checkbox"] {
+    width: auto;
+    margin-right: 8px;
+    cursor: pointer;
+}
+
+.form-group label input[type="checkbox"] {
+    vertical-align: middle;
+}
+
+.form-actions {
+    display: flex;
+    gap: 10px;
+    justify-content: flex-end;
+    margin-top: 20px;
+    padding-top: 20px;
+    border-top: 1px solid #e0e0e0;
+}
+
+/* Loading overlay */
+.loading-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(255,255,255,0.9);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    z-index: 4000;
+}
+
+.loading-overlay.hidden {
+    display: none;
+}
+
+.spinner {
+    width: 50px;
+    height: 50px;
+    border: 3px solid var(--light-color);
+    border-top-color: var(--primary-color);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+.loading-overlay p {
+    margin-top: 20px;
+    color: var(--dark-color);
+    font-size: 16px;
+}
+
+/* Leaflet customizations */
+.leaflet-popup-content-wrapper {
+    border-radius: var(--border-radius);
+    box-shadow: 0 3px 10px rgba(0,0,0,0.2);
+}
+
+.leaflet-popup-content {
+    margin: 13px 19px;
+    line-height: 1.5;
+}
+
+.popup-content h3 {
+    margin: 0 0 10px 0;
+    color: var(--dark-color);
+    font-size: 16px;
+}
+
+.popup-content p {
+    margin: 5px 0;
+    color: #666;
+    font-size: 14px;
+}
+
+.popup-content .popup-meta {
+    font-size: 12px;
+    color: #999;
+    margin-top: 10px;
+    padding-top: 10px;
+    border-top: 1px solid #eee;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .header h1 {
+        font-size: 20px;
+    }
+    
+    .map-controls {
+        top: 10px;
+        right: 10px;
+    }
+    
+    .btn {
+        padding: 8px 12px;
+        font-size: 13px;
+    }
+    
+    /* Hide button text on mobile, show only icons */
+    .btn span.btn-text {
+        display: none;
+    }
+    
+    /* Hide user info on mobile to save space */
+    .user-info {
+        display: none;
+    }
+    
+    .btn {
+        padding: 10px;
+        min-width: 40px;
+        min-height: 40px;
+        justify-content: center;
+    }
+    
+    .modal-content {
+        width: 95%;
+        margin: 10px;
+    }
+    
+    .form-row {
+        grid-template-columns: 1fr;
+    }
+}
+
+/* Add text spans for desktop that can be hidden on mobile */
+@media (min-width: 769px) {
+    .btn span.btn-icon {
+        margin-right: 5px;
+    }
+}
+
+/* Fullscreen styles */
+.fullscreen #map-container {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    z-index: 5000;
+}
+
+.fullscreen .header {
+    display: none;
+}
+
+/* Print styles */
+@media print {
+    .header,
+    .map-controls,
+    .status-container,
+    .modal {
+        display: none !important;
+    }
+    
+    #map-container {
+        height: 100vh;
+    }
+}

map/app/public/index.html

@@ -0,0 +1,276 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description" content="Interactive map viewer for NocoDB location data">
+    <title>NocoDB Map Viewer</title>
+    
+    <!-- Leaflet CSS -->
+    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" 
+          integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY=" 
+          crossorigin="" />
+    
+    <!-- Custom CSS -->
+    <link rel="stylesheet" href="css/style.css">
+</head>
+<body>
+    <div id="app">
+        <!-- Header -->
+        <header class="header">
+            <h1>Location Map Viewer</h1>
+            <div class="header-actions">
+                <button id="refresh-btn" class="btn btn-secondary" title="Refresh locations">
+                    🔄 Refresh
+                </button>
+                <span id="location-count" class="location-count">Loading...</span>
+            </div>
+        </header>
+
+        <!-- Map Container -->
+        <div id="map-container">
+            <div id="map"></div>
+            
+            <!-- Map Controls -->
+            <div class="map-controls">
+                <button id="geolocate-btn" class="btn btn-primary" title="Find my location">
+                    <span class="btn-icon">📍</span><span class="btn-text">My Location</span>
+                </button>
+                <button id="add-location-btn" class="btn btn-success" title="Add location at map center">
+                    <span class="btn-icon">➕</span><span class="btn-text">Add Location Here</span>
+                </button>
+                <button id="fullscreen-btn" class="btn btn-secondary" title="Toggle fullscreen">
+                    <span class="btn-icon">⛶</span><span class="btn-text">Fullscreen</span>
+                </button>
+            </div>
+            
+            <!-- Crosshair for adding locations -->
+            <div id="crosshair" class="crosshair hidden">
+                <div class="crosshair-x"></div>
+                <div class="crosshair-y"></div>
+                <div class="crosshair-info">Click "Add Location Here" to save this point</div>
+            </div>
+        </div>
+
+        <!-- Status Messages -->
+        <div id="status-container" class="status-container"></div>
+
+        <!-- Edit Location Footer Form -->
+        <div id="edit-footer" class="edit-footer hidden">
+            <div class="edit-footer-content">
+                <div class="edit-footer-header">
+                    <h2>Edit Location</h2>
+                    <button class="btn btn-secondary btn-sm" id="close-edit-footer-btn">✕ Close</button>
+                </div>
+                <form id="edit-location-form">
+                    <input type="hidden" id="edit-location-id" name="id">
+                    <div class="form-row">
+                        <div class="form-group">
+                            <label for="edit-first-name">First Name</label>
+                            <input type="text" id="edit-first-name" name="First Name">
+                        </div>
+                        <div class="form-group">
+                            <label for="edit-last-name">Last Name</label>
+                            <input type="text" id="edit-last-name" name="Last Name">
+                        </div>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label for="edit-location-email">Email</label>
+                        <input type="email" id="edit-location-email" name="Email">
+                    </div>
+                    
+                    <div class="form-row">
+                        <div class="form-group">
+                            <label for="edit-location-unit">Unit Number</label>
+                            <input type="text" id="edit-location-unit" name="Unit Number">
+                        </div>
+                        <div class="form-group">
+                            <label for="edit-support-level">Support Level</label>
+                            <select id="edit-support-level" name="Support Level">
+                                <option value="">-- Select --</option>
+                                <option value="1">1 - Strong Support (Green)</option>
+                                <option value="2">2 - Moderate Support (Yellow)</option>
+                                <option value="3">3 - Low Support (Orange)</option>
+                                <option value="4">4 - No Support (Red)</option>
+                            </select>
+                        </div>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label for="edit-location-address">Address</label>
+                        <div style="display: flex; gap: 10px;">
+                            <input type="text" id="edit-location-address" name="Address" style="flex: 1;">
+                            <button type="button" class="btn btn-secondary btn-sm" id="lookup-address-edit-btn">
+                                🔍 Lookup
+                            </button>
+                        </div>
+                    </div>
+                    
+                    <div class="form-row">
+                        <div class="form-group">
+                            <label>
+                                <input type="checkbox" id="edit-sign" name="Sign" value="true">
+                                Has Campaign Sign
+                            </label>
+                        </div>
+                        <div class="form-group">
+                            <label for="edit-sign-size">Sign Size</label>
+                            <select id="edit-sign-size" name="Sign Size">
+                                <option value="">-- Select --</option>
+                                <option value="Small">Small</option>
+                                <option value="Medium">Medium</option>
+                                <option value="Large">Large</option>
+                            </select>
+                        </div>
+                    </div>
+                    
+                    <div class="form-row">
+                        <div class="form-group">
+                            <label for="edit-location-lat">Latitude</label>
+                            <input type="number" id="edit-location-lat" name="latitude" step="0.00000001">
+                        </div>
+                        <div class="form-group">
+                            <label for="edit-location-lng">Longitude</label>
+                            <input type="number" id="edit-location-lng" name="longitude" step="0.00000001">
+                        </div>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label for="edit-geo-location">Geo-Location</label>
+                        <input type="text" id="edit-geo-location" name="Geo-Location" 
+                               placeholder="e.g., 53.5461;-113.4938">
+                    </div>
+                    
+                    <div class="form-actions">
+                        <button type="button" class="btn btn-danger" id="delete-location-btn">Delete</button>
+                        <button type="submit" class="btn btn-primary">Save Changes</button>
+                    </div>
+                </form>
+            </div>
+        </div>
+
+        <!-- Add Location Modal -->
+        <div id="add-modal" class="modal hidden">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h2>Add New Location</h2>
+                    <button class="modal-close" id="close-modal-btn">&times;</button>
+                </div>
+                <div class="modal-body">
+                    <form id="location-form">
+                        <div class="form-row">
+                            <div class="form-group">
+                                <label for="first-name">First Name</label>
+                                <input type="text" id="first-name" name="First Name" 
+                                       placeholder="Enter first name">
+                            </div>
+                            <div class="form-group">
+                                <label for="last-name">Last Name</label>
+                                <input type="text" id="last-name" name="Last Name" 
+                                       placeholder="Enter last name">
+                            </div>
+                        </div>
+                        
+                        <div class="form-group">
+                            <label for="location-email">Email</label>
+                            <input type="email" id="location-email" name="Email" 
+                                   placeholder="Enter email address">
+                        </div>
+                        
+                        <div class="form-row">
+                            <div class="form-group">
+                                <label for="location-unit">Unit Number</label>
+                                <input type="text" id="location-unit" name="Unit Number" 
+                                       placeholder="Enter unit number">
+                            </div>
+                            <div class="form-group">
+                                <label for="support-level">Support Level</label>
+                                <select id="support-level" name="Support Level">
+                                    <option value="">-- Select --</option>
+                                    <option value="1">1 - Strong Support (Green)</option>
+                                    <option value="2">2 - Moderate Support (Yellow)</option>
+                                    <option value="3">3 - Low Support (Orange)</option>
+                                    <option value="4">4 - No Support (Red)</option>
+                                </select>
+                            </div>
+                        </div>
+                        
+                        <div class="form-group">
+                            <label for="location-address">Address</label>
+                            <div style="display: flex; gap: 10px;">
+                                <input type="text" id="location-address" name="Address" 
+                                       placeholder="Enter address" style="flex: 1;">
+                                <button type="button" class="btn btn-secondary btn-sm" id="lookup-address-add-btn">
+                                    🔍 Lookup
+                                </button>
+                            </div>
+                        </div>
+                        
+                        <div class="form-row">
+                            <div class="form-group">
+                                <label>
+                                    <input type="checkbox" id="sign" name="Sign" value="true">
+                                    Has Campaign Sign
+                                </label>
+                            </div>
+                            <div class="form-group">
+                                <label for="sign-size">Sign Size</label>
+                                <select id="sign-size" name="Sign Size">
+                                    <option value="">-- Select --</option>
+                                    <option value="Small">Small</option>
+                                    <option value="Medium">Medium</option>
+                                    <option value="Large">Large</option>
+                                </select>
+                            </div>
+                        </div>
+                        
+                        <div class="form-row">
+                            <div class="form-group">
+                                <label for="location-lat">Latitude</label>
+                                <input type="number" id="location-lat" name="latitude" 
+                                       step="0.00000001" readonly>
+                            </div>
+                            <div class="form-group">
+                                <label for="location-lng">Longitude</label>
+                                <input type="number" id="location-lng" name="longitude" 
+                                       step="0.00000001" readonly>
+                            </div>
+                        </div>
+                        
+                        <div class="form-group">
+                            <label for="geo-location">Geo-Location</label>
+                            <input type="text" id="geo-location" name="Geo-Location" 
+                                   placeholder="e.g., 53.5461;-113.4938"
+                                   title="Enter as 'latitude;longitude' or 'latitude, longitude'">
+                        </div>
+                        
+                        <div class="form-actions">
+                            <button type="button" class="btn btn-secondary" id="cancel-modal-btn">
+                                Cancel
+                            </button>
+                            <button type="submit" class="btn btn-primary">
+                                Save Location
+                            </button>
+                        </div>
+                    </form>
+                </div>
+            </div>
+        </div>
+
+        <!-- Loading Overlay -->
+        <div id="loading" class="loading-overlay">
+            <div class="spinner"></div>
+            <p>Loading map...</p>
+        </div>
+    </div>
+
+    <!-- Leaflet JS -->
+    <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js" 
+            integrity="sha256-20nQCchB9co0qIjJZRGuk2/Z9VM+kNiyxNV1lvTlZBo=" 
+            crossorigin=""></script>
+    
+    <!-- Application JavaScript -->
+    <script src="js/map.js"></script>
+</body>
+</html>

map/app/public/login.html

@@ -0,0 +1,254 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description" content="Login to NocoDB Map Viewer">
+    <title>Login - NocoDB Map Viewer</title>
+    
+    <!-- Custom CSS -->
+    <link rel="stylesheet" href="css/style.css">
+    <style>
+        .login-container {
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: var(--light-color);
+            padding: 20px;
+        }
+        
+        .login-card {
+            background-color: white;
+            border-radius: 8px;
+            box-shadow: 0 4px 20px rgba(0,0,0,0.1);
+            padding: 40px;
+            width: 100%;
+            max-width: 400px;
+        }
+        
+        .login-header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        .login-header h1 {
+            color: var(--dark-color);
+            font-size: 28px;
+            margin-bottom: 10px;
+        }
+        
+        .login-header p {
+            color: var(--secondary-color);
+            font-size: 16px;
+        }
+        
+        .login-form {
+            margin-top: 30px;
+        }
+        
+        .form-group {
+            margin-bottom: 20px;
+        }
+        
+        .form-group label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 500;
+            color: var(--dark-color);
+        }
+        
+        .form-group input {
+            width: 100%;
+            padding: 12px 16px;
+            border: 1px solid #ddd;
+            border-radius: var(--border-radius);
+            font-size: 16px;
+            transition: var(--transition);
+        }
+        
+        .form-group input:focus {
+            outline: none;
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 3px rgba(44, 90, 160, 0.1);
+        }
+        
+        .login-button {
+            width: 100%;
+            padding: 12px 16px;
+            background-color: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: var(--border-radius);
+            font-size: 16px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+        
+        .login-button:hover {
+            background-color: #2471a3;
+            transform: translateY(-1px);
+            box-shadow: 0 4px 8px rgba(0,0,0,0.15);
+        }
+        
+        .login-button:active {
+            transform: translateY(0);
+        }
+        
+        .login-button:disabled {
+            background-color: var(--secondary-color);
+            cursor: not-allowed;
+            transform: none;
+        }
+        
+        .error-message {
+            background-color: #fee;
+            color: var(--danger-color);
+            padding: 12px;
+            border-radius: var(--border-radius);
+            margin-bottom: 20px;
+            font-size: 14px;
+            display: none;
+        }
+        
+        .error-message.show {
+            display: block;
+        }
+        
+        .success-message {
+            background-color: #efe;
+            color: var(--success-color);
+            padding: 12px;
+            border-radius: var(--border-radius);
+            margin-bottom: 20px;
+            font-size: 14px;
+            display: none;
+        }
+        
+        .success-message.show {
+            display: block;
+        }
+        
+        .login-footer {
+            margin-top: 30px;
+            text-align: center;
+            color: var(--secondary-color);
+            font-size: 14px;
+        }
+    </style>
+</head>
+<body>
+    <div class="login-container">
+        <div class="login-card">
+            <div class="login-header">
+                <h1>Location Map Viewer</h1>
+                <p>Please sign in to continue</p>
+            </div>
+            
+            <div id="error-message" class="error-message"></div>
+            <div id="success-message" class="success-message"></div>
+            
+            <form id="login-form" class="login-form">
+                <div class="form-group">
+                    <label for="email">Email Address</label>
+                    <input 
+                        type="email" 
+                        id="email" 
+                        name="email" 
+                        placeholder="Enter your email address"
+                        required
+                        autocomplete="email"
+                        autofocus
+                    >
+                </div>
+                
+                <button type="submit" class="login-button" id="login-button">
+                    Sign In
+                </button>
+            </form>
+            
+            <div class="login-footer">
+                <p>Access is restricted to authorized users only.</p>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // Handle login form submission
+        document.getElementById('login-form').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            const email = document.getElementById('email').value;
+            const button = document.getElementById('login-button');
+            const errorMessage = document.getElementById('error-message');
+            const successMessage = document.getElementById('success-message');
+            
+            // Clear previous messages
+            errorMessage.classList.remove('show');
+            successMessage.classList.remove('show');
+            
+            // Disable button and show loading state
+            button.disabled = true;
+            button.textContent = 'Signing in...';
+            
+            try {
+                const response = await fetch('/api/auth/login', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ email }),
+                    credentials: 'include'
+                });
+                
+                // Get response text first
+                const responseText = await response.text();
+                let data;
+                
+                try {
+                    // Try to parse as JSON
+                    data = JSON.parse(responseText);
+                } catch (parseError) {
+                    // If not JSON, handle as text
+                    console.error('Response is not JSON:', responseText);
+                    if (response.status === 429) {
+                        throw new Error('Too many login attempts. Please try again in a few minutes.');
+                    } else {
+                        throw new Error(responseText || `Server error (${response.status})`);
+                    }
+                }
+                
+                if (response.ok && data.success) {
+                    console.log('Login successful, redirecting...');
+                    successMessage.textContent = 'Login successful! Redirecting...';
+                    successMessage.classList.add('show');
+                    
+                    setTimeout(() => {
+                        window.location.replace('/');
+                    }, 500);
+                } else {
+                    throw new Error(data.error || 'Login failed');
+                }
+                
+            } catch (error) {
+                console.error('Login error:', error);
+                errorMessage.textContent = error.message;
+                errorMessage.classList.add('show');
+                button.disabled = false;
+                button.textContent = 'Sign In';
+            }
+        });
+        
+        // Check if already logged in
+        fetch('/api/auth/check')
+            .then(response => response.json())
+            .then(data => {
+                if (data.authenticated) {
+                    window.location.href = '/';
+                }
+            })
+            .catch(console.error);
+    </script>
+</body>
+</html>

map/app/routes/geocoding.js

@@ -0,0 +1,113 @@
+const express = require('express');
+const router = express.Router();
+const rateLimit = require('express-rate-limit');
+const { reverseGeocode, forwardGeocode, getCacheStats } = require('../services/geocoding');
+
+// Rate limiter specifically for geocoding endpoints
+const geocodeLimiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 30, // limit each IP to 30 requests per windowMs
+    message: 'Too many geocoding requests, please try again later.'
+});
+
+/**
+ * Reverse geocode endpoint
+ * GET /api/geocode/reverse?lat=<latitude>&lng=<longitude>
+ */
+router.get('/reverse', geocodeLimiter, async (req, res) => {
+    try {
+        const { lat, lng } = req.query;
+        
+        // Validate input
+        if (!lat || !lng) {
+            return res.status(400).json({
+                success: false,
+                error: 'Latitude and longitude are required'
+            });
+        }
+        
+        const latitude = parseFloat(lat);
+        const longitude = parseFloat(lng);
+        
+        if (isNaN(latitude) || isNaN(longitude)) {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid latitude or longitude'
+            });
+        }
+        
+        if (latitude < -90 || latitude > 90 || longitude < -180 || longitude > 180) {
+            return res.status(400).json({
+                success: false,
+                error: 'Coordinates out of range'
+            });
+        }
+        
+        // Perform reverse geocoding
+        const result = await reverseGeocode(latitude, longitude);
+        
+        res.json({
+            success: true,
+            data: result
+        });
+        
+    } catch (error) {
+        console.error('Reverse geocoding error:', error);
+        
+        const statusCode = error.message.includes('Rate limit') ? 429 : 500;
+        
+        res.status(statusCode).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * Forward geocode endpoint
+ * GET /api/geocode/forward?address=<address>
+ */
+router.get('/forward', geocodeLimiter, async (req, res) => {
+    try {
+        const { address } = req.query;
+        
+        // Validate input
+        if (!address || address.trim().length === 0) {
+            return res.status(400).json({
+                success: false,
+                error: 'Address is required'
+            });
+        }
+        
+        // Perform forward geocoding
+        const result = await forwardGeocode(address);
+        
+        res.json({
+            success: true,
+            data: result
+        });
+        
+    } catch (error) {
+        console.error('Forward geocoding error:', error);
+        
+        const statusCode = error.message.includes('Rate limit') ? 429 : 500;
+        
+        res.status(statusCode).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
+/**
+ * Get geocoding cache statistics (admin endpoint)
+ * GET /api/geocode/cache/stats
+ */
+router.get('/cache/stats', (req, res) => {
+    res.json({
+        success: true,
+        data: getCacheStats()
+    });
+});
+
+module.exports = router;

map/app/server.js

@@ -0,0 +1,801 @@
+const express = require('express');
+const axios = require('axios');
+const cors = require('cors');
+const helmet = require('helmet');
+const rateLimit = require('express-rate-limit');
+const winston = require('winston');
+const path = require('path');
+const session = require('express-session');
+const cookieParser = require('cookie-parser');
+require('dotenv').config();
+
+// Import geocoding routes
+const geocodingRoutes = require('./routes/geocoding');
+
+// Parse project and table IDs from view URL
+function parseNocoDBUrl(url) {
+    if (!url) return { projectId: null, tableId: null };
+    
+    // Pattern to match NocoDB URLs
+    const patterns = [
+        /#\/nc\/([^\/]+)\/([^\/\?#]+)/,  // matches #/nc/PROJECT_ID/TABLE_ID (dashboard URLs)
+        /\/nc\/([^\/]+)\/([^\/\?#]+)/,   // matches /nc/PROJECT_ID/TABLE_ID
+        /project\/([^\/]+)\/table\/([^\/\?#]+)/,  // alternative pattern
+    ];
+    
+    for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match) {
+            return {
+                projectId: match[1],
+                tableId: match[2]
+            };
+        }
+    }
+    
+    return { projectId: null, tableId: null };
+}
+
+// Add this helper function near the top of the file after the parseNocoDBUrl function
+function syncGeoFields(data) {
+    // If we have latitude and longitude but no Geo-Location, create it
+    if (data.latitude && data.longitude && !data['Geo-Location']) {
+        const lat = parseFloat(data.latitude);
+        const lng = parseFloat(data.longitude);
+        if (!isNaN(lat) && !isNaN(lng)) {
+            data['Geo-Location'] = `${lat};${lng}`; // Use semicolon format for NocoDB GeoData
+            data.geodata = `${lat};${lng}`; // Also update geodata for compatibility
+        }
+    }
+    
+    // If we have Geo-Location but no lat/lng, parse it
+    else if (data['Geo-Location'] && (!data.latitude || !data.longitude)) {
+        const geoLocation = data['Geo-Location'].toString();
+        
+        // Try semicolon-separated first
+        let parts = geoLocation.split(';');
+        if (parts.length === 2) {
+            const lat = parseFloat(parts[0].trim());
+            const lng = parseFloat(parts[1].trim());
+            if (!isNaN(lat) && !isNaN(lng)) {
+                data.latitude = lat;
+                data.longitude = lng;
+                data.geodata = `${lat};${lng}`;
+                return data;
+            }
+        }
+        
+        // Try comma-separated
+        parts = geoLocation.split(',');
+        if (parts.length === 2) {
+            const lat = parseFloat(parts[0].trim());
+            const lng = parseFloat(parts[1].trim());
+            if (!isNaN(lat) && !isNaN(lng)) {
+                data.latitude = lat;
+                data.longitude = lng;
+                data.geodata = `${lat};${lng}`;
+                // Normalize Geo-Location to semicolon format for NocoDB GeoData
+                data['Geo-Location'] = `${lat};${lng}`;
+            }
+        }
+    }
+    
+    return data;
+}
+
+// Auto-parse IDs if view URL is provided
+if (process.env.NOCODB_VIEW_URL && (!process.env.NOCODB_PROJECT_ID || !process.env.NOCODB_TABLE_ID)) {
+    const { projectId, tableId } = parseNocoDBUrl(process.env.NOCODB_VIEW_URL);
+    
+    if (projectId && tableId) {
+        process.env.NOCODB_PROJECT_ID = projectId;
+        process.env.NOCODB_TABLE_ID = tableId;
+        console.log(`Auto-parsed from URL - Project ID: ${projectId}, Table ID: ${tableId}`);
+    }
+}
+
+// Auto-parse login sheet ID if URL is provided
+let LOGIN_SHEET_ID = null;
+if (process.env.NOCODB_LOGIN_SHEET) {
+    // Check if it's a URL or just an ID
+    if (process.env.NOCODB_LOGIN_SHEET.startsWith('http')) {
+        const { projectId, tableId } = parseNocoDBUrl(process.env.NOCODB_LOGIN_SHEET);
+        if (projectId && tableId) {
+            LOGIN_SHEET_ID = tableId;
+            console.log(`Auto-parsed login sheet ID from URL: ${LOGIN_SHEET_ID}`);
+        } else {
+            console.error('Could not parse login sheet URL');
+        }
+    } else {
+        // Assume it's already just the ID
+        LOGIN_SHEET_ID = process.env.NOCODB_LOGIN_SHEET;
+        console.log(`Using login sheet ID: ${LOGIN_SHEET_ID}`);
+    }
+}
+
+// Configure logger
+const logger = winston.createLogger({
+    level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
+    format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.json()
+    ),
+    transports: [
+        new winston.transports.Console({
+            format: winston.format.simple()
+        })
+    ]
+});
+
+// Initialize Express app
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Session configuration
+app.use(cookieParser());
+
+// Determine if we should use secure cookies based on environment and request
+const isProduction = process.env.NODE_ENV === 'production';
+
+// Cookie configuration function
+const getCookieConfig = (req) => {
+    const host = req?.get('host') || '';
+    const isLocalhost = host.includes('localhost') || host.includes('127.0.0.1') || host.match(/^\d+\.\d+\.\d+\.\d+/);
+    
+    const config = {
+        httpOnly: true,
+        maxAge: 24 * 60 * 60 * 1000, // 24 hours
+        sameSite: 'lax',
+        secure: false, // Default to false
+        domain: undefined // Default to no domain restriction
+    };
+    
+    // Only set domain and secure for production non-localhost access
+    if (isProduction && !isLocalhost && process.env.COOKIE_DOMAIN) {
+        // Check if the request is coming from a subdomain of COOKIE_DOMAIN
+        const cookieDomain = process.env.COOKIE_DOMAIN.replace(/^\./, ''); // Remove leading dot
+        if (host.includes(cookieDomain)) {
+            config.domain = process.env.COOKIE_DOMAIN;
+            config.secure = true;
+        }
+    }
+    
+    return config;
+};
+
+app.use(session({
+    secret: process.env.SESSION_SECRET || 'your-secret-key-change-in-production',
+    resave: false,
+    saveUninitialized: false,
+    cookie: getCookieConfig(),
+    name: 'nocodb-map-session',
+    genid: (req) => {
+        // Use a custom session ID generator to avoid conflicts
+        return require('crypto').randomBytes(16).toString('hex');
+    }
+}));
+
+// Security middleware
+app.use(helmet({
+    contentSecurityPolicy: {
+        directives: {
+            defaultSrc: ["'self'"],
+            styleSrc: ["'self'", "'unsafe-inline'", "https://unpkg.com"],
+            scriptSrc: ["'self'", "'unsafe-inline'", "https://unpkg.com"],
+            imgSrc: ["'self'", "data:", "https://*.tile.openstreetmap.org"],
+            connectSrc: ["'self'"]
+        }
+    }
+}));
+
+// CORS configuration
+app.use(cors({
+    origin: function(origin, callback) {
+        // Allow requests with no origin (like mobile apps or curl requests)
+        if (!origin) return callback(null, true);
+        
+        const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',') || [];
+        if (allowedOrigins.includes(origin) || allowedOrigins.includes('*')) {
+            callback(null, true);
+        } else {
+            callback(new Error('Not allowed by CORS'));
+        }
+    },
+    credentials: true,
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization']
+}));
+
+// Trust proxy for Cloudflare
+app.set('trust proxy', true);
+
+// Rate limiting with Cloudflare support
+const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: 100,
+    keyGenerator: (req) => {
+        // Use CF-Connecting-IP header if available (Cloudflare)
+        return req.headers['cf-connecting-ip'] || 
+               req.headers['x-forwarded-for']?.split(',')[0] || 
+               req.ip;
+    },
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+
+const strictLimiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: 20,
+    keyGenerator: (req) => {
+        return req.headers['cf-connecting-ip'] || 
+               req.headers['x-forwarded-for']?.split(',')[0] || 
+               req.ip;
+    }
+});
+
+const authLimiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: process.env.NODE_ENV === 'production' ? 10 : 50, // Increase limit slightly
+    message: 'Too many login attempts, please try again later.',
+    keyGenerator: (req) => {
+        return req.headers['cf-connecting-ip'] || 
+               req.headers['x-forwarded-for']?.split(',')[0] || 
+               req.ip;
+    },
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+
+// Middleware
+app.use(express.json({ limit: '10mb' }));
+
+// Authentication middleware
+const requireAuth = (req, res, next) => {
+    if (req.session && req.session.authenticated) {
+        next();
+    } else {
+        if (req.xhr || req.headers.accept?.indexOf('json') > -1) {
+            res.status(401).json({ success: false, error: 'Authentication required' });
+        } else {
+            res.redirect('/login.html');
+        }
+    }
+};
+
+// Serve login page without authentication
+app.get('/login.html', (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'login.html'));
+});
+
+// Auth routes (no authentication required)
+app.post('/api/auth/login', authLimiter, async (req, res) => {
+    try {
+        // Log request details for debugging
+        logger.info('Login attempt:', {
+            email: req.body.email,
+            ip: req.ip,
+            cfIp: req.headers['cf-connecting-ip'],
+            forwardedFor: req.headers['x-forwarded-for'],
+            userAgent: req.headers['user-agent']
+        });
+        
+        const { email } = req.body;
+        
+        if (!email) {
+            return res.status(400).json({
+                success: false,
+                error: 'Email is required'
+            });
+        }
+        
+        // Validate email format
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!emailRegex.test(email)) {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid email format'
+            });
+        }
+        
+        // Check if login sheet is configured
+        if (!LOGIN_SHEET_ID) {
+            logger.error('NOCODB_LOGIN_SHEET not configured or could not be parsed');
+            return res.status(500).json({
+                success: false,
+                error: 'Authentication system not properly configured'
+            });
+        }
+        
+        // Fetch authorized emails from NocoDB
+        const url = `${process.env.NOCODB_API_URL}/db/data/v1/${process.env.NOCODB_PROJECT_ID}/${LOGIN_SHEET_ID}`;
+        
+        logger.info(`Checking authentication for email: ${email}`);
+        logger.debug(`Using login sheet API: ${url}`);
+        
+        const response = await axios.get(url, {
+            headers: {
+                'xc-token': process.env.NOCODB_API_TOKEN,
+                'Content-Type': 'application/json'
+            },
+            params: {
+                limit: 1000 // Adjust if you have more authorized users
+            }
+        });
+        
+        const users = response.data.list || [];
+        
+        // Check if email exists in the authorized users list
+        const authorizedUser = users.find(user => 
+            user.Email && user.Email.toLowerCase() === email.toLowerCase()
+        );
+        
+        if (authorizedUser) {
+            // Set session
+            req.session.authenticated = true;
+            req.session.userEmail = email;
+            req.session.userName = authorizedUser.Name || email;
+            
+            // Force session save before sending response
+            req.session.save((err) => {
+                if (err) {
+                    logger.error('Session save error:', err);
+                    return res.status(500).json({
+                        success: false,
+                        error: 'Session error. Please try again.'
+                    });
+                }
+                
+                logger.info(`User authenticated: ${email}`);
+                
+                res.json({
+                    success: true,
+                    message: 'Login successful',
+                    user: {
+                        email: email,
+                        name: req.session.userName
+                    }
+                });
+            });
+        } else {
+            logger.warn(`Authentication failed for email: ${email}`);
+            res.status(401).json({
+                success: false,
+                error: 'Email not authorized. Please contact an administrator.'
+            });
+        }
+        
+    } catch (error) {
+        logger.error('Login error:', error.message);
+        res.status(500).json({
+            success: false,
+            error: 'Authentication service error. Please try again later.'
+        });
+    }
+});
+
+app.get('/api/auth/check', (req, res) => {
+    res.json({
+        authenticated: req.session?.authenticated || false,
+        user: req.session?.authenticated ? {
+            email: req.session.userEmail,
+            name: req.session.userName
+        } : null
+    });
+});
+
+app.post('/api/auth/logout', (req, res) => {
+    req.session.destroy((err) => {
+        if (err) {
+            logger.error('Logout error:', err);
+            return res.status(500).json({
+                success: false,
+                error: 'Logout failed'
+            });
+        }
+        res.json({
+            success: true,
+            message: 'Logged out successfully'
+        });
+    });
+});
+
+// Add this after the /api/auth/check route
+app.get('/api/debug/session', (req, res) => {
+    res.json({
+        sessionID: req.sessionID,
+        session: req.session,
+        cookies: req.cookies,
+        authenticated: req.session?.authenticated || false
+    });
+});
+
+// Serve static files with authentication for main app
+app.use(express.static(path.join(__dirname, 'public'), {
+    index: false // Don't serve index.html automatically
+}));
+
+// Protect main app routes
+app.get('/', requireAuth, (req, res) => {
+    res.sendFile(path.join(__dirname, 'public', 'index.html'));
+});
+
+// Add geocoding routes (protected)
+app.use('/api/geocode', requireAuth, geocodingRoutes);
+
+// Apply rate limiting to API routes
+app.use('/api/', limiter);
+
+// Health check endpoint (no auth required)
+app.get('/health', (req, res) => {
+    res.json({ 
+        status: 'healthy', 
+        timestamp: new Date().toISOString(),
+        version: process.env.npm_package_version || '1.0.0'
+    });
+});
+
+// Configuration validation endpoint (protected)
+app.get('/api/config-check', requireAuth, (req, res) => {
+    const config = {
+        hasApiUrl: !!process.env.NOCODB_API_URL,
+        hasApiToken: !!process.env.NOCODB_API_TOKEN,
+        hasProjectId: !!process.env.NOCODB_PROJECT_ID,
+        hasTableId: !!process.env.NOCODB_TABLE_ID,
+        hasLoginSheet: !!LOGIN_SHEET_ID,
+        projectId: process.env.NOCODB_PROJECT_ID,
+        tableId: process.env.NOCODB_TABLE_ID,
+        loginSheet: LOGIN_SHEET_ID,
+        loginSheetConfigured: process.env.NOCODB_LOGIN_SHEET,
+        nodeEnv: process.env.NODE_ENV
+    };
+    
+    const isConfigured = config.hasApiUrl && config.hasApiToken && config.hasProjectId && config.hasTableId;
+    
+    res.json({
+        configured: isConfigured,
+        ...config
+    });
+});
+
+// All other API routes require authentication
+app.use('/api/*', requireAuth);
+
+// Get all locations from NocoDB
+app.get('/api/locations', async (req, res) => {
+    try {
+        const { limit = 1000, offset = 0, where } = req.query;
+        
+        const url = `${process.env.NOCODB_API_URL}/db/data/v1/${process.env.NOCODB_PROJECT_ID}/${process.env.NOCODB_TABLE_ID}`;
+        
+        const params = new URLSearchParams({
+            limit,
+            offset
+        });
+        
+        if (where) {
+            params.append('where', where);
+        }
+        
+        logger.info(`Fetching locations from NocoDB: ${url}`);
+        
+        const response = await axios.get(`${url}?${params}`, {
+            headers: {
+                'xc-token': process.env.NOCODB_API_TOKEN,
+                'Content-Type': 'application/json'
+            },
+            timeout: 10000 // 10 second timeout
+        });
+        
+        // Process locations to ensure they have required fields
+        const locations = response.data.list || [];
+        
+        const validLocations = locations.filter(loc => {
+            // Apply geo field synchronization to each location
+            loc = syncGeoFields(loc);
+            
+            // Check if location has valid coordinates
+            if (loc.latitude && loc.longitude) {
+                return true;
+            }
+            
+            // Try to parse from geodata column (semicolon-separated)
+            if (loc.geodata && typeof loc.geodata === 'string') {
+                const parts = loc.geodata.split(';');
+                if (parts.length === 2) {
+                    loc.latitude = parseFloat(parts[0]);
+                    loc.longitude = parseFloat(parts[1]);
+                    return !isNaN(loc.latitude) && !isNaN(loc.longitude);
+                }
+            }
+            
+            // Try to parse from Geo-Location column (semicolon-separated first, then comma)
+            if (loc['Geo-Location'] && typeof loc['Geo-Location'] === 'string') {
+                // Try semicolon first (as we see in the data)
+                let parts = loc['Geo-Location'].split(';');
+                if (parts.length === 2) {
+                    loc.latitude = parseFloat(parts[0].trim());
+                    loc.longitude = parseFloat(parts[1].trim());
+                    if (!isNaN(loc.latitude) && !isNaN(loc.longitude)) {
+                        return true;
+                    }
+                }
+                
+                // Fallback to comma-separated
+                parts = loc['Geo-Location'].split(',');
+                if (parts.length === 2) {
+                    loc.latitude = parseFloat(parts[0].trim());
+                    loc.longitude = parseFloat(parts[1].trim());
+                    return !isNaN(loc.latitude) && !isNaN(loc.longitude);
+                }
+            }
+            
+            return false;
+        });
+        
+        logger.info(`Retrieved ${validLocations.length} valid locations out of ${locations.length} total`);
+        
+        res.json({
+            success: true,
+            count: validLocations.length,
+            total: response.data.pageInfo?.totalRows || validLocations.length,
+            locations: validLocations
+        });
+        
+    } catch (error) {
+        logger.error('Error fetching locations:', error.message);
+        
+        if (error.response) {
+            // NocoDB API error
+            res.status(error.response.status).json({
+                success: false,
+                error: 'Failed to fetch data from NocoDB',
+                details: error.response.data
+            });
+        } else if (error.code === 'ECONNABORTED') {
+            // Timeout
+            res.status(504).json({
+                success: false,
+                error: 'Request timeout'
+            });
+        } else {
+            // Other errors
+            res.status(500).json({
+                success: false,
+                error: 'Internal server error'
+            });
+        }
+    }
+});
+
+// Get single location by ID
+app.get('/api/locations/:id', async (req, res) => {
+    try {
+        const url = `${process.env.NOCODB_API_URL}/db/data/v1/${process.env.NOCODB_PROJECT_ID}/${process.env.NOCODB_TABLE_ID}/${req.params.id}`;
+        
+        const response = await axios.get(url, {
+            headers: {
+                'xc-token': process.env.NOCODB_API_TOKEN
+            }
+        });
+        
+        res.json({
+            success: true,
+            location: response.data
+        });
+        
+    } catch (error) {
+        logger.error(`Error fetching location ${req.params.id}:`, error.message);
+        res.status(error.response?.status || 500).json({
+            success: false,
+            error: 'Failed to fetch location'
+        });
+    }
+});
+
+// Create new location
+app.post('/api/locations', strictLimiter, async (req, res) => {
+    try {
+        let locationData = { ...req.body };
+        
+        // Sync geo fields before validation
+        locationData = syncGeoFields(locationData);
+        
+        const { latitude, longitude, ...additionalData } = locationData;
+        
+        // Validate coordinates
+        if (!latitude || !longitude) {
+            return res.status(400).json({
+                success: false,
+                error: 'Latitude and longitude are required'
+            });
+        }
+        
+        const lat = parseFloat(latitude);
+        const lng = parseFloat(longitude);
+        
+        if (isNaN(lat) || isNaN(lng)) {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid coordinate values'
+            });
+        }
+        
+        if (lat < -90 || lat > 90) {
+            return res.status(400).json({
+                success: false,
+                error: 'Latitude must be between -90 and 90'
+            });
+        }
+        
+        if (lng < -180 || lng > 180) {
+            return res.status(400).json({
+                success: false,
+                error: 'Longitude must be between -180 and 180'
+            });
+        }
+        
+        // Check bounds if configured
+        if (process.env.BOUND_NORTH) {
+            const bounds = {
+                north: parseFloat(process.env.BOUND_NORTH),
+                south: parseFloat(process.env.BOUND_SOUTH),
+                east: parseFloat(process.env.BOUND_EAST),
+                west: parseFloat(process.env.BOUND_WEST)
+            };
+            
+            if (lat > bounds.north || lat < bounds.south || 
+                lng > bounds.east || lng < bounds.west) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'Location is outside allowed bounds'
+                });
+            }
+        }
+        
+        // Format geodata in both formats for compatibility
+        const geodata = `${lat};${lng}`;
+        const geoLocation = `${lat};${lng}`; // Use semicolon format for NocoDB GeoData column
+        
+        // Prepare data for NocoDB
+        const finalData = {
+            geodata,
+            'Geo-Location': geoLocation,
+            latitude: lat,
+            longitude: lng,
+            ...additionalData,
+            created_at: new Date().toISOString(),
+            created_by: req.session.userEmail // Track who created the location
+        };
+        
+        const url = `${process.env.NOCODB_API_URL}/db/data/v1/${process.env.NOCODB_PROJECT_ID}/${process.env.NOCODB_TABLE_ID}`;
+        
+        logger.info('Creating new location:', { lat, lng });
+        
+        const response = await axios.post(url, finalData, {
+            headers: {
+                'xc-token': process.env.NOCODB_API_TOKEN,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        logger.info('Location created successfully:', response.data.id);
+        
+        res.status(201).json({
+            success: true,
+            location: response.data
+        });
+        
+    } catch (error) {
+        logger.error('Error creating location:', error.message);
+        
+        if (error.response) {
+            res.status(error.response.status).json({
+                success: false,
+                error: 'Failed to save location to NocoDB',
+                details: error.response.data
+            });
+        } else {
+            res.status(500).json({
+                success: false,
+                error: 'Internal server error'
+            });
+        }
+    }
+});
+
+// Update location
+app.put('/api/locations/:id', strictLimiter, async (req, res) => {
+    try {
+        let updateData = { ...req.body };
+        
+        // Sync geo fields
+        updateData = syncGeoFields(updateData);
+        
+        updateData.updated_at = new Date().toISOString();
+        updateData.updated_by = req.session.userEmail; // Track who updated
+        
+        const url = `${process.env.NOCODB_API_URL}/db/data/v1/${process.env.NOCODB_PROJECT_ID}/${process.env.NOCODB_TABLE_ID}/${req.params.id}`;
+        
+        const response = await axios.patch(url, updateData, {
+            headers: {
+                'xc-token': process.env.NOCODB_API_TOKEN,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        res.json({
+            success: true,
+            location: response.data
+        });
+        
+    } catch (error) {
+        logger.error(`Error updating location ${req.params.id}:`, error.message);
+        res.status(error.response?.status || 500).json({
+            success: false,
+            error: 'Failed to update location'
+        });
+    }
+});
+
+// Delete location
+app.delete('/api/locations/:id', strictLimiter, async (req, res) => {
+    try {
+        const url = `${process.env.NOCODB_API_URL}/db/data/v1/${process.env.NOCODB_PROJECT_ID}/${process.env.NOCODB_TABLE_ID}/${req.params.id}`;
+        
+        await axios.delete(url, {
+            headers: {
+                'xc-token': process.env.NOCODB_API_TOKEN
+            }
+        });
+        
+        logger.info(`Location ${req.params.id} deleted by ${req.session.userEmail}`);
+        
+        res.json({
+            success: true,
+            message: 'Location deleted successfully'
+        });
+        
+    } catch (error) {
+        logger.error(`Error deleting location ${req.params.id}:`, error.message);
+        res.status(error.response?.status || 500).json({
+            success: false,
+            error: 'Failed to delete location'
+        });
+    }
+});
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+    logger.error('Unhandled error:', err);
+    res.status(500).json({
+        success: false,
+        error: 'Internal server error'
+    });
+});
+
+// Start server
+app.listen(PORT, () => {
+    logger.info(`
+    ╔════════════════════════════════════════╗
+    ║      NocoDB Map Viewer Server          ║
+    ╠════════════════════════════════════════╣
+    ║  Status: Running                       ║
+    ║  Port: ${PORT}                            ║
+    ║  Environment: ${process.env.NODE_ENV || 'development'}          ║
+    ║  Project ID: ${process.env.NOCODB_PROJECT_ID}             ║
+    ║  Table ID: ${process.env.NOCODB_TABLE_ID}               ║
+    ║  Login Sheet: ${LOGIN_SHEET_ID || 'Not Configured'}              ║
+    ║  Time: ${new Date().toISOString()}    ║
+    ╚════════════════════════════════════════╝
+    `);
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+    logger.info('SIGTERM signal received: closing HTTP server');
+    app.close(() => {
+        logger.info('HTTP server closed');
+        process.exit(0);
+    });
+});
+

map/app/services/geocoding.js

@@ -0,0 +1,231 @@
+const axios = require('axios');
+const winston = require('winston');
+
+// Configure logger
+const logger = winston.createLogger({
+    level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
+    format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.json()
+    ),
+    transports: [
+        new winston.transports.Console({
+            format: winston.format.simple()
+        })
+    ]
+});
+
+// Cache for geocoding results (simple in-memory cache)
+const geocodeCache = new Map();
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+
+// Clean up old cache entries periodically
+setInterval(() => {
+    const now = Date.now();
+    for (const [key, value] of geocodeCache.entries()) {
+        if (now - value.timestamp > CACHE_TTL) {
+            geocodeCache.delete(key);
+        }
+    }
+}, 60 * 60 * 1000); // Run every hour
+
+/**
+ * Reverse geocode coordinates to get address
+ * @param {number} lat - Latitude
+ * @param {number} lng - Longitude
+ * @returns {Promise<Object>} Geocoding result
+ */
+async function reverseGeocode(lat, lng) {
+    // Create cache key
+    const cacheKey = `${lat.toFixed(6)},${lng.toFixed(6)}`;
+    
+    // Check cache first
+    const cached = geocodeCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+        logger.debug(`Geocoding cache hit for ${cacheKey}`);
+        return cached.data;
+    }
+    
+    try {
+        // Add delay to respect Nominatim rate limits (max 1 request per second)
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
+        logger.info(`Reverse geocoding: ${lat}, ${lng}`);
+        
+        const response = await axios.get('https://nominatim.openstreetmap.org/reverse', {
+            params: {
+                format: 'json',
+                lat: lat,
+                lon: lng,
+                zoom: 18,
+                addressdetails: 1,
+                'accept-language': 'en'
+            },
+            headers: {
+                'User-Agent': 'NocoDB Map Viewer 1.0 (https://github.com/yourusername/nocodb-map-viewer)'
+            },
+            timeout: 10000
+        });
+        
+        if (response.data.error) {
+            throw new Error(response.data.error);
+        }
+        
+        // Process the response
+        const result = processGeocodeResponse(response.data);
+        
+        // Cache the result
+        geocodeCache.set(cacheKey, {
+            data: result,
+            timestamp: Date.now()
+        });
+        
+        return result;
+        
+    } catch (error) {
+        logger.error('Reverse geocoding error:', error.message);
+        
+        if (error.response?.status === 429) {
+            throw new Error('Rate limit exceeded. Please try again later.');
+        } else if (error.code === 'ECONNABORTED') {
+            throw new Error('Geocoding service timeout');
+        } else {
+            throw new Error('Geocoding service unavailable');
+        }
+    }
+}
+
+/**
+ * Forward geocode address to get coordinates
+ * @param {string} address - Address to geocode
+ * @returns {Promise<Object>} Geocoding result
+ */
+async function forwardGeocode(address) {
+    // Create cache key
+    const cacheKey = `addr:${address.toLowerCase()}`;
+    
+    // Check cache first
+    const cached = geocodeCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+        logger.debug(`Geocoding cache hit for ${cacheKey}`);
+        return cached.data;
+    }
+    
+    try {
+        // Add delay to respect rate limits
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
+        logger.info(`Forward geocoding: ${address}`);
+        
+        const response = await axios.get('https://nominatim.openstreetmap.org/search', {
+            params: {
+                format: 'json',
+                q: address,
+                limit: 1,
+                addressdetails: 1,
+                'accept-language': 'en'
+            },
+            headers: {
+                'User-Agent': 'NocoDB Map Viewer 1.0 (https://github.com/yourusername/nocodb-map-viewer)'
+            },
+            timeout: 10000
+        });
+        
+        if (!response.data || response.data.length === 0) {
+            throw new Error('No results found');
+        }
+        
+        // Process the first result
+        const result = processGeocodeResponse(response.data[0]);
+        
+        // Cache the result
+        geocodeCache.set(cacheKey, {
+            data: result,
+            timestamp: Date.now()
+        });
+        
+        return result;
+        
+    } catch (error) {
+        logger.error('Forward geocoding error:', error.message);
+        
+        if (error.response?.status === 429) {
+            throw new Error('Rate limit exceeded. Please try again later.');
+        } else if (error.code === 'ECONNABORTED') {
+            throw new Error('Geocoding service timeout');
+        } else {
+            throw new Error('Geocoding service unavailable');
+        }
+    }
+}
+
+/**
+ * Process geocoding response into standardized format
+ * @param {Object} data - Raw geocoding response
+ * @returns {Object} Processed geocoding data
+ */
+function processGeocodeResponse(data) {
+    // Extract address components
+    const addressComponents = {
+        house_number: data.address?.house_number || '',
+        road: data.address?.road || '',
+        suburb: data.address?.suburb || data.address?.neighbourhood || '',
+        city: data.address?.city || data.address?.town || data.address?.village || '',
+        state: data.address?.state || data.address?.province || '',
+        postcode: data.address?.postcode || '',
+        country: data.address?.country || ''
+    };
+    
+    // Create formatted address string
+    let formattedAddress = '';
+    if (addressComponents.house_number) formattedAddress += addressComponents.house_number + ' ';
+    if (addressComponents.road) formattedAddress += addressComponents.road + ', ';
+    if (addressComponents.suburb) formattedAddress += addressComponents.suburb + ', ';
+    if (addressComponents.city) formattedAddress += addressComponents.city + ', ';
+    if (addressComponents.state) formattedAddress += addressComponents.state + ' ';
+    if (addressComponents.postcode) formattedAddress += addressComponents.postcode;
+    
+    // Clean up formatting
+    formattedAddress = formattedAddress.trim().replace(/,$/, '');
+    
+    return {
+        fullAddress: data.display_name || '',
+        formattedAddress: formattedAddress,
+        components: addressComponents,
+        coordinates: {
+            lat: parseFloat(data.lat),
+            lng: parseFloat(data.lon)
+        },
+        boundingBox: data.boundingbox || null,
+        placeId: data.place_id || null,
+        osmType: data.osm_type || null,
+        osmId: data.osm_id || null
+    };
+}
+
+/**
+ * Get cache statistics
+ * @returns {Object} Cache statistics
+ */
+function getCacheStats() {
+    return {
+        size: geocodeCache.size,
+        maxSize: 1000, // Could be made configurable
+        ttl: CACHE_TTL
+    };
+}
+
+/**
+ * Clear the geocoding cache
+ */
+function clearCache() {
+    geocodeCache.clear();
+    logger.info('Geocoding cache cleared');
+}
+
+module.exports = {
+    reverseGeocode,
+    forwardGeocode,
+    getCacheStats,
+    clearCache
+};