@lastshotlabs/bunshot 0.0.25 → 0.0.28

package/dist/lib/resetPassword.js

@@ -1,91 +0,0 @@
-import { getRedis } from "./redis";
-import { appConnection, mongoose } from "./mongo";
-import { getAppName, getResetTokenExpiry } from "./appConfig";
-import { sqliteCreateResetToken, sqliteConsumeResetToken, } from "../adapters/sqliteAuth";
-import { memoryCreateResetToken, memoryConsumeResetToken, } from "../adapters/memoryAuth";
-import { sha256 as hashToken } from "./crypto";
-function getResetModel() {
-    if (appConnection.models["PasswordReset"])
-        return appConnection.models["PasswordReset"];
-    const { Schema } = mongoose;
-    const resetSchema = new Schema({
-        token: { type: String, required: true, unique: true },
-        userId: { type: String, required: true },
-        email: { type: String, required: true },
-        expiresAt: { type: Date, required: true, index: { expireAfterSeconds: 0 } },
-    }, { collection: "password_resets" });
-    return appConnection.model("PasswordReset", resetSchema);
-}
-// ---------------------------------------------------------------------------
-// Redis helpers
-// ---------------------------------------------------------------------------
-/** Atomically GET+DEL a key. Uses native GETDEL (Redis >= 6.2) with a Lua fallback. */
-async function redisGetDel(key) {
-    const redis = getRedis();
-    if (typeof redis.getdel === "function") {
-        try {
-            return await redis.getdel(key);
-        }
-        catch (err) {
-            const msg = err?.message ?? "";
-            if (!/unknown command|ERR unknown command/i.test(msg))
-                throw err;
-            // Fall through to Lua on "unknown command"
-        }
-    }
-    const result = await redis.eval("local v = redis.call('GET', KEYS[1])\nif v then redis.call('DEL', KEYS[1]) end\nreturn v", 1, key);
-    return result ?? null;
-}
-let _store = "redis";
-export const setPasswordResetStore = (store) => { _store = store; };
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/** Create a reset token. Returns the raw token (to embed in the email link).
- *  Only the SHA-256 hash is persisted in the store. */
-export const createResetToken = async (userId, email) => {
-    const token = crypto.randomUUID();
-    const hash = hashToken(token);
-    const ttl = getResetTokenExpiry();
-    if (_store === "memory") {
-        memoryCreateResetToken(hash, userId, email, ttl);
-        return token;
-    }
-    if (_store === "sqlite") {
-        sqliteCreateResetToken(hash, userId, email, ttl);
-        return token;
-    }
-    if (_store === "mongo") {
-        await getResetModel().create({
-            token: hash,
-            userId,
-            email,
-            expiresAt: new Date(Date.now() + ttl * 1000),
-        });
-        return token;
-    }
-    await getRedis().set(`reset:${getAppName()}:${hash}`, JSON.stringify({ userId, email }), "EX", ttl);
-    return token;
-};
-/** Atomically consume a reset token — returns its payload and deletes it in one operation.
- *  Returns null if the token is invalid, expired, or already used. */
-export const consumeResetToken = async (token) => {
-    const hash = hashToken(token);
-    if (_store === "memory")
-        return memoryConsumeResetToken(hash);
-    if (_store === "sqlite")
-        return sqliteConsumeResetToken(hash);
-    if (_store === "mongo") {
-        const doc = await getResetModel()
-            .findOneAndDelete({ token: hash, expiresAt: { $gt: new Date() } })
-            .lean();
-        if (!doc)
-            return null;
-        return { userId: doc.userId, email: doc.email };
-    }
-    // Redis: atomically return and remove the key (GETDEL or Lua fallback)
-    const raw = await redisGetDel(`reset:${getAppName()}:${hash}`);
-    if (!raw)
-        return null;
-    return JSON.parse(raw);
-};

package/dist/lib/roles.d.ts

@@ -1,7 +0,0 @@
-export declare const setUserRoles: (userId: string, roles: string[]) => Promise<void>;
-export declare const addUserRole: (userId: string, role: string) => Promise<void>;
-export declare const removeUserRole: (userId: string, role: string) => Promise<void>;
-export declare const getTenantRoles: (userId: string, tenantId: string) => Promise<string[]>;
-export declare const setTenantRoles: (userId: string, tenantId: string, roles: string[]) => Promise<void>;
-export declare const addTenantRole: (userId: string, tenantId: string, role: string) => Promise<void>;
-export declare const removeTenantRole: (userId: string, tenantId: string, role: string) => Promise<void>;

