@kollors/deep-json-server 0.7.0 → 0.8.1

package/bin/deep-json-server.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-
-import process from 'node:process';
-import { runCli } from '../src/cli.js';
-
-try {
-  await runCli();
-} catch (error) {
-  process.stderr.write(`${error.message}\n`);
-  process.exitCode = 1;
-}

package/index.js

@@ -1,12 +0,0 @@
-/** @typedef {import('./src/config.js').DeepJsonServerConfig} DeepJsonServerConfig */
-/** @typedef {import('./src/config.js').DatabaseConfig} DatabaseConfig */
-/** @typedef {import('./src/config.js').FilesConfig} FilesConfig */
-/** @typedef {import('./src/config.js').MemoryFile} MemoryFile */
-/** @typedef {import('./src/config.js').OpenapiConfig} OpenapiConfig */
-/** @typedef {import('./src/config.js').ServerConfig} ServerConfig */
-/** @typedef {import('./src/files.js').FileMetadata} FileMetadata */
-/** @typedef {import('./src/files.js').FileUpdate} FileUpdate */
-/** @typedef {import('./src/server.js').OpenapiDocument} OpenapiDocument */
-/** @typedef {import('./src/server.js').ServerFacade} ServerFacade */
-
-export { createServer } from './src/server.js';

package/src/cli.js

