@kollors/deep-json-server 0.5.0 → 0.7.0

package/src/server.js

@@ -1,20 +1,25 @@
 import Fastify from 'fastify';
-import { DEFAULT_HOST, DEFAULT_MAX_FILE_SIZE, DEFAULT_PORT, MAX_PAGE_SIZE } from './constants.js';
+import { normalizeServerConfig } from './config.js';
+import { DEFAULT_HOST, DEFAULT_MAX_FILE_SIZE, DEFAULT_MAX_PAGE_SIZE, DEFAULT_PORT } 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 { createFileStore, registerFileRoutes } from './files.js';
+import { resolveSchemaConfig } from './openapi/config.js';
+import { buildOpenapiDocument } from './openapi/document.js';
+import { createOpenapi, writeOpenapi } from './openapi/index.js';
 import { matchesWhere, paginateItems, parsePagination, parseWhere, sortItems, validateWhere } from './query/index.js';
 import { embedItem, parseEmbedPaths, validateEmbedPaths } from './relations.js';
-import { createHttpError, getResourceNames, isObject, resolveDatabasePath } from './utils.js';
+import { createHttpError, getResourceNames, isObject } from './utils.js';
+
+/** @typedef {Record<string, unknown>} OpenapiDocument */
+/** @typedef {{ fastify: () => import('fastify').FastifyInstance, openapi: () => Promise<OpenapiDocument> }} ServerFacade */
 
 const CORS_HEADERS = {
-  'Access-Control-Allow-Headers': 'Content-Name, Content-Type',
+  'Access-Control-Allow-Headers': 'Content-Directory, Content-Name, Content-Override, Content-Type',
   'Access-Control-Allow-Methods': 'DELETE, GET, OPTIONS, PATCH, POST, PUT',
   'Access-Control-Allow-Origin': '*',
 };
 