package/dist/lib/roles.js

@@ -1,49 +0,0 @@
-import { getAuthAdapter } from "./authAdapter";
-const requireMethod = (method) => {
-    throw new Error(`Auth adapter does not implement ${method} — add it to your adapter to manage roles`);
-};
-export const setUserRoles = async (userId, roles) => {
-    const adapter = getAuthAdapter();
-    if (!adapter.setRoles)
-        requireMethod("setRoles");
-    await adapter.setRoles(userId, roles);
-};
-export const addUserRole = async (userId, role) => {
-    const adapter = getAuthAdapter();
-    if (!adapter.addRole)
-        requireMethod("addRole");
-    await adapter.addRole(userId, role);
-};
-export const removeUserRole = async (userId, role) => {
-    const adapter = getAuthAdapter();
-    if (!adapter.removeRole)
-        requireMethod("removeRole");
-    await adapter.removeRole(userId, role);
-};
-// ---------------------------------------------------------------------------
-// Tenant-scoped role helpers
-// ---------------------------------------------------------------------------
-export const getTenantRoles = async (userId, tenantId) => {
-    const adapter = getAuthAdapter();
-    if (!adapter.getTenantRoles)
-        requireMethod("getTenantRoles");
-    return adapter.getTenantRoles(userId, tenantId);
-};
-export const setTenantRoles = async (userId, tenantId, roles) => {
-    const adapter = getAuthAdapter();
-    if (!adapter.setTenantRoles)
-        requireMethod("setTenantRoles");
-    await adapter.setTenantRoles(userId, tenantId, roles);
-};
-export const addTenantRole = async (userId, tenantId, role) => {
-    const adapter = getAuthAdapter();
-    if (!adapter.addTenantRole)
-        requireMethod("addTenantRole");
-    await adapter.addTenantRole(userId, tenantId, role);
-};
-export const removeTenantRole = async (userId, tenantId, role) => {
-    const adapter = getAuthAdapter();
-    if (!adapter.removeTenantRole)
-        requireMethod("removeTenantRole");
-    await adapter.removeTenantRole(userId, tenantId, role);
-};

package/dist/lib/session.d.ts

@@ -1,39 +0,0 @@
-export interface SessionMetadata {
-    ipAddress?: string;
-    userAgent?: string;
-}
-export interface SessionInfo {
-    sessionId: string;
-    createdAt: number;
-    lastActiveAt: number;
-    expiresAt: number;
-    ipAddress?: string;
-    userAgent?: string;
-    isActive: boolean;
-}
-export interface RefreshResult {
-    sessionId: string;
-    userId: string;
-    newRefreshToken: string;
-}
-type SessionStore = "redis" | "mongo" | "sqlite" | "memory";
-export declare const setSessionStore: (store: SessionStore) => void;
-export declare const createSession: (userId: string, token: string, sessionId: string, metadata?: SessionMetadata) => Promise<void>;
-export declare const getSession: (sessionId: string) => Promise<string | null>;
-export declare const deleteSession: (sessionId: string) => Promise<void>;
-export declare const getUserSessions: (userId: string) => Promise<SessionInfo[]>;
-export declare const getActiveSessionCount: (userId: string) => Promise<number>;
-export declare const evictOldestSession: (userId: string) => Promise<void>;
-export declare const deleteUserSessions: (userId: string) => Promise<void>;
-export declare const updateSessionLastActive: (sessionId: string) => Promise<void>;
-/** Store a refresh token on an existing session (called after session creation). */
-export declare const setRefreshToken: (sessionId: string, refreshToken: string) => Promise<void>;
-/** Look up a session by refresh token. Handles grace window and theft detection. */
-export declare const getSessionByRefreshToken: (refreshToken: string) => Promise<RefreshResult | null>;
-/** Rotate the refresh token: move current to prev with grace window, set new token + access token. */
-export declare const rotateRefreshToken: (sessionId: string, newRefreshToken: string, newAccessToken: string) => Promise<void>;
-/** Read the stored fingerprint for a session. Returns null if not yet set. */
-export declare const getSessionFingerprint: (sessionId: string) => Promise<string | null>;
-/** Store a fingerprint on an existing session. No-op if the session does not exist. */
-export declare const setSessionFingerprint: (sessionId: string, fingerprint: string) => Promise<void>;
-export {};