Backend Language Proficiency Questions

// middleware/authBearer.js
const validateToken = require('./tokenValidator'); // sync/async function that returns user info or false

/**
 * Express middleware to enforce Bearer auth.
 * Signature: (req, res, next)
 */
function authBearer(req, res, next) {
  const reqId = req.headers['x-request-id'] || req.id || 'unknown';
  const path = req.originalUrl || req.url;

  const auth = req.headers['authorization'] || '';
  const match = auth.match(/^Bearer\s+(.+)$/i);
  if (!match) {
    console.warn(`[auth] reqId=${reqId} path=${path} - missing token`);
    return res.status(401).json({ error: 'Missing Authorization bearer token' });
  }

  const token = match[1];
  try {
    const user = validateToken(token); // could be async; handle Promise if needed
    if (!user) {
      console.warn(`[auth] reqId=${reqId} path=${path} - invalid token`);
      return res.status(401).json({ error: 'Invalid token' });
    }
    req.user = user;
    console.info(`[auth] reqId=${reqId} path=${path} - authenticated user=${user.id || 'unknown'}`);
    return next();
  } catch (err) {
    console.error(`[auth] reqId=${reqId} path=${path} - validator error`, err);
    return res.status(401).json({ error: 'Authentication error' });
  }
}

module.exports = authBearer;

public final class HeavyModelSingleton {
    // volatile ensures writes to this variable happen-before subsequent reads
    private static volatile HeavyModelSingleton instance;

    // Heavy model object (simulate expensive load)
    private final Model model;

    private HeavyModelSingleton() {
        // load heavy model (IO, deserialize weights, etc.)
        this.model = loadModel();
    }

    public static HeavyModelSingleton getInstance() {
        if (instance == null) {                      // first check (fast path)
            synchronized (HeavyModelSingleton.class) {
                if (instance == null) {              // second check (safe)
                    instance = new HeavyModelSingleton();
                }
            }
        }
        return instance;
    }

    public Model getModel() {
        return model;
    }

    private Model loadModel() {
        // placeholder: expensive initialization (disk, network, GPU warm-up)
        return new Model();
    }

    // Example model class
    public static class Model { /* weights, inference methods */ }
}

public final class HolderSingleton {
  private HolderSingleton() { /* load model */ }
  private static class Holder { static final HolderSingleton INSTANCE = new HolderSingleton(); }
  public static HolderSingleton getInstance() { return Holder.INSTANCE; }
}

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;

public class Iso8601Parser {

    // Checked exception for parsing errors
    public static class IsoParseException extends Exception {
        public IsoParseException(String message, Throwable cause) { super(message, cause); }
        public IsoParseException(String message) { super(message); }
    }

    /**
     * Parse an ISO 8601 timestamp and return epoch milliseconds.
     * Accepts offsets or 'Z'. If input has no timezone/offset, it's treated as UTC.
     * Handles leap-second notation "60" by normalizing to "59" and adding 1 second.
     */
    public static long parseIso8601ToEpochMillis(String iso) throws IsoParseException {
        if (iso == null || iso.isBlank()) throw new IsoParseException("Input timestamp is null or empty");

        String input = iso.trim();

        // Detect leap second "60" in seconds field like ":59:60" or "T23:59:60"
        // Use regex to find seconds=60; simple approach:
        if (input.matches(".*T.*:(60)(?:[.,]\\d+)?(?:Z|[+-].*|$)")) {
            // Replace ":60" with ":59" and remember to add 1 second after parsing
            input = input.replaceFirst(":(60)(?=[.,Z+\\-]|$)", ":59");
            try {
                Instant parsed = parseWithZoneFallback(input);
                return parsed.plusSeconds(1).toEpochMilli();
            } catch (IsoParseException e) {
                throw new IsoParseException("Failed to parse leap-second timestamp: " + iso, e);
            }
        }

        // Normal path
        try {
            Instant parsed = parseWithZoneFallback(input);
            return parsed.toEpochMilli();
        } catch (DateTimeParseException e) {
            throw new IsoParseException("Invalid ISO 8601 timestamp: " + iso, e);
        }
    }

    // Helper: try parsing with Instant, OffsetDateTime, or assume UTC if no offset present
    private static Instant parseWithZoneFallback(String input) throws DateTimeParseException, IsoParseException {
        // Fast path: ISO_INSTANT handles "Z" and fractional seconds with 'Z'
        try {
            return Instant.parse(input);
        } catch (DateTimeParseException ignored) { }

        // Try parsing as OffsetDateTime (handles "+02:00")
        try {
            OffsetDateTime odt = OffsetDateTime.parse(input, DateTimeFormatter.ISO_OFFSET_DATE_TIME);
            return odt.toInstant();
        } catch (DateTimeParseException ignored) { }

        // If no offset present, treat as local timestamp — here we choose UTC as default policy
        // Example inputs: "2023-11-15T13:45:30" -> interpret as 13:45:30 UTC
        if (!input.endsWith("Z") && !input.matches(".*[+-]\\d{2}:?\\d{2}$")) {
            try {
                LocalDateTime ldt = LocalDateTime.parse(input, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
                return ldt.toInstant(ZoneOffset.UTC); // policy: assume UTC
            } catch (DateTimeParseException e) {
                throw e;
            }
        }

        throw new DateTimeParseException("Unrecognized ISO 8601 format", input, 0);
    }
}