@kollors/deep-json-server 0.4.0 → 0.5.0

package/src/files.js

@@ -0,0 +1,278 @@
+import { randomBytes } from 'node:crypto';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createHttpError, isObject } from './utils.js';
+
+const createFileId = (files) => {
+  let id;
+
+  do {
+    id = randomBytes(8).toString('base64url');
+  } while (files.some((file) => file.id === id));
+
+  return id;
+};
+
+const validateFileMetadata = (files, metadataPath) => {
+  if (!Array.isArray(files)) {
+    throw new Error(`Файл метаданных ${metadataPath} должен содержать JSON-массив`);
+  }
+
+  const ids = new Set();
+
+  files.forEach((file, index) => {
+    if (
+      !isObject(file) ||
+      typeof file.id !== 'string' ||
+      file.id === '' ||
+      typeof file.mimeType !== 'string' ||
+      file.mimeType === '' ||
+      typeof file.name !== 'string' ||
+      file.name === '' ||
+      !Number.isInteger(file.size) ||
+      file.size < 0 ||
+      file.url !== `/_files/${file.id}`
+    ) {
+      throw new Error(`Некорректная запись ${index} в файле метаданных ${metadataPath}`);
+    }
+
+    if (ids.has(file.id)) {
+      throw new Error(`Файл метаданных ${metadataPath} содержит повторяющийся id «${file.id}»`);
+    }
+
+    ids.add(file.id);
+  });
+
+  return files;
+};
+
+const readMetadata = async (metadataPath) => {
+  try {
+    return validateFileMetadata(JSON.parse(await readFile(metadataPath, 'utf8')), metadataPath);
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return [];
+    }
+
+    throw error;
+  }
+};
+
+const writeMetadata = async (metadataPath, files) => {
+  const temporaryPath = `${metadataPath}.${randomBytes(6).toString('hex')}.tmp`;
+
+  try {
+    await writeFile(temporaryPath, JSON.stringify(files, null, 2), { encoding: 'utf8', flag: 'wx' });
+    await rename(temporaryPath, metadataPath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true });
+    throw error;
+  }
+};
+
+const getContentName = (value) => {
+  if (typeof value !== 'string' || value === '') {
+    throw createHttpError(400, 'Заголовок Content-Name обязателен');
+  }
+
+  let name;
+
+  try {
+    name = decodeURIComponent(value).replaceAll('\\', '/');
+  } catch {
+    throw createHttpError(400, 'Заголовок Content-Name содержит некорректное значение');
+  }
+
+  const parts = name.split('/');
+
+  if (name.startsWith('/') || parts.some((part) => part === '' || part === '.' || part === '..' || part.includes('\0'))) {
+    throw createHttpError(400, 'Заголовок Content-Name должен содержать безопасный относительный путь');
+  }
+
+  return name;
+};
+
+const getMimeType = (value) => {
+  const mimeType = typeof value === 'string' ? value.split(';', 1)[0].trim().toLowerCase() : '';
+
+  if (mimeType === '' || !/^[\w!#$&^.+-]+\/[\w!#$&^.+-]+$/.test(mimeType)) {
+    throw createHttpError(400, 'Заголовок Content-Type должен содержать корректный MIME-тип');
+  }
+
+  return mimeType;
+};
+
+const createSizeLimiter = (maxFileSize, onSize) => {
+  let size = 0;
+
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      size += chunk.length;
+
+      if (size > maxFileSize) {
+        callback(createHttpError(413, `Размер файла не должен превышать ${maxFileSize} байт`));
+        return;
+      }
+
+      onSize(size);
+      callback(null, chunk);
+    },
+  });
+};
+
+const createFileStore = async ({ directoryPath: sourceDirectoryPath, metadataPath: sourceMetadataPath }) => {
+  if (typeof sourceDirectoryPath !== 'string' || sourceDirectoryPath.trim() === '') {
+    throw new Error('Путь к директории файлов не должен быть пустым');
+  }
+
+  if (typeof sourceMetadataPath !== 'string' || sourceMetadataPath.trim() === '') {
+    throw new Error('Путь к файлу метаданных не должен быть пустым');
+  }
+
+  const directoryPath = resolve(sourceDirectoryPath);
+  const metadataPath = resolve(sourceMetadataPath);
+  let operationQueue = Promise.resolve();
+
+  await Promise.all([mkdir(directoryPath, { recursive: true }), mkdir(dirname(metadataPath), { recursive: true })]);
+  await readMetadata(metadataPath);
+
+  const schedule = (operation) => {
+    const pendingOperation = operationQueue.then(operation);
+
+    operationQueue = pendingOperation.catch(() => undefined);
+
+    return pendingOperation;
+  };
+
+  const get = (id) =>
+    schedule(async () => {
+      const files = await readMetadata(metadataPath);
+      const file = files.find((item) => item.id === id);
+
+      if (file == null) {
+        throw createHttpError(404, 'Файл не найден');
+      }
+
+      const path = join(directoryPath, file.id);
+
+      try {
+        await access(path);
+      } catch (error) {
+        if (error?.code === 'ENOENT') {
+          throw createHttpError(404, 'Файл не найден');
+        }
+
+        throw error;
+      }
+
+      return { file, path };
+    });
+
+  const upload = ({ maxFileSize, mimeType, name, stream }) =>
+    schedule(async () => {
+      const files = await readMetadata(metadataPath);
+      const id = createFileId(files);
+      const path = join(directoryPath, id);
+      const temporaryPath = `${path}.upload`;
+      let size = 0;
+
+      try {
+        await pipeline(
+          stream,
+          createSizeLimiter(maxFileSize, (value) => (size = value)),
+          createWriteStream(temporaryPath, { flags: 'wx' }),
+        );
+        await rename(temporaryPath, path);
+
+        const file = { id, mimeType, name, size, url: `/_files/${id}` };
+
+        files.push(file);
+        await writeMetadata(metadataPath, files);
+
+        return file;
+      } catch (error) {
+        await Promise.all([rm(temporaryPath, { force: true }), rm(path, { force: true })]);
+        throw error;
+      }
+    });
+
+  const remove = (id) =>
+    schedule(async () => {
+      const files = await readMetadata(metadataPath);
+      const index = files.findIndex((file) => file.id === id);
+
+      if (index === -1) {
+        throw createHttpError(404, 'Файл не найден');
+      }
+
+      const [file] = files.splice(index, 1);
+      const path = join(directoryPath, file.id);
+      const temporaryPath = `${path}.${randomBytes(6).toString('hex')}.delete`;
+
+      try {
+        await rename(path, temporaryPath);
+      } catch (error) {
+        if (error?.code === 'ENOENT') {
+          throw createHttpError(404, 'Файл не найден');
+        }
+
+        throw error;
+      }
+
+      try {
+        await writeMetadata(metadataPath, files);
+      } catch (error) {
+        await rename(temporaryPath, path);
+        throw error;
+      }
+
+      await rm(temporaryPath, { force: true }).catch(() => undefined);
+
+      return file;
+    });
+
+  return { get, remove, upload };
+};
+
+const getDownloadName = (name) => encodeURIComponent(basename(name)).replaceAll("'", '%27');
+
+export const registerFileRoutes = async (server, { directoryPath, maxFileSize, metadataPath }) => {
+  const store = await createFileStore({ directoryPath, metadataPath });
+
+  server.register((fileServer, _options, done) => {
+    fileServer.removeAllContentTypeParsers();
+    fileServer.addContentTypeParser('*', (_request, payload, parserDone) => parserDone(null, payload));
+
+    fileServer.post('/_files', async (request, reply) => {
+      const contentLength = Number(request.headers['content-length']);
+
+      if (Number.isFinite(contentLength) && contentLength > maxFileSize) {
+        throw createHttpError(413, `Размер файла не должен превышать ${maxFileSize} байт`);
+      }
+
+      const file = await store.upload({
+        maxFileSize,
+        mimeType: getMimeType(request.headers['content-type']),
+        name: getContentName(request.headers['content-name']),
+        stream: request.body,
+      });
+
+      return reply.code(201).send(file);
+    });
+
+    fileServer.get('/_files/:id', async (request, reply) => {
+      const { file, path } = await store.get(request.params.id);
+
+      reply.header('Content-Disposition', `inline; filename*=UTF-8''${getDownloadName(file.name)}`);
+      reply.type(file.mimeType);
+
+      return reply.send(createReadStream(path));
+    });
+
+    fileServer.delete('/_files/:id', async (request) => store.remove(request.params.id));
+    done();
+  });
+};

