@lastshotlabs/bunshot 0.0.9 → 0.0.13

package/dist/entrypoints/queue.js

@@ -0,0 +1 @@
+export { createQueue, createWorker } from "../lib/queue";

package/dist/entrypoints/redis.d.ts

@@ -0,0 +1 @@
+export { connectRedis, disconnectRedis, getRedis } from "../lib/redis";

package/dist/entrypoints/redis.js

@@ -0,0 +1 @@
+export { connectRedis, disconnectRedis, getRedis } from "../lib/redis";

package/dist/index.d.ts

@@ -1,18 +1,18 @@
 export { createApp } from "./app";
 export { createServer } from "./server";
-export type { CreateAppConfig, DbConfig, AppMeta, AuthConfig, AuthRateLimitConfig, OAuthConfig, SecurityConfig, BotProtectionConfig, PrimaryField, EmailVerificationConfig } from "./app";
+export type { CreateAppConfig, ModelSchemasConfig, DbConfig, AppMeta, AuthConfig, AuthRateLimitConfig, OAuthConfig, SecurityConfig, BotProtectionConfig, PrimaryField, EmailVerificationConfig, PasswordResetConfig } from "./app";
 export type { CreateServerConfig, WsConfig } from "./server";
+export { appConnection, authConnection, mongoose, connectMongo, connectAuthMongo, connectAppMongo, disconnectMongo } from "./lib/mongo";
+export { connectRedis, disconnectRedis, getRedis } from "./lib/redis";
 export { getAppRoles } from "./lib/appConfig";
 export { HttpError } from "./lib/HttpError";
 export { COOKIE_TOKEN, HEADER_USER_TOKEN } from "./lib/constants";
 export { createRouter } from "./lib/context";
+export { createRoute, withSecurity, registerSchema, registerSchemas } from "./lib/createRoute";
 export type { AppEnv, AppVariables } from "./lib/context";
 export { signToken, verifyToken } from "./lib/jwt";
 export { log } from "./lib/logger";
-export { connectMongo, connectAuthMongo, connectAppMongo, disconnectMongo, authConnection, appConnection, mongoose } from "./lib/mongo";
-export { connectRedis, disconnectRedis, getRedis } from "./lib/redis";
-export { createQueue, createWorker } from "./lib/queue";
-export type { Job } from "./lib/queue";
+export { createResetToken, consumeResetToken, setPasswordResetStore } from "./lib/resetPassword";
 export { createSession, getSession, deleteSession, getUserSessions, getActiveSessionCount, evictOldestSession, updateSessionLastActive, setSessionStore } from "./lib/session";
 export type { SessionMetadata, SessionInfo } from "./lib/session";
 export { createVerificationToken, getVerificationToken, deleteVerificationToken } from "./lib/emailVerification";
@@ -30,8 +30,6 @@ export { requireRole } from "./middleware/requireRole";
 export { requireVerifiedEmail } from "./middleware/requireVerifiedEmail";
 export { cacheResponse, bustCache, bustCachePattern, setCacheStore } from "./middleware/cacheResponse";
 export { buildFingerprint } from "./lib/fingerprint";
-export { AuthUser } from "./models/AuthUser";
-export { mongoAuthAdapter } from "./adapters/mongoAuth";
 export { sqliteAuthAdapter, setSqliteDb, startSqliteCleanup } from "./adapters/sqliteAuth";
 export { memoryAuthAdapter, clearMemoryStore } from "./adapters/memoryAuth";
 export { setUserRoles, addUserRole, removeUserRole } from "./lib/roles";

package/dist/index.js

@@ -1,16 +1,18 @@
 // App factory
 export { createApp } from "./app";
 export { createServer } from "./server";
+// Database
+export { appConnection, authConnection, mongoose, connectMongo, connectAuthMongo, connectAppMongo, disconnectMongo } from "./lib/mongo";
+export { connectRedis, disconnectRedis, getRedis } from "./lib/redis";
 // Lib utilities
 export { getAppRoles } from "./lib/appConfig";
 export { HttpError } from "./lib/HttpError";
 export { COOKIE_TOKEN, HEADER_USER_TOKEN } from "./lib/constants";
 export { createRouter } from "./lib/context";
