@olasphe/mongo 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { IUserRepository, ISessionRepository, User, Session } from '@olasubomimk/core';
+export declare class MongoUserRepository implements IUserRepository {
+    create(data: Omit<User, 'id' | 'createdAt' | 'updatedAt'>): Promise<User>;
+    findByEmail(email: string): Promise<User | null>;
+    findById(id: string): Promise<User | null>;
+    update(id: string, updates: Partial<User>): Promise<User>;
+    delete(id: string): Promise<void>;
+    private map;
+}
+export declare class MongoSessionRepository implements ISessionRepository {
+    create(data: Session): Promise<Session>;
+    findByToken(token: string): Promise<Session | null>;
+    deleteByToken(token: string): Promise<void>;
+    revokeAllForUser(userId: string): Promise<void>;
+    revokeOtherSessions(userId: string, currentSessionId: string): Promise<void>;
+    private map;
+}

package/dist/index.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoSessionRepository = exports.MongoUserRepository = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const UserSchema = new mongoose_1.Schema({
+    email: { type: String, required: true, unique: true },
+    passwordHash: { type: String, required: true },
+    isVerified: { type: Boolean, default: false },
+    verificationToken: { type: String },
+    verificationExpires: { type: Date },
+    createdAt: { type: Date, default: Date.now },
+    updatedAt: { type: Date, default: Date.now }
+});
+const UserModel = mongoose_1.default.model('User', UserSchema);
+class MongoUserRepository {
+    async create(data) {
+        const doc = await UserModel.create(data);
+        return this.map(doc);
+    }
+    async findByEmail(email) {
+        const doc = await UserModel.findOne({ email });
+        return doc ? this.map(doc) : null;
+    }
+    async findById(id) {
+        const doc = await UserModel.findById(id);
+        return doc ? this.map(doc) : null;
+    }
+    async update(id, updates) {
+        const doc = await UserModel.findByIdAndUpdate(id, updates, { new: true });
+        if (!doc)
+            throw new Error("User not found");
+        return this.map(doc);
+    }
+    async delete(id) {
+        await UserModel.findByIdAndDelete(id);
+    }
+    map(doc) {
+        return {
+            id: doc._id.toString(),
+            email: doc.email,
+            passwordHash: doc.passwordHash,
+            isVerified: doc.isVerified,
+            verificationToken: doc.verificationToken,
+            verificationExpires: doc.verificationExpires,
+            createdAt: doc.createdAt,
+            updatedAt: doc.updatedAt
+        };
+    }
+}
+exports.MongoUserRepository = MongoUserRepository;
+const SessionSchema = new mongoose_1.Schema({
+    userId: { type: String, required: true },
+    token: { type: String, required: true, unique: true },
+    userAgent: String,
+    ipAddress: String,
+    expiresAt: { type: Date, required: true },
+    createdAt: { type: Date, default: Date.now }
+});
+const SessionModel = mongoose_1.default.model('Session', SessionSchema);
+class MongoSessionRepository {
+    async create(data) {
+        // Mongoose creates _id automatically, but our interface expects `id` to be passed or generated?
+        // In Core `MemorySessionRepository`, we manually generated `id`.
+        // Here we can let Mongo generate it, but we need to respect the interface.
+        // The interface says `create(session: Session): Promise<Session>`.
+        // Usually, the service generates the ID.
+        // If we pass an ID, Mongoose can use it if we set `_id`.
+        // Or we can ignore the passed ID and use Mongoose's.
+        // Let's standardise on using the passed ID as `_id` to be consistent across generic logic.
+        const doc = await SessionModel.create({
+            _id: data.id,
+            ...data
+        });
+        return this.map(doc);
+    }
+    async findByToken(token) {
+        const doc = await SessionModel.findOne({ token });
+        return doc ? this.map(doc) : null;
+    }
+    async deleteByToken(token) {
+        await SessionModel.deleteOne({ token });
+    }
+    async revokeAllForUser(userId) {
+        await SessionModel.deleteMany({ userId });
+    }
+    async revokeOtherSessions(userId, currentSessionId) {
+        await SessionModel.deleteMany({ userId, _id: { $ne: currentSessionId } });
+    }
+    map(doc) {
+        return {
+            id: doc._id.toString(),
+            userId: doc.userId,
+            token: doc.token,
+            userAgent: doc.userAgent,
+            ipAddress: doc.ipAddress,
+            expiresAt: doc.expiresAt,
+            createdAt: doc.createdAt
+        };
+    }
+}
+exports.MongoSessionRepository = MongoSessionRepository;

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@olasphe/mongo",
+    "version": "1.0.0",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "author": "Auth SDK User <user@example.com>",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/example/auth-sdk-monorepo"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc"
+    },
+    "dependencies": {
+        "@olasphe/core": "*",
+        "mongoose": "^8.0.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.0.0"
+    }
+}