-const getRequestBody = (body) => {
+const getJsonObjectBody = (body) => {
   if (!isObject(body)) {
     throw createHttpError(400, 'Тело запроса должно быть JSON-объектом');
   }
@@ -24,7 +29,7 @@ const getRequestBody = (body) => {
 
 const getSchemaName = (reference) => reference.split('/').at(-1);
 
-const addRequestSchemas = (server, document, resources) => {
+const addRequestSchemas = (fastify, document, resources) => {
   const requestSchemaNames = new Set(
     resources.flatMap((resource) => {
       const resourcePath = document.paths[`/${resource}`];
@@ -35,17 +40,17 @@ const addRequestSchemas = (server, document, resources) => {
   );
 
   requestSchemaNames.forEach((schemaName) => {
-    server.addSchema({ $id: schemaName, ...document.components.schemas[schemaName] });
+    fastify.addSchema({ $id: schemaName, ...document.components.schemas[schemaName] });
   });
 };
 
-const registerResourceRoutes = (server, store, resource, document, maxPageSize) => {
+const registerResourceRoutes = (fastify, store, resource, document, maxPageSize) => {
   const resourcePath = `/${resource}`;
   const itemPath = `/${resource}/:id`;
   const createSchemaName = getSchemaName(document.paths[resourcePath].post.requestBody.content['application/json'].schema.$ref);
   const updateSchemaName = getSchemaName(document.paths[`/${resource}/{id}`].patch.requestBody.content['application/json'].schema.$ref);
 
-  server.get(resourcePath, async (request) => {
+  fastify.get(resourcePath, async (request) => {
     const collection = getCollection(store.database, resource);
     const where = parseWhere(request.query);
     const embedPaths = parseEmbedPaths(request.query._embed);
@@ -64,7 +69,7 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
     return paginateItems(sortedItems, pagination.page, pagination.pageSize);
   });
 
-  server.get(itemPath, async (request) => {
+  fastify.get(itemPath, async (request) => {
     const collection = getCollection(store.database, resource);
     const item = findItem(collection, request.params.id);
     const embedPaths = parseEmbedPaths(request.query._embed);
@@ -78,10 +83,10 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
     return embedItem(store.database, item, resource, embedPaths);
   });
 
-  server.post(resourcePath, { schema: { body: { $ref: `${createSchemaName}#` } } }, async (request, reply) => {
+  fastify.post(resourcePath, { schema: { body: { $ref: `${createSchemaName}#` } } }, async (request, reply) => {
     const item = await store.update((database) => {
       const collection = getCollection(database, resource);
-      const createdItem = { ...getRequestBody(request.body), id: createId(collection) };
+      const createdItem = { ...getJsonObjectBody(request.body), id: createId(collection) };
 
       collection.push(createdItem);
 
@@ -91,7 +96,7 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
     return reply.code(201).send(item);
   });
 
-  server.put(itemPath, { schema: { body: { $ref: `${createSchemaName}#` } } }, async (request) =>
+  fastify.put(itemPath, { schema: { body: { $ref: `${createSchemaName}#` } } }, async (request) =>
     store.update((database) => {
       const collection = getCollection(database, resource);
       const currentItem = findItem(collection, request.params.id);
@@ -100,7 +105,7 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
         throw createHttpError(404, 'Запись не найдена');
       }
 
-      const item = { ...getRequestBody(request.body), id: currentItem.id };
+      const item = { ...getJsonObjectBody(request.body), id: currentItem.id };
 
       collection.splice(collection.indexOf(currentItem), 1, item);
 
@@ -108,7 +113,7 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
     }),
   );
 
-  server.patch(itemPath, { schema: { body: { $ref: `${updateSchemaName}#` } } }, async (request) =>
+  fastify.patch(itemPath, { schema: { body: { $ref: `${updateSchemaName}#` } } }, async (request) =>
     store.update((database) => {
       const collection = getCollection(database, resource);
       const currentItem = findItem(collection, request.params.id);
@@ -117,7 +122,7 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
         throw createHttpError(404, 'Запись не найдена');
       }
 
-      const item = { ...currentItem, ...getRequestBody(request.body), id: currentItem.id };
+      const item = { ...currentItem, ...getJsonObjectBody(request.body), id: currentItem.id };
 
       collection.splice(collection.indexOf(currentItem), 1, item);
 
@@ -125,7 +130,7 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
     }),
   );
 
-  server.delete(itemPath, async (request) =>
+  fastify.delete(itemPath, async (request) =>
     store.update((database) => {
       const collection = getCollection(database, resource);
       const currentItem = findItem(collection, request.params.id);
@@ -142,97 +147,104 @@ const registerResourceRoutes = (server, store, resource, document, maxPageSize)
 };
 
 /**
- * Creates a Fastify server without opening a network port.
- * @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.
+ * Creates lazy Fastify and OpenAPI accessors from one configuration.
+ * @param {import('./config.js').DeepJsonServerConfig} config Server configuration.
+ * @param {{ files?: boolean }} [features] Optional feature switches.
+ * @returns {Promise<ServerFacade>} Server facade.
  */
-export async function createServer(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('Максимальный размер страницы должен быть положительным целым числом');
+export async function createServer(config, features = {}) {
+  const normalizedConfig = normalizeServerConfig(config);
+  const filesEnabled = features.files ?? normalizedConfig.files != null;
+  const { logger = true, maxFileSize = DEFAULT_MAX_FILE_SIZE, maxPageSize = DEFAULT_MAX_PAGE_SIZE } = normalizedConfig.server;
+  const store = await createDatabaseStore(normalizedConfig.database);
+  const schema = await resolveSchemaConfig(normalizedConfig.database.schema);
+  const fileStore = filesEnabled && normalizedConfig.files != null ? await createFileStore(normalizedConfig.files) : undefined;
+  let fastifyInstance;
+
+  if (filesEnabled && normalizedConfig.files == null) {
+    throw new Error('Для файловых маршрутов укажите секцию config.files');
   }
 
-  if (!Number.isInteger(maxFileSize) || maxFileSize < 1) {
-    throw new Error('Максимальный размер файла должен быть положительным целым числом');
-  }
+  const buildDocument = () =>
+    buildOpenapiDocument({
+      database: store.database.data,
+      files: filesEnabled,
+      maxPageSize,
+      schema,
+    });
+
+  const getFastify = () => {
+    if (fastifyInstance != null) {
+      return fastifyInstance;
+    }
+
+    const document = buildDocument();
+    const resources = getResourceNames(store.database.data);
+    const fastify = Fastify({ logger });
+    const originalListen = fastify.listen.bind(fastify);
 
-  const store = await createDatabaseStore(databasePath);
-  const schemaConfig = await readSchemaConfig(schemaPath);
-  const document = createOpenApiDocument(store.database.data, schemaConfig);
-  const resources = getResourceNames(store.database.data);
-  const server = Fastify({ logger });
+    // Calling fastify().listen() without arguments uses config defaults.
+    fastify.listen = (...args) => originalListen(...(args.length === 0 ? [{ host: normalizedConfig.server.host ?? DEFAULT_HOST, port: normalizedConfig.server.port ?? DEFAULT_PORT }] : args));
 
-  addRequestSchemas(server, document, resources);
+    addRequestSchemas(fastify, document, resources);
 
-  server.addHook('onRequest', async (_request, reply) => {
-    Object.entries(CORS_HEADERS).forEach(([header, value]) => {
-      reply.header(header, value);
+    fastify.addHook('onRequest', async (_request, reply) => {
+      Object.entries(CORS_HEADERS).forEach(([header, value]) => {
+        reply.header(header, value);
+      });
     });
-  });
 
-  server.addHook('preHandler', async (request) => {
-    if (request.method === 'GET') {
-      await store.read();
-    }
-  });
+    fastify.addHook('preHandler', async (request) => {
+      if (request.method === 'GET') {
+        await store.read();
+      }
+    });
 
-  server.options('/', async (_request, reply) => reply.code(204).send());
-  server.options('/*', async (_request, reply) => reply.code(204).send());
-  server.get('/', async () => ({ resources }));
+    fastify.options('/', async (_request, reply) => reply.code(204).send());
+    fastify.options('/*', async (_request, reply) => reply.code(204).send());
+    fastify.get('/', async () => ({ resources }));
 
-  resources.forEach((resource) => {
-    registerResourceRoutes(server, store, resource, document, maxPageSize);
-  });
+    resources.forEach((resource) => {
+      registerResourceRoutes(fastify, store, resource, document, maxPageSize);
+    });
 
-  if ((filesDirectoryPath == null) !== (filesMetadataPath == null)) {
-    throw new Error('Для файловых маршрутов укажите filesDirectoryPath и filesMetadataPath');
-  }
+    if (fileStore != null) {
+      registerFileRoutes(fastify, { maxFileSize, store: fileStore });
+    }
 
-  if (filesDirectoryPath != null) {
-    await registerFileRoutes(server, { directoryPath: filesDirectoryPath, maxFileSize, metadataPath: filesMetadataPath });
-  }
+    fastify.setErrorHandler((error, request, reply) => {
+      const statusCode = Number.isInteger(error.statusCode) ? error.statusCode : 500;
 
-  server.setErrorHandler((error, request, reply) => {
-    const statusCode = Number.isInteger(error.statusCode) ? error.statusCode : 500;
+      if (statusCode === 500) {
+        request.log.error(error);
+      }
 
-    if (statusCode === 500) {
-      request.log.error(error);
-    }
+      return reply.code(statusCode).send({ error: error.message });
+    });
 
-    return reply.code(statusCode).send({ error: error.message });
-  });
+    fastifyInstance = fastify;
 
-  return server;
-}
+    return fastifyInstance;
+  };
 
-/**
- * Creates and starts a Fastify server.
- * @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,
-    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 openapi = async () => {
+    await store.read();
 
-  const resolvedDatabasePath = resolveDatabasePath(databasePath);
-  const server = await createServer({ databasePath: resolvedDatabasePath, filesDirectoryPath, filesMetadataPath, logger, maxFileSize, maxPageSize, schemaPath });
+    const document = createOpenapi({
+      database: store.database.data,
+      files: filesEnabled,
+      host: normalizedConfig.server.host,
+      maxPageSize,
+      port: normalizedConfig.server.port,
+      schema,
+    });
+
+    if (normalizedConfig.openapi.path != null) {
+      await writeOpenapi(document, normalizedConfig.openapi.path);
+    }
 
-  await server.listen({ host, port });
-  server.log.info({ database: resolvedDatabasePath }, 'Deep JSON Server запущен');
+    return document;
+  };
 
-  return server;
+  return { fastify: getFastify, openapi };
 }

package/src/utils.js

@@ -1,3 +1,4 @@
+import { randomBytes } from 'node:crypto';
 import { resolve } from 'node:path';
 import pluralize from 'pluralize';
 
@@ -11,6 +12,35 @@ export const createHttpError = (statusCode, message) => {
   return error;
 };
 
+/** @returns {<T>(operation: () => T | Promise<T>) => Promise<T>} Serialized operation scheduler. */
+export const createSerialQueue = () => {
+  let queue = Promise.resolve();
+
+  return (operation) => {
+    const pendingOperation = queue.then(operation);
+
+    // Keep the queue usable after a failed operation.
+    queue = pendingOperation.catch(() => undefined);
+
+    return pendingOperation;
+  };
+};
+
+/**
+ * Creates a random ID that is not currently in use.
+ * @param {(id: string) => boolean} isUsed Checks whether an ID already exists.
+ * @returns {string} Unique ID.
+ */
+export const createUniqueId = (isUsed) => {
+  let id;
+
+  do {
+    id = randomBytes(8).toString('base64url');
+  } while (isUsed(id));
+
+  return id;
+};
+
 export const getResourceNames = (data) => Object.keys(data);
 export const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 export const isSafeKey = (key) => !UNSAFE_KEYS.has(key);

package/types/index.d.ts

@@ -1,2 +1,21 @@
-export { createOpenApiDocument, generateOpenApi } from './src/openapi/index.js';
-export { createServer, startServer } from './src/server.js';
+/** @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 type DeepJsonServerConfig = import('./src/config.js').DeepJsonServerConfig;
+export type DatabaseConfig = import('./src/config.js').DatabaseConfig;
+export type FilesConfig = import('./src/config.js').FilesConfig;
+export type MemoryFile = import('./src/config.js').MemoryFile;
+export type OpenapiConfig = import('./src/config.js').OpenapiConfig;
+export type ServerConfig = import('./src/config.js').ServerConfig;
+export type FileMetadata = import('./src/files.js').FileMetadata;
+export type FileUpdate = import('./src/files.js').FileUpdate;
+export type OpenapiDocument = import('./src/server.js').OpenapiDocument;
+export type ServerFacade = import('./src/server.js').ServerFacade;
+export { createServer } from './src/server.js';

package/types/src/config.d.ts

@@ -0,0 +1,73 @@
+export type DatabaseData = Record<string, Array<Record<string, unknown>>>;
+export type DatabaseSchema = Record<string, unknown>;
+export type DatabaseConfig = {
+    data: DatabaseData;
+    path?: never;
+    schema?: DatabaseSchema | string;
+} | {
+    data?: never;
+    path: string;
+    schema?: DatabaseSchema | string;
+};
+export type MemoryFile = {
+    content: Uint8Array;
+    directory?: string;
+    mimeType: string;
+    name: string;
+};
+export type FilesConfig = {
+    data: MemoryFile[];
+    directory?: never;
+    metadata?: never;
+} | {
+    data?: never;
+    directory: string;
+    metadata: string;
+};
+export type OpenapiConfig = {
+    path?: string;
+};
+export type ServerConfig = {
+    host?: string;
+    logger?: boolean | Record<string, unknown>;
+    maxFileSize?: number;
+    maxPageSize?: number;
+    port?: number;
+};
+export type DeepJsonServerConfig = {
+    /**
+     * Database source and optional schema.
+     */
+    database: DatabaseConfig;
+    /**
+     * Binary-file storage.
+     */
+    files?: FilesConfig;
+    /**
+     * Generated OpenAPI file.
+     */
+    openapi?: OpenapiConfig;
+    /**
+     * Runtime settings.
+     */
+    server?: ServerConfig;
+};
+export type NormalizedServerConfig = {
+    database: DatabaseConfig;
+    files?: FilesConfig;
+    openapi: OpenapiConfig;
+    server: ServerConfig;
+};
+/**
+ * Validates configuration and resolves relative paths.
+ * @param {DeepJsonServerConfig} config Server configuration.
+ * @param {string} [directoryPath] Base directory for relative paths.
+ * @returns {NormalizedServerConfig} Normalized configuration.
+ */
+export declare const normalizeServerConfig: (config: DeepJsonServerConfig, directoryPath?: string) => NormalizedServerConfig;
+/**
+ * Loads an ES module config and resolves paths from its directory.
+ * @param {string} configPath Configuration module path.
+ * @returns {Promise<NormalizedServerConfig>} Normalized configuration.
+ */
+export declare function readServerConfig(configPath: string): Promise<NormalizedServerConfig>;

package/types/src/constants.d.ts

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

package/types/src/database.d.ts

@@ -1,8 +1,33 @@
+export type DatabaseContainer = {
+    data: import('./config.js').DatabaseData;
+};
+export type DatabaseStore = {
+    /**
+     * Current database container.
+     */
+    database: DatabaseContainer;
+    /**
+     * Resolved database file path.
+     */
+    path?: string;
+    /**
+     * Returns current data and reloads disk-backed sources.
+     */
+    read: () => Promise<import('./config.js').DatabaseData>;
+    /**
+     * Runs a serialized update.
+     */
+    update: <T>(operation: (database: DatabaseContainer) => T) => Promise<T>;
+};
 export declare const validateDatabase: (data: any) => any;
 export declare const readJsonObject: (path: any, label: any) => Promise<any>;
 export declare const readDatabaseFile: (databasePath: any) => Promise<any>;
-/** @returns {Promise<any>} Internal LowDB-backed store. */
-export declare const createDatabaseStore: (databasePath: any) => Promise<any>;
+/**
+ * Creates a disk- or memory-backed database with serialized updates.
+ * @param {import('./config.js').DatabaseConfig} config Database source.
+ * @returns {Promise<DatabaseStore>} Database store.
+ */
+export declare const createDatabaseStore: (config: import('./config.js').DatabaseConfig) => Promise<DatabaseStore>;
 export declare const getCollection: (database: any, resource: any) => any[];
 export declare const findItem: (collection: any, id: any) => any;
-export declare const createId: (collection: any) => any;
+export declare const createId: (collection: any) => string;

package/types/src/files.d.ts

@@ -1,5 +1,64 @@
-export declare const registerFileRoutes: (server: any, { directoryPath, maxFileSize, metadataPath }: {
-    directoryPath: any;
+import { Readable } from 'node:stream';
+export type StoredFileMetadata = {
+    directory: string;
+    mimeType: string;
+    name: string;
+};
+export type FileRecord = StoredFileMetadata & {
+    size: number;
+};
+export type FileMetadata = FileRecord & {
+    downloadUrl: string;
+    metadataUrl: string;
+    url: string;
+};
+export type FileUpload = {
+    directory: string;
+    maxFileSize: number;
+    mimeType: string;
+    name: string;
+    override: boolean;
+    stream: Readable;
+};
+export type FileUpdate = {
+    directory?: string;
+    name?: string;
+};
+export type FileStore = {
+    /**
+     * Returns file metadata and contents.
+     */
+    get: (path: string) => Promise<{
+        file: FileRecord;
+        stream: Readable;
+    }>;
+    /**
+     * Returns file metadata.
+     */
+    metadata: (path: string) => Promise<FileRecord>;
+    /**
+     * Deletes a file.
+     */
+    remove: (path: string) => Promise<void>;
+    /**
+     * Renames or moves a file.
+     */
+    update: (path: string, update: FileUpdate) => Promise<FileRecord>;
+    /**
+     * Stores a file.
+     */
+    upload: (upload: FileUpload) => Promise<{
+        created: boolean;
+        file: FileRecord;
+    }>;
+};
+/**
+ * Creates a disk- or memory-backed file store with serialized operations.
+ * @param {import('./config.js').FilesConfig} config File storage configuration.
+ * @returns {Promise<FileStore>} File store.
+ */
+export declare const createFileStore: (config: import('./config.js').FilesConfig) => Promise<FileStore>;
+export declare const registerFileRoutes: (fastify: any, { maxFileSize, store }: {
     maxFileSize: any;
-    metadataPath: any;
-}) => Promise<void>;
+    store: any;
+}) => void;

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

@@ -1,3 +1,3 @@
 export declare const validateSchemaConfig: (schemaConfig: any, resources: any) => any;
 export declare const applyConfiguredFields: (schema: any, resource: any, resourceConfig: any) => any;
-export declare const readSchemaConfig: (schemaPath: any) => Promise<any>;
+export declare const resolveSchemaConfig: (schema: any) => Promise<any>;

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

@@ -1,12 +1,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 {{ files?: boolean, host?: string, port?: number }} [serverOptions] Server address and optional features used in the generated document.
+ * Builds an OpenAPI document without runtime server addresses.
+ * @param {{ database: Record<string, Array<Record<string, unknown>>>, files?: boolean, maxPageSize?: number, schema?: Record<string, unknown> }} options Source data and schema settings.
  * @returns {Record<string, unknown>} OpenAPI document.
  */
-export declare function createOpenApiDocument(database: Record<string, Array<Record<string, unknown>>>, schemaConfig?: Record<string, unknown>, { files, host, port }?: {
+export declare function buildOpenapiDocument(options: {
+    database: Record<string, Array<Record<string, unknown>>>;
     files?: boolean;
-    host?: string;
-    port?: number;
+    maxPageSize?: number;
+    schema?: Record<string, unknown>;
 }): Record<string, unknown>;

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

@@ -1,14 +1,9 @@
-export { createOpenApiDocument } from './document.js';
-/**
- * Generates an OpenAPI YAML file.
- * @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, files, host, outputPath, port, schemaPath }: {
-    databasePath: string;
-    files?: boolean;
-    host?: string;
-    outputPath: string;
-    port?: number;
-    schemaPath?: string;
-}): Promise<Record<string, unknown>>;
+export declare const createOpenapi: ({ database, files, host, maxPageSize, port, schema }: {
+    database: any;
+    files: any;
+    host?: string | undefined;
+    maxPageSize: any;
+    port?: number | undefined;
+    schema: any;
+}) => Record<string, unknown>;
+export declare const writeOpenapi: (document: any, outputPath: any) => Promise<void>;

package/types/src/query/pagination.d.ts

@@ -4,10 +4,5 @@ export declare const parsePagination: (query: any, maxPageSize?: number) => {
 };
 export declare const paginateItems: (items: any, page: any, pageSize: any) => {
     data: any;
-    first: number;
-    items: any;
-    last: number;
-    next: any;
-    pages: number;
-    prev: number | null;
+    total: any;
 };