+export { createRoute, withSecurity, registerSchema, registerSchemas } from "./lib/createRoute";
 export { signToken, verifyToken } from "./lib/jwt";
 export { log } from "./lib/logger";
-export { connectMongo, connectAuthMongo, connectAppMongo, disconnectMongo, authConnection, appConnection, mongoose } from "./lib/mongo";
-export { connectRedis, disconnectRedis, getRedis } from "./lib/redis";
-export { createQueue, createWorker } from "./lib/queue";
+export { createResetToken, consumeResetToken, setPasswordResetStore } from "./lib/resetPassword";
 export { createSession, getSession, deleteSession, getUserSessions, getActiveSessionCount, evictOldestSession, updateSessionLastActive, setSessionStore } from "./lib/session";
 export { createVerificationToken, getVerificationToken, deleteVerificationToken } from "./lib/emailVerification";
 export { bustAuthLimit, trackAttempt, isLimited } from "./lib/authRateLimit";
@@ -27,8 +29,6 @@ export { cacheResponse, bustCache, bustCachePattern, setCacheStore } from "./mid
 // Lib utilities (bot protection)
 export { buildFingerprint } from "./lib/fingerprint";
 // Models
-export { AuthUser } from "./models/AuthUser";
-export { mongoAuthAdapter } from "./adapters/mongoAuth";
 export { sqliteAuthAdapter, setSqliteDb, startSqliteCleanup } from "./adapters/sqliteAuth";
 export { memoryAuthAdapter, clearMemoryStore } from "./adapters/memoryAuth";
 export { setUserRoles, addUserRole, removeUserRole } from "./lib/roles";

package/dist/lib/appConfig.d.ts

@@ -7,6 +7,12 @@ export interface EmailVerificationConfig {
     /** Called after registration with the identifier and verification token. Use to send the email. */
     onSend: (email: string, token: string) => Promise<void>;
 }
+export interface PasswordResetConfig {
+    /** Token time-to-live in seconds. Defaults to 3 600 (1 hour). */
+    tokenExpiry?: number;
+    /** Called with the user's email and the reset token. Use to send the reset email. */
+    onSend: (email: string, token: string) => Promise<void>;
+}
 export declare const setAppName: (name: string) => void;
 export declare const getAppName: () => string;
 export declare const setAppRoles: (roles: string[]) => void;
@@ -18,6 +24,9 @@ export declare const getPrimaryField: () => PrimaryField;
 export declare const setEmailVerificationConfig: (config: EmailVerificationConfig | null) => void;
 export declare const getEmailVerificationConfig: () => EmailVerificationConfig | null;
 export declare const getTokenExpiry: () => number;
+export declare const setPasswordResetConfig: (config: PasswordResetConfig | null) => void;
+export declare const getPasswordResetConfig: () => PasswordResetConfig | null;
+export declare const getResetTokenExpiry: () => number;
 export declare const setMaxSessions: (n: number) => void;
 export declare const getMaxSessions: () => number;
 export declare const setPersistSessionMetadata: (v: boolean) => void;

package/dist/lib/appConfig.js

@@ -3,6 +3,7 @@ let appRoles = [];
 let defaultRole = null;
 let _primaryField = "email";
 let _emailVerificationConfig = null;
+let _passwordResetConfig = null;
 export const setAppName = (name) => { appName = name; };
 export const getAppName = () => appName;
 export const setAppRoles = (roles) => { appRoles = roles; };