@@ -1,91 +0,0 @@
-import process from 'node:process';
-import { readServerConfig } from './config.js';
-import { DEFAULT_HOST, DEFAULT_PORT } from './constants.js';
-import { createServer } from './server.js';
-
-const HELP_TEXT = `Deep JSON Server
-
-Использование:
-  deep-json-server [--files] [--openapi | --openapi-only] <server.config.js>
-
-Параметры:
-  --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 (configPath == null) {
-    throw new Error('Укажите путь к файлу конфигурации');
-  }
-
-  return { configPath, ...options };
-};
-
-const validateModeConfig = (config, { files, openapiMode }) => {
-  if (openapiMode !== 'none' && config.openapi.path == null) {
-    throw new Error(`Для --openapi${openapiMode === 'only' ? '-only' : ''} укажите ключ config.openapi.path`);
-  }
-
-  if (files && config.files == null) {
-    throw new Error('Для --files укажите секцию config.files');
-  }
-};
-
-export async function runCli(args = process.argv.slice(2), services = { createServer }) {
-  if (args.includes('--help')) {
-    process.stdout.write(`${HELP_TEXT}\n`);
-    return;
-  }
-
-  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);
-
-  validateModeConfig(config, { files, openapiMode });
-
-  const runtimeConfig = { ...config, server: { ...config.server, host, port } };
-  const serverFacade = await services.createServer(runtimeConfig, { files });
-
-  if (openapiMode !== 'none') {
-    await serverFacade.openapi();
-    process.stdout.write(`OpenAPI-схема сохранена в ${config.openapi.path}\n`);
-  }
-
-  if (openapiMode === 'only') {
-    return;
-  }
-
-  const fastify = serverFacade.fastify();
-
-  await fastify.listen({ host, port });
-  fastify.log.info({ database: 'path' in config.database ? config.database.path : 'memory' }, 'Deep JSON Server запущен');
-}

package/src/config.js

@@ -1,203 +0,0 @@
-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, directory?: string, mimeType: string, name: string }} MemoryFile */
-/** @typedef {{ data: MemoryFile[], directory?: never, metadata?: never } | { data?: never, directory: string, metadata: string }} FilesConfig */
-/** @typedef {{ path?: string }} OpenapiConfig */
-/** @typedef {{ host?: string, logger?: boolean | Record<string, unknown>, maxFileSize?: number, maxPageSize?: number, port?: number }} ServerConfig */
-/**
- * @typedef {object} DeepJsonServerConfig
- * @property {DatabaseConfig} database Database source and optional schema.
- * @property {FilesConfig} [files] Binary-file storage.
- * @property {OpenapiConfig} [openapi] Generated OpenAPI file.
- * @property {ServerConfig} [server] Runtime settings.
- */
-/** @typedef {{ database: DatabaseConfig, files?: FilesConfig, openapi: OpenapiConfig, server: ServerConfig }} NormalizedServerConfig */
-
-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),
-  };
-};
-
-/**
- * Validates configuration and resolves relative paths.
- * @param {DeepJsonServerConfig} config Server configuration.
- * @param {string} [directoryPath] Base directory for relative paths.
- * @returns {NormalizedServerConfig} 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,
-    },
-  };
-};
-
-/**
- * Loads an ES module config and resolves paths from its directory.
- * @param {string} configPath Configuration module path.
- * @returns {Promise<NormalizedServerConfig>} Normalized configuration.
- */
-export async function readServerConfig(configPath) {
-  const resolvedConfigPath = resolve(getString(configPath, 'config', true));
-  let config;
-
-  try {
-    const configUrl = pathToFileURL(resolvedConfigPath);
-
-    // Bypass the module cache so repeated reads use the latest config.
-    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/database.js

@@ -1,148 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { JSONFilePreset } from 'lowdb/node';
-import { createHttpError, createSerialQueue, createUniqueId, isObject, isSafeKey, resolveDatabasePath } from './utils.js';
-
-/** @typedef {{ data: import('./config.js').DatabaseData }} DatabaseContainer */
-/**
- * @typedef {object} DatabaseStore
- * @property {DatabaseContainer} database Current database container.
- * @property {string} [path] Resolved database file path.
- * @property {() => Promise<import('./config.js').DatabaseData>} read Returns current data and reloads disk-backed sources.
- * @property {<T>(operation: (database: DatabaseContainer) => T) => Promise<T>} update Runs a serialized update.
- */
-
-const RESOURCE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
-
-export const validateDatabase = (data) => {
-  if (!isObject(data)) {
-    throw new Error('База данных должна содержать JSON-объект');
-  }
-
-  Object.entries(data).forEach(([resource, records]) => {
-    if (!RESOURCE_NAME_PATTERN.test(resource) || !isSafeKey(resource)) {
-      throw new Error(`Недопустимое имя ресурса «${resource}»`);
-    }
-
-    if (!Array.isArray(records)) {
-      throw new Error(`Ресурс «${resource}» должен содержать JSON-массив`);
-    }
-
-    const ids = new Set();
-
-    records.forEach((record, index) => {
-      if (!isObject(record)) {
-        throw new Error(`Запись ${index} ресурса «${resource}» должна содержать JSON-объект`);
-      }
-
-      if (typeof record.id !== 'string' && !(typeof record.id === 'number' && Number.isFinite(record.id))) {
-        throw new Error(`Запись ${index} ресурса «${resource}» должна содержать строковый или числовой id`);
-      }
-
-      if (String(record.id) === '') {
-        throw new Error(`Запись ${index} ресурса «${resource}» должна содержать непустой id`);
-      }
-
-      const id = String(record.id);
-
-      if (ids.has(id)) {
-        throw new Error(`Ресурс «${resource}» содержит повторяющийся id «${id}»`);
-      }
-
-      ids.add(id);
-    });
-  });
-
-  return data;
-};
-
-export const readJsonObject = async (path, label) => {
-  let source;
-
-  try {
-    source = await readFile(resolve(path), 'utf8');
-  } catch (error) {
-    if (error?.code === 'ENOENT') {
-      throw new Error(`${label} не найден: ${resolve(path)}`);
-    }
-
-    throw error;
-  }
-
-  const value = JSON.parse(source);
-
-  if (!isObject(value)) {
-    throw new Error(`${label} должен содержать JSON-объект`);
-  }
-
-  return value;
-};
-
-export const readDatabaseFile = async (databasePath) => validateDatabase(await readJsonObject(databasePath, 'Файл базы данных'));
-
-const createDiskDatabaseStore = async (databasePath) => {
-  const resolvedDatabasePath = resolveDatabasePath(databasePath);
-  const initialData = await readDatabaseFile(resolvedDatabasePath);
-  const database = await JSONFilePreset(resolvedDatabasePath, initialData);
-  const schedule = createSerialQueue();
-
-  const read = async () => {
-    database.data = await readDatabaseFile(resolvedDatabasePath);
-
-    return database.data;
-  };
-
-  const update = (operation) =>
-    schedule(async () => {
-      await read();
-
-      const result = operation(database);
-
-      validateDatabase(database.data);
-      await database.write();
-
-      return result;
-    });
-
-  return { database, path: resolvedDatabasePath, read, update };
-};
-
-const createMemoryDatabaseStore = (sourceData) => {
-  const database = { data: validateDatabase(structuredClone(sourceData)) };
-  const schedule = createSerialQueue();
-
-  const read = async () => database.data;
-  const update = (operation) =>
-    schedule(() => {
-      const draft = { data: structuredClone(database.data) };
-      const result = operation(draft);
-
-      validateDatabase(draft.data);
-      database.data = draft.data;
-
-      return result;
-    });
-
-  return { database, read, update };
-};
-
-/**
- * Creates a disk- or memory-backed database with serialized updates.
- * @param {import('./config.js').DatabaseConfig} config Database source.
- * @returns {Promise<DatabaseStore>} 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;
-
-  if (!Array.isArray(collection)) {
-    throw createHttpError(404, 'Ресурс не найден');
-  }
-
-  return collection;
-};
-
-export const findItem = (collection, id) => collection.find((item) => String(item.id) === String(id));
-
-export const createId = (collection) => createUniqueId((id) => findItem(collection, id) != null);