package/src/openapi/document.js

@@ -101,6 +101,7 @@ const addReverseRelations = (schemas, rawSchemas, resources, componentNames) =>
 };
 
 const createParameters = () => ({
+  ContentName: { description: 'URI-encoded relative file name', in: 'header', name: 'Content-Name', required: true, schema: { type: 'string' } },
   Embed: { description: 'Relationship paths to embed', explode: true, in: 'query', name: '_embed', schema: { items: { type: 'string' }, type: 'array' }, style: 'form' },
   Id: { in: 'path', name: 'id', required: true, schema: { type: 'string' } },
   Page: { in: 'query', name: '_page', required: false, schema: { default: 1, minimum: 1, type: 'integer' } },
@@ -114,6 +115,40 @@ const createResponse = (description, schema) => ({ description, ...(schema != nu
 const createParameterReference = (name) => ({ $ref: `#/components/parameters/${name}` });
 const createRequestBody = (name) => ({ required: true, ...createJsonContent(createSchemaReference(name)) });
 
+const createFilePaths = () => ({
+  '/_files': {
+    post: {
+      operationId: 'uploadFile',
+      parameters: [createParameterReference('ContentName')],
+      requestBody: { content: { 'application/octet-stream': { schema: { format: 'binary', type: 'string' } } }, required: true },
+      responses: {
+        201: createResponse('Uploaded', createSchemaReference('UploadedFile')),
+        400: createResponse('Invalid request', createSchemaReference('Error')),
+        413: createResponse('File is too large', createSchemaReference('Error')),
+        415: createResponse('Unsupported media type', createSchemaReference('Error')),
+      },
+      tags: ['files'],
+    },
+  },
+  '/_files/{id}': {
+    delete: {
+      operationId: 'deleteFileById',
+      parameters: [createParameterReference('Id')],
+      responses: { 200: createResponse('Deleted', createSchemaReference('UploadedFile')), 404: createResponse('Not found', createSchemaReference('Error')) },
+      tags: ['files'],
+    },
+    get: {
+      operationId: 'getFileById',
+      parameters: [createParameterReference('Id')],
+      responses: {
+        200: { content: { 'application/octet-stream': { schema: { format: 'binary', type: 'string' } } }, description: 'File contents' },
+        404: createResponse('Not found', createSchemaReference('Error')),
+      },
+      tags: ['files'],
+    },
+  },
+});
+
 const createResourcePaths = (resource, componentName) => {
   const resourceName = toPascalCase(resource);
 
@@ -181,8 +216,8 @@ const getOperationIds = (resource) => {
   return [`get${resourceName}`, `post${resourceName}`, `delete${resourceName}ById`, `get${resourceName}ById`, `patch${resourceName}ById`, `put${resourceName}ById`];
 };
 
-const validateGeneratedNames = (resources, componentNames) => {
-  const schemaOwners = new Map([['Error', 'встроенная схема ошибки']]);
+const validateGeneratedNames = (resources, componentNames, files) => {
+  const schemaOwners = new Map([['Error', 'встроенная схема ошибки'], ...(files ? [['UploadedFile', 'встроенная схема файла']] : [])]);
   const operationOwners = new Map();
 
   resources.forEach((resource) => {
@@ -218,10 +253,10 @@ const validateGeneratedNames = (resources, componentNames) => {
  * Creates an OpenAPI 3.0 document from a database and optional schema configuration.
  * @param {Record<string, Array<Record<string, unknown>>>} database Database contents.
  * @param {Record<string, unknown>} [schemaConfig] Schema configuration.
- * @param {{ host?: string, port?: number }} [serverOptions] Server address used in the generated document.
+ * @param {{ files?: boolean, host?: string, port?: number }} [serverOptions] Server address and optional features used in the generated document.
  * @returns {Record<string, unknown>} OpenAPI document.
  */
-export function createOpenApiDocument(database, schemaConfig = {}, { host = DEFAULT_HOST, port = DEFAULT_PORT } = {}) {
+export function createOpenApiDocument(database, schemaConfig = {}, { files = false, host = DEFAULT_HOST, port = DEFAULT_PORT } = {}) {
   validateDatabase(database);
 
   if (!isObject(schemaConfig)) {
@@ -239,7 +274,7 @@ export function createOpenApiDocument(database, schemaConfig = {}, { host = DEFA
     }),
   );
 
-  validateGeneratedNames(resources, componentNames);
+  validateGeneratedNames(resources, componentNames, files);
 
   const rawSchemas = Object.fromEntries(
     resources.map((resource) => {
@@ -250,7 +285,16 @@ export function createOpenApiDocument(database, schemaConfig = {}, { host = DEFA
       return [resource, applyConfiguredFields(ensureGeneratedIdSchema(configuredSchema), resource, resourceConfig)];
     }),
   );
-  const schemas = { Error: { properties: { error: { type: 'string' } }, required: ['error'], type: 'object' } };
+  const schemas = {
+    Error: { properties: { error: { type: 'string' } }, required: ['error'], type: 'object' },
+    ...(files && {
+      UploadedFile: {
+        properties: { id: { type: 'string' }, mimeType: { type: 'string' }, name: { type: 'string' }, size: { minimum: 0, type: 'integer' }, url: { type: 'string' } },
+        required: ['id', 'mimeType', 'name', 'size', 'url'],
+        type: 'object',
+      },
+    }),
+  };
 
   resources.forEach((resource) => {
     const componentName = componentNames[resource];
@@ -280,8 +324,8 @@ export function createOpenApiDocument(database, schemaConfig = {}, { host = DEFA
     components: { parameters: createParameters(), schemas },
     info: isObject(schemaConfig.$info) ? schemaConfig.$info : { title: 'Deep JSON Server API', version: '1.0.0' },
     openapi: '3.0.3',
-    paths: Object.assign({}, ...resources.map((resource) => createResourcePaths(resource, componentNames[resource]))),
+    paths: Object.assign({}, ...resources.map((resource) => createResourcePaths(resource, componentNames[resource])), files ? createFilePaths() : {}),
     servers: [{ url: getServerUrl(host, port) }],
-    tags: resources.map((resource) => ({ name: resource })),
+    tags: [...resources.map((resource) => ({ name: resource })), ...(files ? [{ name: 'files' }] : [])],
   };
 }

package/src/openapi/index.js

@@ -9,13 +9,13 @@ export { createOpenApiDocument } from './document.js';
 
 /**
  * Generates an OpenAPI YAML file.
- * @param {{ databasePath: string, host?: string, outputPath: string, port?: number, schemaPath: string }} options Generation options.
+ * @param {{ databasePath: string, files?: boolean, host?: string, outputPath: string, port?: number, schemaPath?: string }} options Generation options.
  * @returns {Promise<Record<string, unknown>>} Generated OpenAPI document.
  */
-export async function generateOpenApi({ databasePath, host, outputPath, port, schemaPath }) {
+export async function generateOpenApi({ databasePath, files = false, host, outputPath, port, schemaPath }) {
   const database = await readDatabaseFile(databasePath);
   const schemaConfig = await readSchemaConfig(schemaPath);
-  const document = createOpenApiDocument(database, schemaConfig, { host, port });
+  const document = createOpenApiDocument(database, schemaConfig, { files, host, port });
   const resolvedOutputPath = resolve(outputPath);
 
   await mkdir(dirname(resolvedOutputPath), { recursive: true });

package/src/server.js

@@ -1,6 +1,7 @@
 import Fastify from 'fastify';
-import { DEFAULT_HOST, DEFAULT_PORT, MAX_PAGE_SIZE } from './constants.js';
+import { DEFAULT_HOST, DEFAULT_MAX_FILE_SIZE, DEFAULT_PORT, MAX_PAGE_SIZE } from './constants.js';
 import { createDatabaseStore, createId, findItem, getCollection } from './database.js';
+import { registerFileRoutes } from './files.js';
 import { readSchemaConfig } from './openapi/config.js';
 import { createOpenApiDocument } from './openapi/index.js';
 import { matchesWhere, paginateItems, parsePagination, parseWhere, sortItems, validateWhere } from './query/index.js';
@@ -8,7 +9,7 @@ import { embedItem, parseEmbedPaths, validateEmbedPaths } from './relations.js';
 import { createHttpError, getResourceNames, isObject, resolveDatabasePath } from './utils.js';
 
 const CORS_HEADERS = {
-  'Access-Control-Allow-Headers': 'Content-Type',
+  'Access-Control-Allow-Headers': 'Content-Name, Content-Type',
   'Access-Control-Allow-Methods': 'DELETE, GET, OPTIONS, PATCH, POST, PUT',
   'Access-Control-Allow-Origin': '*',
 };
@@ -142,16 +143,20 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
 
 /**
  * Creates a Fastify server without opening a network port.
- * @param {{ databasePath: string, logger?: boolean | Record<string, unknown>, maxPageSize?: number, schemaPath?: string }} options Server options.
+ * @param {{ databasePath: string, filesDirectoryPath?: string, filesMetadataPath?: string, logger?: boolean | Record<string, unknown>, maxFileSize?: number, maxPageSize?: number, schemaPath?: string }} options Server options.
  * @returns {Promise<import('fastify').FastifyInstance>} Fastify server.
  */
 export async function createServer(options) {
-  const { databasePath, logger = true, maxPageSize = MAX_PAGE_SIZE, schemaPath } = options ?? {};
+  const { databasePath, filesDirectoryPath, filesMetadataPath, logger = true, maxFileSize = DEFAULT_MAX_FILE_SIZE, maxPageSize = MAX_PAGE_SIZE, schemaPath } = options ?? {};
 
   if (!Number.isInteger(maxPageSize) || maxPageSize < 1) {
     throw new Error('Максимальный размер страницы должен быть положительным целым числом');
   }
 
+  if (!Number.isInteger(maxFileSize) || maxFileSize < 1) {
+    throw new Error('Максимальный размер файла должен быть положительным целым числом');
+  }
+
   const store = await createDatabaseStore(databasePath);
   const schemaConfig = await readSchemaConfig(schemaPath);
   const document = createOpenApiDocument(store.database.data, schemaConfig);
@@ -180,6 +185,14 @@ export async function createServer(options) {
     registerResourceRoutes(server, store, resource, document, maxPageSize);
   });
 
+  if ((filesDirectoryPath == null) !== (filesMetadataPath == null)) {
+    throw new Error('Для файловых маршрутов укажите filesDirectoryPath и filesMetadataPath');
+  }
+
+  if (filesDirectoryPath != null) {
+    await registerFileRoutes(server, { directoryPath: filesDirectoryPath, maxFileSize, metadataPath: filesMetadataPath });
+  }
+
   server.setErrorHandler((error, request, reply) => {
     const statusCode = Number.isInteger(error.statusCode) ? error.statusCode : 500;
 
@@ -195,18 +208,28 @@ export async function createServer(options) {
 
 /**
  * Creates and starts a Fastify server.
- * @param {{ databasePath: string, host?: string, logger?: boolean | Record<string, unknown>, maxPageSize?: number, port?: number, schemaPath?: string }} options Server options.
+ * @param {{ databasePath: string, filesDirectoryPath?: string, filesMetadataPath?: string, host?: string, logger?: boolean | Record<string, unknown>, maxFileSize?: number, maxPageSize?: number, port?: number, schemaPath?: string }} options Server options.
  * @returns {Promise<import('fastify').FastifyInstance>} Listening Fastify server.
  */
 export async function startServer(options) {
-  const { databasePath, host = DEFAULT_HOST, logger = true, maxPageSize = MAX_PAGE_SIZE, port = DEFAULT_PORT, schemaPath } = options ?? {};
+  const {
+    databasePath,
+    filesDirectoryPath,
+    filesMetadataPath,
+    host = DEFAULT_HOST,
+    logger = true,
+    maxFileSize = DEFAULT_MAX_FILE_SIZE,
+    maxPageSize = MAX_PAGE_SIZE,
+    port = DEFAULT_PORT,
+    schemaPath,
+  } = options ?? {};
 
   if (!Number.isInteger(port) || port < 0 || port > 65_535) {
     throw new Error('Порт должен быть целым числом от 0 до 65535');
   }
 
   const resolvedDatabasePath = resolveDatabasePath(databasePath);
-  const server = await createServer({ databasePath: resolvedDatabasePath, logger, maxPageSize, schemaPath });
+  const server = await createServer({ databasePath: resolvedDatabasePath, filesDirectoryPath, filesMetadataPath, logger, maxFileSize, maxPageSize, schemaPath });
 
   await server.listen({ host, port });
   server.log.info({ database: resolvedDatabasePath }, 'Deep JSON Server запущен');

package/types/src/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const DEFAULT_HOST = "127.0.0.1";
+export declare const DEFAULT_MAX_FILE_SIZE: number;
 export declare const DEFAULT_PAGE_SIZE = 10;
 export declare const DEFAULT_PORT = 4001;
 export declare const MAX_PAGE_SIZE = 1000;

package/types/src/files.d.ts

@@ -0,0 +1,5 @@
+export declare const registerFileRoutes: (server: any, { directoryPath, maxFileSize, metadataPath }: {
+    directoryPath: any;
+    maxFileSize: any;
+    metadataPath: any;
+}) => Promise<void>;

package/types/src/openapi/document.d.ts

@@ -2,10 +2,11 @@
  * Creates an OpenAPI 3.0 document from a database and optional schema configuration.
  * @param {Record<string, Array<Record<string, unknown>>>} database Database contents.
  * @param {Record<string, unknown>} [schemaConfig] Schema configuration.
- * @param {{ host?: string, port?: number }} [serverOptions] Server address used in the generated document.
+ * @param {{ files?: boolean, host?: string, port?: number }} [serverOptions] Server address and optional features used in the generated document.
  * @returns {Record<string, unknown>} OpenAPI document.
  */
-export declare function createOpenApiDocument(database: Record<string, Array<Record<string, unknown>>>, schemaConfig?: Record<string, unknown>, { host, port }?: {
+export declare function createOpenApiDocument(database: Record<string, Array<Record<string, unknown>>>, schemaConfig?: Record<string, unknown>, { files, host, port }?: {
+    files?: boolean;
     host?: string;
     port?: number;
 }): Record<string, unknown>;

package/types/src/openapi/index.d.ts

@@ -1,13 +1,14 @@
 export { createOpenApiDocument } from './document.js';
 /**
  * Generates an OpenAPI YAML file.
- * @param {{ databasePath: string, host?: string, outputPath: string, port?: number, schemaPath: string }} options Generation options.
+ * @param {{ databasePath: string, files?: boolean, host?: string, outputPath: string, port?: number, schemaPath?: string }} options Generation options.
  * @returns {Promise<Record<string, unknown>>} Generated OpenAPI document.
  */
-export declare function generateOpenApi({ databasePath, host, outputPath, port, schemaPath }: {
+export declare function generateOpenApi({ databasePath, files, host, outputPath, port, schemaPath }: {
     databasePath: string;
+    files?: boolean;
     host?: string;
     outputPath: string;
     port?: number;
-    schemaPath: string;
+    schemaPath?: string;
 }): Promise<Record<string, unknown>>;

package/types/src/server.d.ts

@@ -1,23 +1,29 @@
 /**
  * Creates a Fastify server without opening a network port.
- * @param {{ databasePath: string, logger?: boolean | Record<string, unknown>, maxPageSize?: number, schemaPath?: string }} options Server options.
+ * @param {{ databasePath: string, filesDirectoryPath?: string, filesMetadataPath?: string, logger?: boolean | Record<string, unknown>, maxFileSize?: number, maxPageSize?: number, schemaPath?: string }} options Server options.
  * @returns {Promise<import('fastify').FastifyInstance>} Fastify server.
  */
 export declare function createServer(options: {
     databasePath: string;
+    filesDirectoryPath?: string;
+    filesMetadataPath?: string;
     logger?: boolean | Record<string, unknown>;
+    maxFileSize?: number;
     maxPageSize?: number;
     schemaPath?: string;
 }): Promise<import('fastify').FastifyInstance>;
 /**
  * Creates and starts a Fastify server.
- * @param {{ databasePath: string, host?: string, logger?: boolean | Record<string, unknown>, maxPageSize?: number, port?: number, schemaPath?: string }} options Server options.
+ * @param {{ databasePath: string, filesDirectoryPath?: string, filesMetadataPath?: string, host?: string, logger?: boolean | Record<string, unknown>, maxFileSize?: number, maxPageSize?: number, port?: number, schemaPath?: string }} options Server options.
  * @returns {Promise<import('fastify').FastifyInstance>} Listening Fastify server.
  */
 export declare function startServer(options: {
     databasePath: string;
+    filesDirectoryPath?: string;
+    filesMetadataPath?: string;
     host?: string;
     logger?: boolean | Record<string, unknown>;
+    maxFileSize?: number;
     maxPageSize?: number;
     port?: number;
     schemaPath?: string;