@@ -15,6 +16,10 @@ export const setEmailVerificationConfig = (config) => { _emailVerificationConfig
 export const getEmailVerificationConfig = () => _emailVerificationConfig;
 const DEFAULT_TOKEN_EXPIRY = 60 * 60 * 24; // 24 hours
 export const getTokenExpiry = () => _emailVerificationConfig?.tokenExpiry ?? DEFAULT_TOKEN_EXPIRY;
+export const setPasswordResetConfig = (config) => { _passwordResetConfig = config; };
+export const getPasswordResetConfig = () => _passwordResetConfig;
+const DEFAULT_RESET_TOKEN_EXPIRY = 60 * 60; // 1 hour
+export const getResetTokenExpiry = () => _passwordResetConfig?.tokenExpiry ?? DEFAULT_RESET_TOKEN_EXPIRY;
 // ---------------------------------------------------------------------------
 // Session policy
 // ---------------------------------------------------------------------------

package/dist/lib/createRoute.d.ts

@@ -0,0 +1,61 @@
+import type { RouteConfig } from "@hono/zod-openapi";
+import type { ZodType } from "zod";
+/**
+ * Registers a Zod schema as a named entry in `components/schemas`.
+ *
+ * Use this for shared schemas (e.g. shared error types, reusable response shapes)
+ * that aren't directly attached to a specific route. Schemas already registered
+ * under the same name are silently skipped.
+ *
+ * @example
+ * export const MySchema = registerSchema("MySchema", z.object({ id: z.string() }));
+ */
+export declare const registerSchema: <T extends ZodType>(name: string, schema: T) => T;
+/**
+ * Registers multiple Zod schemas at once as named entries in `components/schemas`.
+ * Object keys become the schema names. Returns the same object so you can
+ * destructure or re-export the schemas normally.
+ *
+ * Schemas already registered (e.g. via a prior `registerSchema` call) are skipped.
+ *
+ * @example
+ * export const { LedgerItem, Product } = registerSchemas({
+ *   LedgerItem: z.object({ id: z.string(), amount: z.number() }),
+ *   Product:    z.object({ id: z.string(), price: z.number() }),
+ * });
+ */
+export declare const registerSchemas: <T extends Record<string, ZodType>>(schemas: T) => T;
+/**
+ * Auto-registers a module export as a named OpenAPI schema.
+ * Used internally by modelSchemas auto-discovery in createApp.
+ * Strips a trailing "Schema" suffix from the export name.
+ * Skips non-Zod values and already-registered schemas.
+ */
+export declare function maybeAutoRegister(exportName: string, value: unknown): void;
+/**
+ * Adds an OpenAPI `security` requirement to a route without affecting TypeScript
+ * type inference on the handler. Pass each security scheme as a separate object.
+ *
+ * Use this instead of inlining `security` in `createRoute(...)` — inlining a
+ * field typed as `{ [name: string]: string[] }` breaks `c.req.valid()` inference.
+ *
+ * @example
+ * router.openapi(
+ *   withSecurity(createRoute({ method: "get", path: "/me", ... }), { cookieAuth: [] }, { userToken: [] }),
+ *   async (c) => { ... }
+ * )
+ */
+export declare const withSecurity: <T extends RouteConfig>(route: T, ...schemes: Array<Record<string, string[]>>) => T;
+/**
+ * Drop-in replacement for `createRoute` from `@hono/zod-openapi`.
+ *
+ * Automatically registers unnamed request body and response schemas as named
+ * OpenAPI components so they appear in `components/schemas` instead of being
+ * inlined at every use site. Generated names follow the convention:
+ *
+ *   {Method}{PathSegments}Body         — request body
+ *   {Method}{PathSegments}{StatusCode} — response body
+ *
+ * Schemas already named via `.openapi("Name")` are never overwritten.
+ */
+export declare const createRoute: <T extends RouteConfig>(config: T) => T;

package/dist/lib/createRoute.js

@@ -0,0 +1,147 @@
+import { createRoute as _createRoute } from "@hono/zod-openapi";
+import { getRefId, zodToOpenAPIRegistry } from "@asteasolutions/zod-to-openapi";
+const STATUS_SUFFIX = {
+    "200": "Response",
+    "201": "Response",
+    "204": "Response",
+    "400": "BadRequestError",
+    "401": "UnauthorizedError",
+    "403": "ForbiddenError",
+    "404": "NotFoundError",
+    "409": "ConflictError",
+    "422": "ValidationError",
+    "429": "RateLimitError",
+    "500": "InternalError",
+    "501": "NotImplementedError",
+    "503": "UnavailableError",
+};
+const METHOD_VERB = {
+    get: "Get",
+    post: "Create",
+    put: "Replace",
+    patch: "Update",
+    delete: "Delete",
+};
+/**
+ * Converts a route method + path into a PascalCase base name for auto-generated schema names.
+ * Examples:
+ *   POST /ledger-items       → CreateLedgerItems
+ *   GET  /ledger-items/{id}  → GetLedgerItemsById
+ *   DELETE /auth/sessions/{sessionId} → DeleteAuthSessionsBySessionId
+ */
+function toBaseName(method, path) {
+    const m = METHOD_VERB[method.toLowerCase()] ?? (method.charAt(0).toUpperCase() + method.slice(1).toLowerCase());
+    const segments = path
+        .split("/")
+        .filter(Boolean)
+        .map((seg) => {
+        if (seg.startsWith("{") && seg.endsWith("}")) {
+            const param = seg.slice(1, -1);
+            return "By" + param.charAt(0).toUpperCase() + param.slice(1);
+        }
+        // kebab-case and plain segments → PascalCase
+        return seg.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+    });
+    return m + segments.join("");
+}
+function maybeRegister(schema, name) {
+    if (!schema || typeof schema !== "object" || !("_def" in schema))
+        return;
+    if (getRefId(schema))
+        return; // already named via .openapi()
+    // Write directly to the registry instead of calling schema.openapi(name) — the
+    // .openapi() method requires extendZodWithOpenApi() to have been called on the
+    // same zod instance that created the schema, which isn't guaranteed in tenant apps.
+    zodToOpenAPIRegistry.add(schema, { _internal: { refId: name } });
+}
+/**
+ * Registers a Zod schema as a named entry in `components/schemas`.
+ *
+ * Use this for shared schemas (e.g. shared error types, reusable response shapes)
+ * that aren't directly attached to a specific route. Schemas already registered
+ * under the same name are silently skipped.
+ *
+ * @example
+ * export const MySchema = registerSchema("MySchema", z.object({ id: z.string() }));
+ */
+export const registerSchema = (name, schema) => {
+    if (!getRefId(schema)) {
+        zodToOpenAPIRegistry.add(schema, { _internal: { refId: name } });
+    }
+    return schema;
+};
+/**
+ * Registers multiple Zod schemas at once as named entries in `components/schemas`.
+ * Object keys become the schema names. Returns the same object so you can
+ * destructure or re-export the schemas normally.
+ *
+ * Schemas already registered (e.g. via a prior `registerSchema` call) are skipped.
+ *
+ * @example
+ * export const { LedgerItem, Product } = registerSchemas({
+ *   LedgerItem: z.object({ id: z.string(), amount: z.number() }),
+ *   Product:    z.object({ id: z.string(), price: z.number() }),
+ * });
+ */
+export const registerSchemas = (schemas) => {
+    for (const [name, schema] of Object.entries(schemas)) {
+        if (!getRefId(schema)) {
+            zodToOpenAPIRegistry.add(schema, { _internal: { refId: name } });
+        }
+    }
+    return schemas;
+};
+/**
+ * Auto-registers a module export as a named OpenAPI schema.
+ * Used internally by modelSchemas auto-discovery in createApp.
+ * Strips a trailing "Schema" suffix from the export name.
+ * Skips non-Zod values and already-registered schemas.
+ */
+export function maybeAutoRegister(exportName, value) {
+    if (!value || typeof value !== "object" || !("_def" in value))
+        return;
+    if (getRefId(value))
+        return;
+    const name = exportName.endsWith("Schema")
+        ? exportName.slice(0, -"Schema".length)
+        : exportName;
+    zodToOpenAPIRegistry.add(value, { _internal: { refId: name } });
+}
+/**
+ * Adds an OpenAPI `security` requirement to a route without affecting TypeScript
+ * type inference on the handler. Pass each security scheme as a separate object.
+ *
+ * Use this instead of inlining `security` in `createRoute(...)` — inlining a
+ * field typed as `{ [name: string]: string[] }` breaks `c.req.valid()` inference.
+ *
+ * @example
+ * router.openapi(
+ *   withSecurity(createRoute({ method: "get", path: "/me", ... }), { cookieAuth: [] }, { userToken: [] }),
+ *   async (c) => { ... }
+ * )
+ */
+export const withSecurity = (route, ...schemes) => Object.assign(route, { security: schemes });
+/**
+ * Drop-in replacement for `createRoute` from `@hono/zod-openapi`.
+ *
+ * Automatically registers unnamed request body and response schemas as named
+ * OpenAPI components so they appear in `components/schemas` instead of being
+ * inlined at every use site. Generated names follow the convention:
+ *
+ *   {Method}{PathSegments}Body         — request body
+ *   {Method}{PathSegments}{StatusCode} — response body
+ *
+ * Schemas already named via `.openapi("Name")` are never overwritten.
+ */
+export const createRoute = (config) => {
+    const base = toBaseName(config.method, config.path);
+    // Auto-name the JSON request body schema if present and unnamed
+    const bodySchema = config.request?.body?.content?.["application/json"]?.schema;
+    maybeRegister(bodySchema, `${base}Request`);
+    // Auto-name each JSON response schema if present and unnamed
+    for (const [status, response] of Object.entries(config.responses ?? {})) {
+        const resSchema = response?.content?.["application/json"]?.schema;
+        maybeRegister(resSchema, `${base}${STATUS_SUFFIX[status] ?? status}`);
+    }
+    return _createRoute(config);
+};

package/dist/lib/emailVerification.js

@@ -1,18 +1,19 @@
 import { getRedis } from "./redis";
-import { appConnection } from "./mongo";
+import { appConnection, mongoose } from "./mongo";
 import { getAppName, getTokenExpiry } from "./appConfig";
-import { Schema } from "mongoose";
 import { sqliteCreateVerificationToken, sqliteGetVerificationToken, sqliteDeleteVerificationToken, } from "../adapters/sqliteAuth";
 import { memoryCreateVerificationToken, memoryGetVerificationToken, memoryDeleteVerificationToken, } from "../adapters/memoryAuth";
-const verificationSchema = 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: "email_verifications" });
 function getVerificationModel() {
-    return appConnection.models["EmailVerification"] ??
-        appConnection.model("EmailVerification", verificationSchema);
+    if (appConnection.models["EmailVerification"])
+        return appConnection.models["EmailVerification"];
+    const { Schema } = mongoose;
+    const verificationSchema = 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: "email_verifications" });
+    return appConnection.model("EmailVerification", verificationSchema);
 }
 let _store = "redis";
 export const setEmailVerificationStore = (store) => { _store = store; };

