Update module imports

0c8ccf176511a33fb84e1528af57e17027fa733c

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: a0e6030836d18bd17c66d302cbb0af43c453988c

recover.js+11 -6 Viewed

 import fs from 'node:fs';
 import yaml from 'yaml';
 import storage from 'node-persist';
-import * as users from './src/users.js';
+import {
+    initUserStorage,
+    getPasswordSalt,
+    getPasswordHash,
+    toKey,
+} from './src/users.js';
 const userAccount = process.argv[2];
 const userPassword = process.argv[3];

@@ -22,7 +27,7 @@ async function initStorage() {
22	process.exit(1);	27	process.exit(1);
23	}	28	}
24		29
25	await users.initUserStorage(dataRoot);	30	await initUserStorage(dataRoot);
26	}	31	}
27		32
28	async function main() {	33	async function main() {

     /**
      * @type {import('./src/users').User}
      */
-    const user = await storage.get(users.toKey(userAccount));
+    const user = await storage.get(toKey(userAccount));
     if (!user) {
         console.error(`User "${userAccount}" not found.`);

     if (userPassword) {
         console.log('Setting new password...');
-        const salt = users.getPasswordSalt();
+        const salt = getPasswordSalt();
-        const passwordHash = users.getPasswordHash(userPassword, salt);
+        const passwordHash = getPasswordHash(userPassword, salt);
         user.password = passwordHash;
         user.salt = salt;
     } else {

@@ -55,7 +60,7 @@ async function main() {
55	user.salt = '';	60	user.salt = '';
56	}	61	}
57		62
58	await storage.setItem(users.toKey(userAccount), user);	63	await storage.setItem(toKey(userAccount), user);
59	console.log('User recovered. A program will exit now.');	64	console.log('User recovered. A program will exit now.');
60	}	65	}
61		66

server.js+37 -23 Viewed

 util.inspect.defaultOptions.depth = 4;
 // local library imports
-import * as loader from './src/plugin-loader.js';
+import{ loadPlugins } from './src/plugin-loader.js';
-import * as userModule from './src/users.js';
+import {
+    initUserStorage,
+    getCsrfSecret,
+    getCookieSecret,
+    getCookieSessionName,
+    getAllEnabledUsers,
+    ensurePublicDirectoriesExist,
+    getUserDirectoriesList,
+    migrateSystemPrompts,
+    migrateUserData,
+    requireLoginMiddleware,
+    setUserDataMiddleware,
+    shouldRedirectToLogin,
+    tryAutoLogin,
+    router as userDataRouter,
+} from './src/users.js';
 import basicAuthMiddleware from './src/middleware/basicAuth.js';
 import whitelistMiddleware from './src/middleware/whitelist.js';
 import multerMonkeyPatch from './src/middleware/multerMonkeyPatch.js';
 import initRequestProxy from './src/request-proxy.js';
-import * as contentManager from './src/endpoints/content-manager.js';
 import {
     getVersion,
     getConfigValue,

 import { router as statsRouter, init as statsInit, onExit as statsOnExit } from './src/endpoints/stats.js';
 import { router as backgroundsRouter } from './src/endpoints/backgrounds.js';
 import { router as spritesRouter } from './src/endpoints/sprites.js';
-import { router as contentManagerRouter } from './src/endpoints/content-manager.js';
+import { router as contentManagerRouter, checkForNewContent } from './src/endpoints/content-manager.js';
 import { router as settingsRouter, init as settingsInit } from './src/endpoints/settings.js';
 import { router as stableDiffusionRouter } from './src/endpoints/stable-diffusion.js';
 import { router as hordeRouter } from './src/endpoints/horde.js';

+}
 app.use(cookieSession({
-    name: userModule.getCookieSessionName(),
+    name: getCookieSessionName(),
     sameSite: 'strict',
     httpOnly: true,
     maxAge: getSessionCookieAge(),
-    secret: userModule.getCookieSecret(),
+    secret: getCookieSecret(),
 }));
-app.use(userModule.setUserDataMiddleware);
+app.use(setUserDataMiddleware);
 // CSRF Protection //
 if (!disableCsrf) {
-    const COOKIES_SECRET = userModule.getCookieSecret();
+    const COOKIES_SECRET = getCookieSecret();
     const { generateToken, doubleCsrfProtection } = doubleCsrf({
-        getSecret: userModule.getCsrfSecret,
+        getSecret: getCsrfSecret,
         cookieName: 'X-CSRF-Token',
         cookieOptions: {
             httpOnly: true,

 // Static files
 // Host index page
 app.get('/', (request, response) => {
-    if (userModule.shouldRedirectToLogin(request)) {
+    if (shouldRedirectToLogin(request)) {
         const query = request.url.split('?')[1];
         const redirectUrl = query ? `/login?${query}` : '/login';
         return response.redirect(redirectUrl);

+    }
     try {
-        const autoLogin = await userModule.tryAutoLogin(request, basicAuthMode);
+        const autoLogin = await tryAutoLogin(request, basicAuthMode);
         if (autoLogin) {
             return response.redirect('/');

 app.use('/api/users', usersPublicRouter);
 // Everything below this line requires authentication
-app.use(userModule.requireLoginMiddleware);
+app.use(requireLoginMiddleware);
 app.get('/api/ping', (_, response) => response.sendStatus(204));
 // File uploads

 app.use(multerMonkeyPatch);
 // User data mount
-app.use('/', userModule.router);
+app.use('/', userDataRouter);
 // Private endpoints
 app.use('/api/users', usersPrivateRouter);
 // Admin endpoints

+    }
     console.log();
-    const directories = await userModule.getUserDirectoriesList();
+    const directories = await getUserDirectoriesList();
-    await contentManager.checkForNewContent(directories);
+    await checkForNewContent(directories);
     await ensureThumbnailCache();
     cleanUploads();
     await settingsInit();
     await statsInit();
-    const cleanupPlugins = await loadPlugins();
+    const cleanupPlugins = await initializePlugins();
     const consoleTitle = process.title;
     let isExiting = false;

  * Loads server plugins from a directory.
  * @returns {Promise<Function>} Function to be run on server exit
  */
-async function loadPlugins() {
+async function initializePlugins() {
     try {
         const pluginDirectory = path.join(serverDirectory, 'plugins');
-        const cleanupPlugins = await loader.loadPlugins(app, pluginDirectory);
+        const cleanupPlugins = await loadPlugins(app, pluginDirectory);
         return cleanupPlugins;
     } catch {
         console.log('Plugin loading failed.');

         logSecurityAlert('Your SillyTavern is currently insecurely open to the public. Enable whitelisting, basic authentication or user accounts.');
+    }
-    const users = await userModule.getAllEnabledUsers();
+    const users = await getAllEnabledUsers();
     const unprotectedUsers = users.filter(x => !x.password);
     const unprotectedAdminUsers = unprotectedUsers.filter(x => x.admin);

+}
 // User storage module needs to be initialized before starting the server
-userModule.initUserStorage(dataRoot)
+initUserStorage(dataRoot)
-    .then(userModule.ensurePublicDirectoriesExist)
+    .then(ensurePublicDirectoriesExist)
-    .then(userModule.migrateUserData)
+    .then(migrateUserData)
-    .then(userModule.migrateSystemPrompts)
+    .then(migrateSystemPrompts)
     .then(verifySecuritySettings)
     .then(preSetupTasks)
     .finally(startServer);

src/endpoints/characters.js+3 -3 Viewed

 import { jsonParser, urlencodedParser } from '../express-common.js';
 import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer } from '../util.js';
 import { TavernCardValidator } from '../validator/TavernCardValidator.js';
-import * as characterCardParser from '../character-card-parser.js';
+import { parse, write } from '../character-card-parser.js';
 import { readWorldInfoFile } from './worldinfo.js';
 import { invalidateThumbnail } from './thumbnails.js';
 import { importRisuSprites } from './sprites.js';

@@ -38,7 +38,7 @@ async function readCharacterData(inputFile, inputFormat = 'png') {
38	return characterDataCache.get(cacheKey);	38	return characterDataCache.get(cacheKey);
39	}	39	}
40		40
41	const result = characterCardParser.parse(inputFile, inputFormat);	41	const result = parse(inputFile, inputFormat);
42	characterDataCache.set(cacheKey, result);	42	characterDataCache.set(cacheKey, result);
43	return result;	43	return result;
44	}	44	}

         const inputImage = await getInputImage();
         // Get the chunks
-        const outputImage = characterCardParser.write(inputImage, data);
+        const outputImage = write(inputImage, data);
         const outputImagePath = path.join(request.user.directories.characters, `${outputFile}.png`);
         writeFileAtomicSync(outputImagePath, outputImage);

src/endpoints/content-manager.js+4 -3 Viewed

 import express from 'express';
 import fetch from 'node-fetch';
 import sanitize from 'sanitize-filename';
+import { sync as writeFileAtomicSync } from  'write-file-atomic';
 import { getConfigValue, color } from '../util.js';
 import { jsonParser } from '../express-common.js';
-import { sync as writeFileAtomicSync } from  'write-file-atomic';
+import { write } from '../character-card-parser.js';
 const contentDirectory = path.join(process.cwd(), 'default/content');
 const scaffoldDirectory = path.join(process.cwd(), 'default/scaffold');
 const contentIndexPath = path.join(contentDirectory, 'index.json');
 const scaffoldIndexPath = path.join(scaffoldDirectory, 'index.json');
-import * as characterCardParser from '../character-card-parser.js';
 const WHITELIST_GENERIC_URL_DOWNLOAD_SOURCES = getConfigValue('whitelistImportDomains', []);

         const avatarResult = await fetch(avatarUrl);
         const avatarBuffer = await avatarResult.buffer();
-        const cardBuffer = characterCardParser.write(avatarBuffer, JSON.stringify(characterData));
+        const cardBuffer = write(avatarBuffer, JSON.stringify(characterData));
         return {
             buffer: cardBuffer,

src/endpoints/users-private.js+2 -3 Viewed

 import { jsonParser } from '../express-common.js';
 import { getUserAvatar, toKey, getPasswordHash, getPasswordSalt, createBackupArchive, ensurePublicDirectoriesExist, toAvatarKey } from '../users.js';
 import { SETTINGS_FILE } from '../constants.js';
-import * as contentManager from './content-manager.js';
+import { checkForNewContent, CONTENT_TYPES } from './content-manager.js';
 import { color, Cache } from '../util.js';
-import { checkForNewContent } from './content-manager.js';
 const RESET_CACHE = new Cache(5 * 60 * 1000);

         const pathToFile = path.join(request.user.directories.root, SETTINGS_FILE);
         await fsPromises.rm(pathToFile, { force: true });
-        await contentManager.checkForNewContent([request.user.directories], [contentManager.CONTENT_TYPES.SETTINGS]);
+        await checkForNewContent([request.user.directories], [CONTENT_TYPES.SETTINGS]);
         return response.sendStatus(204);
     } catch (error) {