@kollors/deep-json-server 0.4.0 → 0.6.0

package/src/cli.js

@@ -1,78 +1,91 @@
 import process from 'node:process';
+import { readServerConfig } from './config.js';
 import { DEFAULT_HOST, DEFAULT_PORT } from './constants.js';
-import { generateOpenApi } from './openapi/index.js';
-import { startServer } from './server.js';
+import { createServer } from './server.js';
 
 const HELP_TEXT = `Deep JSON Server
 
 Использование:
-  deep-json-server <database.json> [--schema <database-schema.json>] [--host <host>] [--port <port>]
-  deep-json-server <database.json> --generate <database-schema.json> <openapi-schema.yaml> [--host <host>] [--port <port>]
+  deep-json-server [--files] [--openapi | --openapi-only] <server.config.js>
 
 Параметры:
-  --generate  Сгенерировать OpenAPI и завершить работу
-  --host, -h  Адрес сервера (по умолчанию 127.0.0.1)
-  --port, -p  Порт сервера (по умолчанию 4001)
-  --schema    Проверять запросы записи по указанной схеме
-  --help      Показать справку`;
-
-const parseOptions = (args, allowedOptions) => {
-  const options = {};
-
-  for (let index = 0; index < args.length; index += 2) {
-    const option = args[index];
-    const value = args[index + 1];
-
-    if (!allowedOptions.includes(option)) {
-      throw new Error(`Неизвестный параметр: ${option}`);
+  --files         Добавить файловые маршруты в сервер и OpenAPI
+  --openapi       Сгенерировать OpenAPI и запустить сервер
+  --openapi-only  Сгенерировать OpenAPI и завершить работу
+  --help          Показать справку`;
+
+const parseArguments = (args) => {
+  const options = { files: false, openapiMode: 'none' };
+  let configPath;
+
+  args.forEach((argument) => {
+    if (argument === '--files') {
+      options.files = true;
+    } else if (argument === '--openapi') {
+      if (options.openapiMode !== 'none') {
+        throw new Error('Параметры --openapi и --openapi-only нельзя использовать одновременно');
+      }
+
+      options.openapiMode = 'generate';
+    } else if (argument === '--openapi-only') {
+      if (options.openapiMode !== 'none') {
+        throw new Error('Параметры --openapi и --openapi-only нельзя использовать одновременно');
+      }
+
+      options.openapiMode = 'only';
+    } else if (argument.startsWith('-')) {
+      throw new Error(`Неизвестный параметр: ${argument}`);
+    } else if (configPath == null) {
+      configPath = argument;
+    } else {
+      throw new Error('Можно указать только один файл конфигурации');
     }
+  });
 
-    if (value == null || value.startsWith('-')) {
-      throw new Error(`Не указано значение параметра ${option}`);
-    }
+  if (configPath == null) {
+    throw new Error('Укажите путь к файлу конфигурации');
+  }
 
-    const optionName = ['--host', '-h'].includes(option) ? 'host' : ['--port', '-p'].includes(option) ? 'port' : 'schemaPath';
+  return { configPath, ...options };
+};
 
-    options[optionName] = value;
+const validateModeConfig = (config, { files, openapiMode }) => {
+  if (openapiMode !== 'none' && config.openapi.path == null) {
+    throw new Error(`Для --openapi${openapiMode === 'only' ? '-only' : ''} укажите ключ config.openapi.path`);
   }
 
-  return options;
+  if (files && config.files == null) {
+    throw new Error('Для --files укажите секцию config.files');
+  }
 };
 
-export async function runCli(args = process.argv.slice(2)) {
+export async function runCli(args = process.argv.slice(2), services = { createServer }) {
   if (args.includes('--help')) {
     process.stdout.write(`${HELP_TEXT}\n`);
     return;
   }
 
-  const [databasePath] = args;
-
-  if (databasePath == null || databasePath.startsWith('-')) {
-    throw new Error('Укажите путь к JSON-базе данных');
-  }
-
-  const generateIndex = args.indexOf('--generate');
+  const { configPath, files, openapiMode } = parseArguments(args);
+  const config = await readServerConfig(configPath);
+  const host = config.server.host ?? process.env.HOST ?? DEFAULT_HOST;
+  const port = config.server.port ?? Number(process.env.PORT ?? DEFAULT_PORT);
 
-  if (generateIndex !== -1) {
-    const schemaPath = args[generateIndex + 1];
-    const outputPath = args[generateIndex + 2];
+  validateModeConfig(config, { files, openapiMode });
 
-    if (generateIndex !== 1 || schemaPath == null || outputPath == null) {
-      throw new Error('Используйте: deep-json-server <database.json> --generate <database-schema.json> <openapi-schema.yaml> [--host <host>] [--port <port>]');
-    }
+  const runtimeConfig = { ...config, server: { ...config.server, host, port } };
+  const server = await services.createServer(runtimeConfig, { files });
 
-    const options = parseOptions(args.slice(4), ['--host', '-h', '--port', '-p']);
-    const host = options.host ?? process.env.HOST ?? DEFAULT_HOST;
-    const port = Number(options.port ?? process.env.PORT ?? DEFAULT_PORT);
+  if (openapiMode !== 'none') {
+    await server.openapi();
+    process.stdout.write(`OpenAPI-схема сохранена в ${config.openapi.path}\n`);
+  }
 
-    await generateOpenApi({ databasePath, host, outputPath, port, schemaPath });
-    process.stdout.write(`OpenAPI-схема сохранена в ${outputPath}\n`);
+  if (openapiMode === 'only') {
     return;
   }
 
-  const options = parseOptions(args.slice(1), ['--host', '-h', '--port', '-p', '--schema']);
-  const host = options.host ?? process.env.HOST ?? DEFAULT_HOST;
-  const port = Number(options.port ?? process.env.PORT ?? DEFAULT_PORT);
+  const fastify = server.fastify();
 
-  await startServer({ databasePath, host, port, schemaPath: options.schemaPath });
+  await fastify.listen({ host, port });
+  fastify.log.info({ database: 'path' in config.database ? config.database.path : 'memory' }, 'Deep JSON Server запущен');
 }

package/src/config.js

@@ -0,0 +1,194 @@
+import { dirname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isObject } from './utils.js';
+
+const CONFIG_KEYS = new Set(['database', 'files', 'openapi', 'server']);
+const DATABASE_KEYS = new Set(['data', 'path', 'schema']);
+const FILES_KEYS = new Set(['data', 'directory', 'metadata']);
+const OPENAPI_KEYS = new Set(['path']);
+const SERVER_KEYS = new Set(['host', 'logger', 'maxFileSize', 'maxPageSize', 'port']);
+let configImportIndex = 0;
+
+/** @typedef {Record<string, Array<Record<string, unknown>>>} DatabaseData */
+/** @typedef {Record<string, unknown>} DatabaseSchema */
+/** @typedef {{ data: DatabaseData, path?: never, schema?: DatabaseSchema | string } | { data?: never, path: string, schema?: DatabaseSchema | string }} DatabaseConfig */
+/** @typedef {{ content: Uint8Array, id: string, mimeType: string, name: string }} MemoryFile */
+/** @typedef {{ data: MemoryFile[], directory?: never, metadata?: never } | { data?: never, directory: string, metadata: string }} FilesConfig */
+/**
+ * @typedef {object} DeepJsonServerConfig
+ * @property {DatabaseConfig} database Database source and optional schema.
+ * @property {FilesConfig} [files] Binary-file storage.
+ * @property {{ path?: string }} [openapi] Generated OpenAPI file.
+ * @property {{ host?: string, logger?: boolean | Record<string, unknown>, maxFileSize?: number, maxPageSize?: number, port?: number }} [server] Runtime settings.
+ */
+
+const assertKnownKeys = (value, keys, path) => {
+  const unknownKey = Object.keys(value).find((key) => !keys.has(key));
+
+  if (unknownKey != null) {
+    throw new Error(`Неизвестный ключ ${path}.${unknownKey}`);
+  }
+};
+
+const getObject = (value, path, required = false) => {
+  if (value == null && !required) {
+    return undefined;
+  }
+
+  if (!isObject(value)) {
+    throw new Error(`Ключ ${path} должен быть JSON-объектом`);
+  }
+
+  return value;
+};
+
+const getString = (value, path, required = false) => {
+  if (value == null && !required) {
+    return undefined;
+  }
+
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`Ключ ${path} должен содержать непустую строку`);
+  }
+
+  return value;
+};
+
+const resolveConfigPath = (value, directoryPath) => (value == null ? undefined : resolve(directoryPath, value));
+
+const normalizeSchema = (schema, directoryPath) => {
+  if (schema == null) {
+    return undefined;
+  }
+
+  if (typeof schema === 'string') {
+    return resolveConfigPath(getString(schema, 'config.database.schema', true), directoryPath);
+  }
+
+  return getObject(schema, 'config.database.schema', true);
+};
+
+const normalizeDatabase = (value, directoryPath) => {
+  const database = getObject(value, 'config.database', true);
+
+  assertKnownKeys(database, DATABASE_KEYS, 'config.database');
+
+  const hasData = database.data != null;
+  const hasPath = database.path != null;
+
+  if (hasData === hasPath) {
+    throw new Error('Укажите ровно один из ключей config.database.path и config.database.data');
+  }
+
+  const schema = normalizeSchema(database.schema, directoryPath);
+
+  if (hasData) {
+    return { data: getObject(database.data, 'config.database.data', true), schema };
+  }
+
+  return { path: resolveConfigPath(getString(database.path, 'config.database.path', true), directoryPath), schema };
+};
+
+const normalizeFiles = (value, directoryPath) => {
+  const files = getObject(value, 'config.files');
+
+  if (files == null) {
+    return undefined;
+  }
+
+  assertKnownKeys(files, FILES_KEYS, 'config.files');
+
+  const hasData = files.data != null;
+  const hasDiskStorage = files.directory != null || files.metadata != null;
+
+  if (hasData === hasDiskStorage) {
+    throw new Error('Укажите либо config.files.data, либо пару config.files.directory и config.files.metadata');
+  }
+
+  if (hasData) {
+    if (!Array.isArray(files.data)) {
+      throw new Error('Ключ config.files.data должен содержать массив');
+    }
+
+    return { data: files.data };
+  }
+
+  return {
+    directory: resolveConfigPath(getString(files.directory, 'config.files.directory', true), directoryPath),
+    metadata: resolveConfigPath(getString(files.metadata, 'config.files.metadata', true), directoryPath),
+  };
+};
+
+/**
+ * @param {DeepJsonServerConfig} config Server configuration.
+ * @param {string} [directoryPath] Base directory for relative paths.
+ * @returns {{ database: DatabaseConfig, files?: FilesConfig, openapi: { path?: string }, server: { host?: string, logger?: boolean | Record<string, unknown>, maxFileSize?: number, maxPageSize?: number, port?: number } }} Normalized configuration.
+ */
+export const normalizeServerConfig = (config, directoryPath = '.') => {
+  if (!isObject(config)) {
+    throw new Error('Конфигурация сервера должна содержать JSON-объект');
+  }
+
+  assertKnownKeys(config, CONFIG_KEYS, 'config');
+
+  const database = normalizeDatabase(config.database, directoryPath);
+  const files = normalizeFiles(config.files, directoryPath);
+  const openapi = getObject(config.openapi, 'config.openapi') ?? {};
+  const server = getObject(config.server, 'config.server') ?? {};
+
+  assertKnownKeys(openapi, OPENAPI_KEYS, 'config.openapi');
+  assertKnownKeys(server, SERVER_KEYS, 'config.server');
+
+  const openapiPath = getString(openapi.path, 'config.openapi.path');
+  const host = getString(server.host, 'config.server.host');
+
+  if (server.port != null && (!Number.isInteger(server.port) || server.port < 0 || server.port > 65_535)) {
+    throw new Error('Ключ config.server.port должен быть целым числом от 0 до 65535');
+  }
+
+  if (server.maxPageSize != null && (!Number.isInteger(server.maxPageSize) || server.maxPageSize < 1)) {
+    throw new Error('Ключ config.server.maxPageSize должен быть положительным целым числом');
+  }
+
+  if (server.maxFileSize != null && (!Number.isInteger(server.maxFileSize) || server.maxFileSize < 1)) {
+    throw new Error('Ключ config.server.maxFileSize должен быть положительным целым числом');
+  }
+
+  if (server.logger != null && typeof server.logger !== 'boolean' && !isObject(server.logger)) {
+    throw new Error('Ключ config.server.logger должен содержать boolean или JSON-объект');
+  }
+
+  return {
+    database,
+    files,
+    openapi: { path: resolveConfigPath(openapiPath, directoryPath) },
+    server: {
+      host,
+      logger: server.logger,
+      maxFileSize: server.maxFileSize,
+      maxPageSize: server.maxPageSize,
+      port: server.port,
+    },
+  };
+};
+
+/** @param {string} configPath Configuration module path. */
+export async function readServerConfig(configPath) {
+  const resolvedConfigPath = resolve(getString(configPath, 'config', true));
+  let config;
+
+  try {
+    const configUrl = pathToFileURL(resolvedConfigPath);
+
+    configUrl.searchParams.set('deep-json-server-import', String(configImportIndex++));
+    config = (await import(configUrl.href)).default;
+  } catch (error) {
+    throw new Error(`Не удалось загрузить конфигурацию ${resolvedConfigPath}: ${error.message}`, { cause: error });
+  }
+
+  if (!isObject(config)) {
+    throw new Error('Конфигурация сервера должна экспортировать JSON-объект через export default');
+  }
+
+  return normalizeServerConfig(config, dirname(resolvedConfigPath));
+}

package/src/constants.js

@@ -1,4 +1,5 @@
 export const DEFAULT_HOST = '127.0.0.1';
+export const DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024;
 export const DEFAULT_PAGE_SIZE = 10;
 export const DEFAULT_PORT = 4001;
 export const MAX_PAGE_SIZE = 1000;

package/src/database.js

@@ -72,8 +72,7 @@ export const readJsonObject = async (path, label) => {
 
 export const readDatabaseFile = async (databasePath) => validateDatabase(await readJsonObject(databasePath, 'Файл базы данных'));
 
-/** @returns {Promise<any>} Internal LowDB-backed store. */
-export const createDatabaseStore = async (databasePath) => {
+const createDiskDatabaseStore = async (databasePath) => {
   const resolvedDatabasePath = resolveDatabasePath(databasePath);
   const initialData = await readDatabaseFile(resolvedDatabasePath);
   const database = await JSONFilePreset(resolvedDatabasePath, initialData);
@@ -105,6 +104,36 @@ export const createDatabaseStore = async (databasePath) => {
   return { database, path: resolvedDatabasePath, read, update };
 };
 
+const createMemoryDatabaseStore = (sourceData) => {
+  const database = { data: validateDatabase(structuredClone(sourceData)) };
+  let updateQueue = Promise.resolve();
+
+  const read = async () => database.data;
+  const update = (operation) => {
+    const pendingOperation = updateQueue.then(() => {
+      const draft = { data: structuredClone(database.data) };
+      const result = operation(draft);
+
+      validateDatabase(draft.data);
+      database.data = draft.data;
+
+      return result;
+    });
+
+    updateQueue = pendingOperation.catch(() => undefined);
+
+    return pendingOperation;
+  };
+
+  return { database, read, update };
+};
+
+/**
+ * @param {import('./config.js').DatabaseConfig} config Database source.
+ * @returns {Promise<any>} Internal database store.
+ */
+export const createDatabaseStore = async (config) => ('data' in config ? createMemoryDatabaseStore(config.data) : createDiskDatabaseStore(config.path));
+
 export const getCollection = (database, resource) => {
   const collection = isSafeKey(resource) ? database.data[resource] : undefined;