package/dist/lib/mongo.d.ts

@@ -1,15 +1,20 @@
-import mongoose from "mongoose";
+import type { Connection, Mongoose } from "mongoose";
+type MongooseModule = Mongoose;
 /**
  * Named connection used exclusively for auth data (AuthUser model).
  * Connected via connectAuthMongo() or connectMongo() (backward compat).
  */
-export declare const authConnection: mongoose.Connection;
+export declare const authConnection: Connection;
 /**
  * Named connection for app/tenant data.
  * Connected via connectAppMongo() or connectMongo() (backward compat).
  * Use this when registering your own models: appConnection.model("Product", schema).
  */
-export declare const appConnection: mongoose.Connection;
+export declare const appConnection: Connection;
+/**
+ * The mongoose instance. Available after connectMongo() / connectAuthMongo() is called.
+ */
+export declare const mongoose: MongooseModule;
 /**
  * Connect the auth connection to its dedicated MongoDB server.
  * Uses MONGO_AUTH_USER_*, MONGO_AUTH_PW_*, MONGO_AUTH_HOST_*, MONGO_AUTH_DB_* env vars.
@@ -31,4 +36,4 @@ export declare const connectMongo: () => Promise<void>;
  * Useful for one-off scripts that need a clean exit.
  */
 export declare const disconnectMongo: () => Promise<void>;
