@terreno/api 0.0.18 → 0.2.0

package/dist/betterAuthSetup.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * Better Auth setup and initialization for @terreno/api.
+ *
+ * This module provides functions to initialize Better Auth with MongoDB,
+ * create session middleware, and sync users with the application User model.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasBetterAuthSession = exports.getBetterAuthSession = exports.setupBetterAuthUserSync = exports.getMongoClientFromMongoose = exports.mountBetterAuthRoutes = exports.syncBetterAuthUser = exports.createBetterAuthSessionMiddleware = exports.createBetterAuth = void 0;
+var better_auth_1 = require("better-auth");
+var mongodb_1 = require("better-auth/adapters/mongodb");
+var node_1 = require("better-auth/node");
+var mongoose_1 = __importDefault(require("mongoose"));
+var logger_1 = require("./logger");
+/**
+ * Creates a Better Auth instance with MongoDB adapter.
+ */
+var createBetterAuth = function (options) {
+    var _a, _b;
+    var config = options.config, mongoClient = options.mongoClient;
+    var secret = config.secret || process.env.BETTER_AUTH_SECRET;
+    if (!secret) {
+        throw new Error("BETTER_AUTH_SECRET must be set in env or config.secret must be provided.");
+    }
+    var baseURL = config.baseURL || process.env.BETTER_AUTH_URL;
+    if (!baseURL) {
+        throw new Error("BETTER_AUTH_URL must be set in env or config.baseURL must be provided.");
+    }
+    var basePath = (_a = config.basePath) !== null && _a !== void 0 ? _a : "/api/auth";
+    var socialProviders = {};
+    if (config.googleOAuth) {
+        socialProviders.google = {
+            clientId: config.googleOAuth.clientId,
+            clientSecret: config.googleOAuth.clientSecret,
+        };
+    }
+    if (config.appleOAuth) {
+        socialProviders.apple = {
+            clientId: config.appleOAuth.clientId,
+            clientSecret: config.appleOAuth.clientSecret,
+        };
+    }
+    if (config.githubOAuth) {
+        socialProviders.github = {
+            clientId: config.githubOAuth.clientId,
+            clientSecret: config.githubOAuth.clientSecret,
+        };
+    }
+    var auth = (0, better_auth_1.betterAuth)({
+        basePath: basePath,
+        baseURL: baseURL,
+        database: (0, mongodb_1.mongodbAdapter)(mongoClient.db()),
+        emailAndPassword: {
+            enabled: true,
+        },
+        secret: secret,
+        session: {
+            cookieCache: {
+                enabled: true,
+                maxAge: 5 * 60, // 5 minutes
+            },
+        },
+        socialProviders: Object.keys(socialProviders).length > 0 ? socialProviders : undefined,
+        trustedOrigins: (_b = config.trustedOrigins) !== null && _b !== void 0 ? _b : [],
+    });
+    return auth;
+};
+exports.createBetterAuth = createBetterAuth;
+/**
+ * Creates Express middleware that extracts the Better Auth session
+ * and populates req.user with the application User model.
+ */
+var createBetterAuthSessionMiddleware = function (auth, userModel) {
+    return function (req, _res, next) { return __awaiter(void 0, void 0, void 0, function () {
+        var session, betterAuthUser, appUser, newUser, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 8, , 9]);
+                    return [4 /*yield*/, auth.api.getSession({
+                            headers: req.headers,
+                        })];
+                case 1:
+                    session = _a.sent();
+                    if (!((session === null || session === void 0 ? void 0 : session.user) && (session === null || session === void 0 ? void 0 : session.session))) return [3 /*break*/, 7];
+                    betterAuthUser = session.user;
+                    if (!userModel) return [3 /*break*/, 6];
+                    return [4 /*yield*/, userModel.findOne({ betterAuthId: betterAuthUser.id })];
+                case 2:
+                    appUser = _a.sent();
+                    if (!appUser) return [3 /*break*/, 3];
+                    req.user = appUser;
+                    req.betterAuthSession = session;
+                    return [3 /*break*/, 5];
+                case 3: return [4 /*yield*/, (0, exports.syncBetterAuthUser)(userModel, betterAuthUser)];
+                case 4:
+                    newUser = _a.sent();
+                    req.user = newUser;
+                    req.betterAuthSession = session;
+                    _a.label = 5;
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    // No user model - just attach the Better Auth user directly
+                    req.user = {
+                        _id: betterAuthUser.id,
+                        admin: false,
+                        betterAuthId: betterAuthUser.id,
+                        email: betterAuthUser.email,
+                        id: betterAuthUser.id,
+                        name: betterAuthUser.name,
+                    };
+                    req.betterAuthSession = session;
+                    _a.label = 7;
+                case 7:
+                    next();
+                    return [3 /*break*/, 9];
+                case 8:
+                    error_1 = _a.sent();
+                    logger_1.logger.debug("Better Auth session extraction error: ".concat(error_1));
+                    next();
+                    return [3 /*break*/, 9];
+                case 9: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+exports.createBetterAuthSessionMiddleware = createBetterAuthSessionMiddleware;
+/**
+ * Syncs a Better Auth user to the application User model.
+ * Creates or updates the user as needed.
+ */
+var syncBetterAuthUser = function (userModel, betterAuthUser, oauthProvider) { return __awaiter(void 0, void 0, void 0, function () {
+    var existingUser, userByEmail, newUser, error_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 8, , 9]);
+                return [4 /*yield*/, userModel.findOne({ betterAuthId: betterAuthUser.id })];
+            case 1:
+                existingUser = _a.sent();
+                if (!existingUser) return [3 /*break*/, 3];
+                // Update existing user if needed
+                existingUser.email = betterAuthUser.email;
+                if (betterAuthUser.name) {
+                    existingUser.name = betterAuthUser.name;
+                }
+                return [4 /*yield*/, existingUser.save()];
+            case 2:
+                _a.sent();
+                return [2 /*return*/, existingUser];
+            case 3: return [4 /*yield*/, userModel.findOne({ email: betterAuthUser.email })];
+            case 4:
+                userByEmail = _a.sent();
+                if (!userByEmail) return [3 /*break*/, 6];
+                // Link existing user to Better Auth
+                userByEmail.betterAuthId = betterAuthUser.id;
+                if (oauthProvider) {
+                    userByEmail.oauthProvider = oauthProvider;
+                }
+                return [4 /*yield*/, userByEmail.save()];
+            case 5:
+                _a.sent();
+                return [2 /*return*/, userByEmail];
+            case 6:
+                newUser = new userModel({
+                    admin: false,
+                    betterAuthId: betterAuthUser.id,
+                    email: betterAuthUser.email,
+                    name: betterAuthUser.name || betterAuthUser.email.split("@")[0],
+                    oauthProvider: oauthProvider || null,
+                });
+                return [4 /*yield*/, newUser.save()];
+            case 7:
+                _a.sent();
+                logger_1.logger.info("Created new user from Better Auth: ".concat(newUser.id));
+                return [2 /*return*/, newUser];
+            case 8:
+                error_2 = _a.sent();
+                logger_1.logger.error("Error syncing Better Auth user: ".concat(error_2));
+                throw error_2;
+            case 9: return [2 /*return*/];
+        }
+    });
+}); };
+exports.syncBetterAuthUser = syncBetterAuthUser;
+/**
+ * Mounts Better Auth routes on the Express app.
+ */
+var mountBetterAuthRoutes = function (app, auth, basePath) {
+    if (basePath === void 0) { basePath = "/api/auth"; }
+    var handler = (0, node_1.toNodeHandler)(auth);
+    // Mount at the base path with wildcard
+    app.all("".concat(basePath, "/*"), function (req, res) {
+        return handler(req, res);
+    });
+    logger_1.logger.info("Better Auth routes mounted at ".concat(basePath, "/*"));
+};
+exports.mountBetterAuthRoutes = mountBetterAuthRoutes;
+/**
+ * Gets the MongoDB client from the mongoose connection.
+ */
+var getMongoClientFromMongoose = function () {
+    var connection = mongoose_1.default.connection;
+    var client = connection.client;
+    if (!client) {
+        throw new Error("Mongoose is not connected. Ensure MongoDB connection is established first.");
+    }
+    return client;
+};
+exports.getMongoClientFromMongoose = getMongoClientFromMongoose;
+/**
+ * Sets up Better Auth user sync hooks.
+ * This ensures users created/updated in Better Auth are synced to the application User model.
+ *
+ * Note: Better Auth doesn't have built-in event hooks, so we rely on the session middleware
+ * to create users on first session access.
+ */
+var setupBetterAuthUserSync = function (_auth, _userModel) {
+    // Better Auth v1.x doesn't expose event hooks for user creation.
+    // User sync is handled in createBetterAuthSessionMiddleware when a session is accessed.
+    // This function is a placeholder for future versions that may support hooks.
+    logger_1.logger.debug("Better Auth user sync configured (via session middleware)");
+};
+exports.setupBetterAuthUserSync = setupBetterAuthUserSync;
+/**
+ * Extracts Better Auth session data from the request.
+ */
+var getBetterAuthSession = function (req) {
+    var _a;
+    return (_a = req.betterAuthSession) !== null && _a !== void 0 ? _a : null;
+};
+exports.getBetterAuthSession = getBetterAuthSession;
+/**
+ * Checks if the request has a valid Better Auth session.
+ */
+var hasBetterAuthSession = function (req) {
+    return Boolean(req.betterAuthSession);
+};
+exports.hasBetterAuthSession = hasBetterAuthSession;

package/dist/betterAuthSetup.test.d.ts

@@ -0,0 +1 @@
+export {};