@kikiutils/nitro-session/dist/index.mjs

Easy-to-use nitro session.

import { consola } from 'consola';
import { merge, cloneDeep } from 'lodash-es';
import { defaultOptions, cachedHandlers } from './constants.mjs';
import { DataHandler } from './handlers/data/index.mjs';
import { CookieTokenHandler } from './handlers/token/cookie.mjs';
import { HeaderTokenHandler } from './handlers/token/header.mjs';
import { setupH3EventContextSession } from './utils.mjs';

// eslint-disable-next-line import/no-mutable-exports
let processResponseEvent;
async function createHandlers(options) {
    const dataHandler = await DataHandler.createInstance(options);
    let tokenHandler;
    if (options.storage?.token?.driver === 'cookie') {
        tokenHandler = new CookieTokenHandler(options.storage.token.options, options.maxAge);
    }
    else if (options.storage?.token?.driver === 'header') {
        tokenHandler = new HeaderTokenHandler(options.storage?.token?.options);
    }
    else
        throw new Error('Invalid token storage driver');
    return {
        dataHandler,
        tokenHandler,
    };
}
async function initialization(framework, options) {
    consola.info(`Initializing ${framework} session...`);
    const pluginOptions = merge(cloneDeep(defaultOptions), options);
    if (!pluginOptions.enabled)
        return consola.info(`${framework} session disabled.`);
    consola.info(`${framework} session configured data with '${pluginOptions.storage.data.driver}' driver.`);
    consola.info(`${framework} session configured token with '${pluginOptions.storage.token.driver}' driver.`);
    const handlers = await createHandlers(pluginOptions);
    return {
        handlers,
        pluginOptions,
    };
}
async function nitroSession(nitroApp, options) {
    const initializationResult = await initialization('Nitro', options);
    if (!initializationResult)
        return;
    await registerHooksAndSetupCachedHandlers(nitroApp, initializationResult.pluginOptions, false, initializationResult.handlers);
    consola.success('Nitro session initialization successful.');
}
async function registerHooksAndSetupCachedHandlers(nitroApp, options, onlyApi, handlers) {
    if (!handlers)
        handlers = await createHandlers(options);
    cachedHandlers.data = handlers.dataHandler;
    processResponseEvent = async (event) => {
        if (!event.context._nitroSessionChanged || (onlyApi && !event.path.startsWith('/api')))
            return;
        if (event.context._nitroSessionCleared) {
            const token = handlers.tokenHandler.get(event);
            if (token)
                await handlers.dataHandler.delete(token);
            handlers.tokenHandler.delete(event);
        }
        else {
            const token = await handlers.dataHandler.setAndGetToken(event, event.context.session);
            if (token)
                handlers.tokenHandler.set(event, token);
        }
    };
    nitroApp.hooks.hook('beforeResponse', processResponseEvent);
    // nitroApp.hooks.hook('error', async (_, { event }) => {
    //     event && options.persistSessionOnError && await processResponseEvent(event);
    // });
    nitroApp.hooks.hook('request', async (event) => {
        if (onlyApi && !event.path.startsWith('/api'))
            return;
        const token = handlers.tokenHandler.get(event);
        let sessionData;
        if (token) {
            sessionData = await handlers.dataHandler.get(event, token);
            if (!sessionData) {
                await handlers.dataHandler.delete(token);
                handlers.tokenHandler.delete(event);
            }
        }
        setupH3EventContextSession(event, sessionData || {});
    });
}

export { initialization, nitroSession, processResponseEvent, registerHooksAndSetupCachedHandlers };
//# sourceMappingURL=index.mjs.map