-export { mongoose };
+export {};

package/dist/lib/mongo.js

@@ -1,32 +1,74 @@
-import mongoose from "mongoose";
 import { log } from "./logger";
 const isProd = process.env.NODE_ENV === "production";
+function requireMongoose() {
+    try {
+        // Bun supports require() in ESM; this defers the import to call time
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require("mongoose");
+        return mod.default ?? mod;
+    }
+    catch {
+        throw new Error("mongoose is not installed. Run: bun add mongoose");
+    }
+}
 function buildUri(user, password, host, db) {
     const [hostPart, queryPart] = host.split("?");
     return `mongodb+srv://${user}:${password}@${hostPart.replace(/\/$/, "")}/${db}${queryPart ? `?${queryPart}` : ""}`;
 }
+// Internal mutable references — set inside connect functions
+let _authConn = null;
+let _appConn = null;
+let _mongoose = null;
+function makeConnectionProxy(label, getConn, setConn) {
+    return new Proxy({}, {
+        get(_, prop) {
+            let conn = getConn();
+            if (!conn) {
+                // Lazily create a disconnected connection so appConnection.model() works at module
+                // load time. Mongoose buffers queries until openUri() is called by connectMongo().
+                conn = requireMongoose().createConnection();
+                setConn(conn);
+            }
+            const val = conn[prop];
+            return typeof val === "function" ? val.bind(conn) : val;
+        },
+    });
+}
 /**
  * Named connection used exclusively for auth data (AuthUser model).
  * Connected via connectAuthMongo() or connectMongo() (backward compat).
  */
-export const authConnection = mongoose.createConnection();
+export const authConnection = makeConnectionProxy("auth", () => _authConn, (c) => { _authConn = c; });
 /**
  * Named connection for app/tenant data.
  * Connected via connectAppMongo() or connectMongo() (backward compat).
  * Use this when registering your own models: appConnection.model("Product", schema).
  */
-export const appConnection = mongoose.createConnection();
+export const appConnection = makeConnectionProxy("app", () => _appConn, (c) => { _appConn = c; });
+/**
+ * The mongoose instance. Available after connectMongo() / connectAuthMongo() is called.
+ */
+export const mongoose = new Proxy({}, {
+    get(_, prop) {
+        const mg = _mongoose ?? requireMongoose();
+        return mg[prop];
+    },
+});
 /**
  * Connect the auth connection to its dedicated MongoDB server.
  * Uses MONGO_AUTH_USER_*, MONGO_AUTH_PW_*, MONGO_AUTH_HOST_*, MONGO_AUTH_DB_* env vars.
  */
 export const connectAuthMongo = async () => {
+    const mg = requireMongoose();
+    _mongoose = mg;
+    if (!_authConn)
+        _authConn = mg.createConnection();
     const user = isProd ? process.env.MONGO_AUTH_USER_PROD : process.env.MONGO_AUTH_USER_DEV;
     const password = isProd ? process.env.MONGO_AUTH_PW_PROD : process.env.MONGO_AUTH_PW_DEV;
     const host = isProd ? process.env.MONGO_AUTH_HOST_PROD : process.env.MONGO_AUTH_HOST_DEV;
     const db = isProd ? process.env.MONGO_AUTH_DB_PROD : process.env.MONGO_AUTH_DB_DEV;
     const uri = buildUri(user, password, host, db);
-    await authConnection.openUri(uri);
+    await _authConn.openUri(uri);
     log(`[mongo] auth connected to ${host} as ${user}`);
 };
 /**
@@ -34,12 +76,16 @@ export const connectAuthMongo = async () => {
  * Uses MONGO_USER_*, MONGO_PW_*, MONGO_HOST_*, MONGO_DB_* env vars.
  */
 export const connectAppMongo = async () => {
+    const mg = requireMongoose();
+    _mongoose = mg;
+    if (!_appConn)
+        _appConn = mg.createConnection();
     const user = isProd ? process.env.MONGO_USER_PROD : process.env.MONGO_USER_DEV;
     const password = isProd ? process.env.MONGO_PW_PROD : process.env.MONGO_PW_DEV;
     const host = isProd ? process.env.MONGO_HOST_PROD : process.env.MONGO_HOST_DEV;
     const db = isProd ? process.env.MONGO_DB_PROD : process.env.MONGO_DB_DEV;
     const uri = buildUri(user, password, host, db);
-    await appConnection.openUri(uri);
+    await _appConn.openUri(uri);
     log(`[mongo] app connected to ${host} as ${user}`);
 };
 /**
@@ -48,14 +94,20 @@ export const connectAppMongo = async () => {
  * Uses MONGO_USER_*, MONGO_PW_*, MONGO_HOST_*, MONGO_DB_* env vars.
  */
 export const connectMongo = async () => {
+    const mg = requireMongoose();
+    _mongoose = mg;
+    if (!_authConn)
+        _authConn = mg.createConnection();
+    if (!_appConn)
+        _appConn = mg.createConnection();
     const user = isProd ? process.env.MONGO_USER_PROD : process.env.MONGO_USER_DEV;
     const password = isProd ? process.env.MONGO_PW_PROD : process.env.MONGO_PW_DEV;
     const host = isProd ? process.env.MONGO_HOST_PROD : process.env.MONGO_HOST_DEV;
     const db = isProd ? process.env.MONGO_DB_PROD : process.env.MONGO_DB_DEV;
     const uri = buildUri(user, password, host, db);
     await Promise.all([
-        authConnection.openUri(uri),
-        appConnection.openUri(uri),
+        _authConn.openUri(uri),
+        _appConn.openUri(uri),
     ]);
     log(`[mongo] connected to ${host} as ${user}`);
 };
@@ -65,9 +117,8 @@ export const connectMongo = async () => {
  */
 export const disconnectMongo = async () => {
     await Promise.all([
-        authConnection.readyState !== 0 ? authConnection.close() : Promise.resolve(),
-        appConnection.readyState !== 0 ? appConnection.close() : Promise.resolve(),
+        _authConn && _authConn.readyState !== 0 ? _authConn.close() : Promise.resolve(),
+        _appConn && _appConn.readyState !== 0 ? _appConn.close() : Promise.resolve(),
     ]);
     log("[mongo] disconnected");
 };
-export { mongoose };

package/dist/lib/oauth.js

@@ -1,8 +1,7 @@
 import { Google, Apple, generateState, generateCodeVerifier } from "arctic";
 import { getRedis } from "./redis";
-import { appConnection } from "./mongo";
+import { appConnection, mongoose } from "./mongo";
 import { getAppName } from "./appConfig";
-import { Schema } from "mongoose";
 import { sqliteStoreOAuthState, sqliteConsumeOAuthState } from "../adapters/sqliteAuth";
 import { memoryStoreOAuthState, memoryConsumeOAuthState } from "../adapters/memoryAuth";
 let _providers = {};
@@ -29,15 +28,17 @@ export const getApple = () => {
 export const getConfiguredOAuthProviders = () => Object.entries(_providers)
     .filter(([, v]) => v != null)
     .map(([k]) => k);
-const oauthStateSchema = new Schema({
-    state: { type: String, required: true, unique: true },
-    codeVerifier: { type: String },
-    linkUserId: { type: String },
-    expiresAt: { type: Date, required: true, index: { expireAfterSeconds: 0 } },
-}, { collection: "oauth_states" });
 function getOAuthStateModel() {
-    return appConnection.models["OAuthState"] ??
-        appConnection.model("OAuthState", oauthStateSchema);
+    if (appConnection.models["OAuthState"])
+        return appConnection.models["OAuthState"];
+    const { Schema } = mongoose;
+    const oauthStateSchema = new Schema({
+        state: { type: String, required: true, unique: true },
+        codeVerifier: { type: String },
+        linkUserId: { type: String },
+        expiresAt: { type: Date, required: true, index: { expireAfterSeconds: 0 } },
+    }, { collection: "oauth_states" });
+    return appConnection.model("OAuthState", oauthStateSchema);
 }
 let _oauthStore = "redis";
 export const setOAuthStateStore = (store) => { _oauthStore = store; };

package/dist/lib/queue.d.ts

@@ -1,5 +1,4 @@
-import { Queue, Worker } from "bullmq";
-import type { Processor, QueueOptions, WorkerOptions, Job } from "bullmq";
-export declare const createQueue: <T = unknown, R = unknown>(name: string, options?: Omit<QueueOptions, "connection">) => Queue<T, R>;
-export declare const createWorker: <T = unknown, R = unknown>(name: string, processor: Processor<T, R>, options?: Omit<WorkerOptions, "connection">) => Worker<T, R>;
+import type { Queue as QueueType, Worker as WorkerType, Processor, QueueOptions, WorkerOptions, Job } from "bullmq";
+export declare const createQueue: <T = unknown, R = unknown>(name: string, options?: Omit<QueueOptions, "connection">) => QueueType<T, R>;
+export declare const createWorker: <T = unknown, R = unknown>(name: string, processor: Processor<T, R>, options?: Omit<WorkerOptions, "connection">) => WorkerType<T, R>;
 export type { Job };

package/dist/lib/queue.js

@@ -1,4 +1,19 @@
-import { Queue, Worker } from "bullmq";
 import { getRedisConnectionOptions } from "./redis";
-export const createQueue = (name, options) => new Queue(name, { connection: getRedisConnectionOptions(), ...options });
-export const createWorker = (name, processor, options) => new Worker(name, processor, { connection: getRedisConnectionOptions(), ...options });
+function requireBullMQ() {
+    try {
+        // Bun supports require() in ESM; this defers the import to call time
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require("bullmq");
+    }
+    catch {
+        throw new Error("bullmq is not installed. Run: bun add bullmq");
+    }
+}
+export const createQueue = (name, options) => {
+    const { Queue } = requireBullMQ();
+    return new Queue(name, { connection: getRedisConnectionOptions(), ...options });
+};
+export const createWorker = (name, processor, options) => {
+    const { Worker } = requireBullMQ();
+    return new Worker(name, processor, { connection: getRedisConnectionOptions(), ...options });
+};

package/dist/lib/redis.d.ts

@@ -1,14 +1,9 @@
-import Redis from "ioredis";
-export declare const getRedisConnectionOptions: () => {
-    password?: string | undefined;
-    username?: string | undefined;
-    host: string;
-    port: number;
-};
+import type { default as RedisClass, RedisOptions } from "ioredis";
+export declare const getRedisConnectionOptions: () => RedisOptions;
 export declare const connectRedis: () => Promise<void>;
 /**
  * Gracefully close the Redis connection.
  * Useful for one-off scripts that need a clean exit.
  */
 export declare const disconnectRedis: () => Promise<void>;
-export declare const getRedis: () => Redis;
+export declare const getRedis: () => RedisClass;

package/dist/lib/redis.js

@@ -1,6 +1,16 @@
-import Redis from "ioredis";
 import { log } from "./logger";
 const isProd = process.env.NODE_ENV === "production";
+function requireIoredis() {
+    try {
+        // Bun supports require() in ESM; this defers the import to call time
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require("ioredis");
+        return mod.default ?? mod;
+    }
+    catch {
+        throw new Error("ioredis is not installed. Run: bun add ioredis");
+    }
+}
 export const getRedisConnectionOptions = () => {
     const host_port = isProd ? process.env.REDIS_HOST_PROD : process.env.REDIS_HOST_DEV;
     if (!host_port)
@@ -18,17 +28,18 @@ export const getRedisConnectionOptions = () => {
     };
 };
 let client = null;
-const createClient = () => {
-    const redis = new Redis(getRedisConnectionOptions());
-    redis.on("error", (err) => log(`[redis] error: ${err.message}`));
-    return redis;
-};
 export const connectRedis = () => {
     if (client)
         return Promise.resolve();
-    client = createClient();
+    const Redis = requireIoredis();
+    client = new Redis(getRedisConnectionOptions());
+    client.on("error", (err) => log(`[redis] error: ${err.message}`));
     return new Promise((resolve, reject) => {
-        client.once("ready", () => { log(`[redis] connected to ${getRedisConnectionOptions().host}:${getRedisConnectionOptions().port} as ${getRedisConnectionOptions().username || "default user"}`); resolve(); });
+        client.once("ready", () => {
+            const opts = getRedisConnectionOptions();
+            log(`[redis] connected to ${opts.host}:${opts.port} as ${opts.username || "default user"}`);
+            resolve();
+        });
         client.once("error", reject);
     });
 };