@kollors/deep-json-server 0.9.0 → 1.0.0-alpha.10

package/dist/src/openapi/document.js

@@ -1,338 +1,307 @@
-import { DEFAULT_MAX_PAGE_SIZE, DEFAULT_PAGE_SIZE } from '../constants.js';
-import { validateDatabase } from '../database.js';
-import { FILE_HEADERS, FILE_METADATA_SCHEMA, FILE_ROUTES, FILE_UPDATE_SCHEMA } from '../files/contract.js';
-import { getRelationMetadata } from '../relation-metadata.js';
-import { getResourceNames, isObject, singularize, toPascalCase } from '../utils.js';
-import { applyConfiguredFields, normalizeSchemaConfig } from './config.js';
-import { ensureGeneratedIdSchema, inferObjectSchema, mergeSchemaOverrides, omitId } from './inference.js';
-const createSchemaReference = (name) => ({ $ref: `#/components/schemas/${name}` });
-const addForwardRelations = (schema, resources, componentNames, sourceResource) => {
-    if (Array.isArray(schema.oneOf)) {
-        return { ...schema, oneOf: schema.oneOf.map((nestedSchema) => addForwardRelations(nestedSchema, resources, componentNames, sourceResource)) };
+import { VERSION } from '../core/constants.js';
+import { assertApi, canonicalNode, nodeName, objectSchema, operationName, relationInputSchema, valueSchema } from '../core/model.js';
+import { MUTATIONS } from '../core/operations.js';
+import { normalizePagination } from '../core/pagination.js';
+import { operatorsFor } from '../core/query/contract.js';
+import { sortableFields } from '../core/query/options.js';
+import { capitalize, isObject } from '../core/utils.js';
+import { FILE_HEADERS, FILE_METADATA_SCHEMA, FILE_UPDATE_SCHEMA } from '../files/http.js';
+import { AUTH_SCHEMAS, AUTH_SECURITY_SCHEMES, authOpenapiPaths } from './auth.js';
+import { createFilePaths } from './files.js';
+import { json, ref, response } from './helpers.js';
+/** Преобразует nullable-значения JSON Schema в представление OpenAPI 3.0, рекурсивно обрабатывая поля и элементы.
+ * @example { anyOf: [{ type: 'string' }, { type: 'null' }] } → { type: 'string', nullable: true }.
+ */
+function toOpenapi(schema) {
+    if (Array.isArray(schema.anyOf) && schema.anyOf.some((v) => isObject(v) && v.type === 'null')) {
+        const nonNull = schema.anyOf.find((v) => isObject(v) && v.type !== 'null');
+        const converted = toOpenapi(nonNull);
+        if (!converted.type)
+            return { anyOf: [converted, { type: 'object', nullable: true, enum: [null] }] };
+        return { ...converted, nullable: true, ...(converted.enum ? { enum: [...converted.enum.filter((value) => value !== null), null] } : {}) };
     }
-    if (schema.type === 'array') {
-        return { ...schema, items: addForwardRelations(schema.items ?? {}, resources, componentNames, sourceResource) };
+    const result = { ...schema };
+    if (isObject(schema.properties))
+        result.properties = Object.fromEntries(Object.entries(schema.properties).map(([k, v]) => [k, toOpenapi(v)]));
+    if (isObject(schema.items))
+        result.items = toOpenapi(schema.items);
+    return result;
+}
+/** Строит документ с маршрутами и схемами записей, включая выбранные дополнительные маршруты.
+ * @example { model, files: true } → документ с paths['/_files/storage'].
+ */
+export function buildOpenapiDocument({ model, files = false, auth = false, pageSize, maxPageSize, info = { title: 'Deep JSON Server API', version: VERSION }, }) {
+    assertApi(model, 'openapi');
+    ({ pageSize, maxPageSize } = normalizePagination({ pageSize, maxPageSize }));
+    const schemas = {
+        Error: { type: 'object', properties: { error: { type: 'string' } }, required: ['error'] },
+        Pager: {
+            type: 'object',
+            additionalProperties: false,
+            properties: { page: { type: 'integer', minimum: 1, default: 1 }, pageSize: { type: 'integer', minimum: 1, maximum: maxPageSize, default: pageSize } },
+        },
+    };
+    const owners = new Map();
+    function reserve(name, node) {
+        if (owners.get(name) === node)
+            return false;
+        if (schemas[name])
+            throw new Error(`OpenAPI schema name collision: ${name}`);
+        owners.set(name, node);
+        schemas[name] = {};
+        return true;
     }
-    if (schema.type !== 'object' || !isObject(schema.properties)) {
+    function annotate(schema, node) {
+        for (const key of ['description', 'example', 'default', 'readOnly', 'writeOnly'])
+            if (node[key] !== undefined)
+                schema[key] = node[key];
+        if (node.generated)
+            schema.readOnly = true;
         return schema;
     }
-    const properties = Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, addForwardRelations(value, resources, componentNames, sourceResource)]));
-    Object.keys(schema.properties).forEach((key) => {
-        const relation = getRelationMetadata(key, resources, sourceResource);
-        if (relation != null) {
-            const relationSchema = createSchemaReference(componentNames[relation.targetResource]);
-            properties[relation.relationName] = relation.isMany ? { items: relationSchema, type: 'array' } : relationSchema;
+    function baseField(node) {
+        return annotate(toOpenapi(valueSchema(node)), node);
+    }
+    function annotateInput(schema, node, defaults) {
+        for (const [key, property] of Object.entries(schema.properties ?? {})) {
+            const child = node.children[key];
+            for (const attribute of ['description', 'example', 'writeOnly'])
+                if (child[attribute] !== undefined)
+                    property[attribute] = child[attribute];
+            if (defaults && child.default !== undefined)
+                property.default = child.default;
+            if (!child.relation && child.base === 'object')
+                annotateInput(child.many ? property.items : property, child, defaults);
         }
-    });
-    return { ...schema, properties };
-};
-const collectRelations = (schema, resources, sourceResource, relations = []) => {
-    if (Array.isArray(schema.oneOf)) {
-        schema.oneOf.forEach((nestedSchema) => {
-            collectRelations(nestedSchema, resources, sourceResource, relations);
-        });
-        return relations;
+        return schema;
+    }
+    function writeInput(node, mode, root = false, nestedMode = mode) {
+        return annotateInput(toOpenapi(objectSchema(node, mode, root, (child) => relationInputSchema(child, nestedInput(child.relation, nestedMode)))), node, mode !== 'update');
     }
-    if (schema.type === 'array') {
-        collectRelations(schema.items ?? {}, resources, sourceResource, relations);
-        return relations;
+    function nestedInput(entity, mode) {
+        const name = `${entity.name}Nested${capitalize(mode)}`;
+        if (!reserve(name, entity.root))
+            return ref(name);
+        const existing = writeInput(entity.root, mode === 'replace' ? 'replace' : 'update', true, mode);
+        existing.properties ??= {};
+        existing.properties[entity.primary] = toOpenapi(valueSchema(entity.fields[entity.primary]));
+        existing.required = [...(existing.required ?? []), entity.primary];
+        const variants = [existing];
+        if (entity.fields[entity.primary].generated)
+            variants.push(writeInput(entity.root, 'create', true, mode));
+        schemas[name] = { anyOf: variants, description: 'An object with a primary key updates an existing record; an object without a key creates one. PUT replaces, PATCH updates supplied fields.' };
+        return ref(name);
     }
-    if (schema.type !== 'object' || !isObject(schema.properties)) {
-        return relations;
+    function output(entity, node) {
+        [entity, node] = canonicalNode(entity, node);
+        const name = nodeName(entity, node);
+        if (!reserve(name, node))
+            return ref(name);
+        const properties = {};
+        for (const [key, child] of Object.entries(node.children)) {
+            if (child.writeOnly)
+                continue;
+            if (child.relation || child.base === 'object') {
+                const value = child.many ? page(entity, child) : output(entity, child);
+                const shape = child.nullable || (child.relation && !child.many && !child.required) ? { anyOf: [value, { type: 'object', nullable: true, enum: [null] }] } : value;
+                const attributes = annotate({}, child);
+                properties[key] = Object.keys(attributes).length ? { allOf: [shape], ...attributes } : shape;
+            }
+            else
+                properties[key] = baseField(child);
+        }
+        // Выбор может содержать любую часть полей, поэтому поля ответа необязательны.
+        schemas[name] = { type: 'object', additionalProperties: false, properties };
+        return ref(name);
     }
-    Object.entries(schema.properties).forEach(([key, value]) => {
-        const relation = getRelationMetadata(key, resources, sourceResource);
-        if (relation != null) {
-            relations.push(relation);
+    function scope(entity, node, list = node.many) {
+        [entity, node] = canonicalNode(entity, node);
+        const name = `${nodeName(entity, node)}${list ? 'List' : ''}Scope`;
+        if (!reserve(name, node))
+            return ref(name);
+        const fieldsName = `${nodeName(entity, node)}ScopeFields`;
+        if (reserve(fieldsName, node)) {
+            const included = { type: 'boolean', enum: [true] };
+            const properties = { '*': included };
+            for (const [key, child] of Object.entries(node.children)) {
+                if (child.writeOnly)
+                    continue;
+                properties[key] = child.relation || child.base === 'object' ? scope(entity, child) : included;
+            }
+            schemas[fieldsName] = { type: 'object', additionalProperties: false, properties };
         }
-        collectRelations(value, resources, sourceResource, relations);
-    });
-    return relations;
-};
-const addReverseRelations = (schemas, rawSchemas, resources, componentNames) => {
-    resources.forEach((sourceResource) => {
-        collectRelations(rawSchemas[sourceResource], resources, sourceResource).forEach(({ reverseRelationName, targetResource }) => {
-            const targetComponentName = componentNames[targetResource];
-            const targetSchema = schemas[targetComponentName];
-            if (targetSchema.type === 'object' && isObject(targetSchema.properties) && !Object.hasOwn(targetSchema.properties, reverseRelationName)) {
-                schemas[targetComponentName] = {
-                    ...targetSchema,
-                    properties: {
-                        ...targetSchema.properties,
-                        [reverseRelationName]: { items: createSchemaReference(componentNames[sourceResource]), type: 'array' },
-                    },
-                };
+        schemas[name] = {
+            type: 'array',
+            minItems: 1,
+            maxItems: list ? 2 : 1,
+            items: list ? { anyOf: [ref(fieldsName), options(entity, node)] } : ref(fieldsName),
+            description: list
+                ? '[fields, arguments?]. The first object selects fields; the optional second object contains where, order and pager. OpenAPI 3.0 cannot express positional item schemas; the server validates their order.'
+                : '[fields]. * selects own fields without relations or writeOnly fields.',
+        };
+        return ref(name);
+    }
+    function page(entity, node) {
+        [entity, node] = canonicalNode(entity, node);
+        const name = `${nodeName(entity, node)}Page`;
+        if (reserve(name, node))
+            schemas[name] = { type: 'object', required: ['data', 'total'], properties: { data: { type: 'array', items: output(entity, node) }, total: { type: 'integer', minimum: 0 } } };
+        return ref(name);
+    }
+    function where(entity, node) {
+        [entity, node] = canonicalNode(entity, node);
+        const name = `${nodeName(entity, node)}Where`;
+        if (!reserve(name, node))
+            return ref(name);
+        const properties = { and: { type: 'array', items: ref(name) }, or: { type: 'array', minItems: 1, items: ref(name) }, not: ref(name) };
+        for (const [key, child] of Object.entries(node.children))
+            if (!child.writeOnly) {
+                if (Object.hasOwn(properties, key))
+                    throw new Error(`Reserved filter field: ${entity.name}.${child.path}`);
+                properties[key] = !child.many && (child.relation || child.base === 'object') ? where(entity, child) : filter(entity, child);
             }
+        schemas[name] = { type: 'object', additionalProperties: false, properties };
+        return ref(name);
+    }
+    function filter(entity, node) {
+        const name = `${nodeName(entity, node)}Filter`;
+        if (!reserve(name, node))
+            return ref(name);
+        const properties = {};
+        const element = node.many ? (node.relation || node.base === 'object' ? where(entity, node) : filter(entity, { ...node, many: false, path: `${node.path}_element` })) : undefined;
+        for (const [key, operand] of Object.entries(operatorsFor(node))) {
+            const nullable = ['eq', 'ne', 'in'].includes(key);
+            const scalar = {
+                type: node.base,
+                ...(nullable ? { nullable: true } : {}),
+                ...(node.enum ? { enum: [...node.enum, ...(nullable && !node.enum.includes(null) ? [null] : [])] } : {}),
+            };
+            if (operand === 'condition')
+                properties[key] = ref(name);
+            else if (operand === 'element')
+                properties[key] = element;
+            else
+                properties[key] =
+                    operand === 'values' ? { type: 'array', items: scalar } : operand === 'text' ? { type: 'string' } : operand === 'comparison' ? { type: node.base } : scalar;
+        }
+        schemas[name] = { type: 'object', additionalProperties: false, properties };
+        return ref(name);
+    }
+    function order(entity, node) {
+        [entity, node] = canonicalNode(entity, node);
+        const name = `${nodeName(entity, node)}Order`;
+        if (reserve(name, node)) {
+            const paths = sortableFields(node);
+            schemas[name] = {
+                type: 'array',
+                ...(paths.length
+                    ? {
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            required: ['field', 'direction'],
+                            properties: { field: { type: 'string', enum: paths }, direction: { type: 'string', enum: ['ASC', 'DESC'] } },
+                        },
+                    }
+                    : { maxItems: 0, items: { type: 'object' } }),
+            };
+        }
+        return ref(name);
+    }
+    function options(entity, node) {
+        return { type: 'object', additionalProperties: false, properties: { where: where(entity, node), order: order(entity, node), pager: ref('Pager') } };
+    }
+    const paths = {};
+    const operations = new Set();
+    for (const entity of model.entities.filter((e) => e.api.includes('openapi'))) {
+        const name = entity.name;
+        const op = operationName(entity);
+        for (const { mode, hasBody } of MUTATIONS) {
+            if (!hasBody)
+                continue;
+            const key = `${name}${capitalize(mode)}`;
+            reserve(key, entity.root);
+            schemas[key] = writeInput(entity.root, mode, true);
+        }
+        const selectionParameter = (list) => ({
+            in: 'query',
+            name: 'scope',
+            ...json(scope(entity, entity.root, list)),
+            description: 'JSON [fields, arguments?]. Scalars use true; objects and relations use their own scope arrays. * includes own fields without relations or writeOnly fields. Arguments are available only on lists.',
         });
-    });
-};
-const createParameters = (maxPageSize) => ({
-    ContentDirectory: { description: 'URI-encoded relative storage directory', in: 'header', name: FILE_HEADERS.directory.name, schema: { type: 'string' } },
-    ContentName: { description: 'URI-encoded file name', in: 'header', name: FILE_HEADERS.name.name, required: true, schema: { type: 'string' } },
-    ContentOverride: {
-        description: 'Overwrite an existing file at the same path',
-        in: 'header',
-        name: FILE_HEADERS.override.name,
-        schema: { default: 'false', enum: ['false', 'true'], type: 'string' },
-    },
-    Embed: { description: 'Relationship paths to embed', explode: true, in: 'query', name: '_embed', schema: { items: { type: 'string' }, type: 'array' }, style: 'form' },
-    FilePath: { description: 'Percent-encoded file path relative to the storage directory', in: 'path', name: 'path', required: true, schema: { type: 'string' } },
-    Id: { in: 'path', name: 'id', required: true, schema: { type: 'string' } },
-    Page: { in: 'query', name: '_page', required: false, schema: { default: 1, minimum: 1, type: 'integer' } },
-    PerPage: { in: 'query', name: '_perPage', required: false, schema: { default: DEFAULT_PAGE_SIZE, maximum: maxPageSize, minimum: 1, type: 'integer' } },
-    Sort: { description: 'Comma-separated fields; prefix with - for descending order', in: 'query', name: '_sort', schema: { type: 'string' } },
-    Where: { description: 'JSON-encoded filter for nested data', in: 'query', name: '_where', schema: { type: 'string' } },
-});
-const createJsonContent = (schema) => ({ content: { 'application/json': { schema } } });
-const createResponse = (description, schema) => ({ description, ...(schema != null && createJsonContent(schema)) });
-const createErrorResponse = (description) => createResponse(description, createSchemaReference('Error'));
-const createParameterReference = (name) => ({ $ref: `#/components/parameters/${name}` });
-const createRequestBody = (name) => ({ required: true, ...createJsonContent(createSchemaReference(name)) });
-const createFilePaths = () => ({
-    [`${FILE_ROUTES.download}/{path}`]: {
-        get: {
-            operationId: 'downloadFile',
-            parameters: [createParameterReference('FilePath')],
-            responses: {
-                200: { content: { '*/*': { schema: { format: 'binary', type: 'string' } } }, description: 'File download' },
-                400: createErrorResponse('Invalid path'),
-                404: createErrorResponse('Not found'),
-            },
-            tags: ['files'],
-        },
-    },
-    [`${FILE_ROUTES.metadata}/{path}`]: {
-        get: {
-            operationId: 'getFileMetadata',
-            parameters: [createParameterReference('FilePath')],
-            responses: {
-                200: createResponse('File metadata', createSchemaReference('FileMetadata')),
-                400: createErrorResponse('Invalid path'),
-                404: createErrorResponse('Not found'),
-            },
-            tags: ['files'],
-        },
-    },
-    [FILE_ROUTES.storage]: {
-        post: {
-            operationId: 'uploadFile',
-            parameters: ['ContentName', 'ContentDirectory', 'ContentOverride'].map(createParameterReference),
-            requestBody: { content: { '*/*': { schema: { format: 'binary', type: 'string' } } }, required: true },
-            responses: {
-                200: createResponse('Overwritten', createSchemaReference('FileMetadata')),
-                201: createResponse('Created', createSchemaReference('FileMetadata')),
-                400: createErrorResponse('Invalid request'),
-                409: createErrorResponse('Already exists'),
-                413: createErrorResponse('File is too large'),
-                415: createErrorResponse('Unsupported media type'),
-            },
-            tags: ['files'],
-        },
-    },
-    [`${FILE_ROUTES.storage}/{path}`]: {
-        delete: {
-            operationId: 'deleteFile',
-            parameters: [createParameterReference('FilePath')],
-            responses: {
-                204: { description: 'Deleted' },
-                400: createErrorResponse('Invalid path'),
-                404: createErrorResponse('Not found'),
-            },
-            tags: ['files'],
-        },
-        get: {
-            operationId: 'getFileContent',
-            parameters: [createParameterReference('FilePath')],
-            responses: {
-                200: { content: { '*/*': { schema: { format: 'binary', type: 'string' } } }, description: 'File contents' },
-                400: createErrorResponse('Invalid path'),
-                404: createErrorResponse('Not found'),
-            },
-            tags: ['files'],
-        },
-        patch: {
-            operationId: 'updateFile',
-            parameters: [createParameterReference('FilePath')],
-            requestBody: createRequestBody('FileUpdate'),
-            responses: {
-                200: createResponse('Updated', createSchemaReference('FileMetadata')),
-                400: createErrorResponse('Invalid request'),
-                404: createErrorResponse('Not found'),
-                409: createErrorResponse('Already exists'),
-                413: createErrorResponse('Request is too large'),
-                415: createErrorResponse('Unsupported media type'),
-            },
-            tags: ['files'],
-        },
-    },
-});
-const createResourceOperationIds = (resource) => {
-    const resourceName = toPascalCase(resource);
-    return {
-        create: `post${resourceName}`,
-        get: `get${resourceName}ById`,
-        list: `get${resourceName}`,
-        remove: `delete${resourceName}ById`,
-        replace: `put${resourceName}ById`,
-        update: `patch${resourceName}ById`,
-    };
-};
-const createResourcePaths = (resource, componentName) => {
-    const operationIds = createResourceOperationIds(resource);
-    return {
-        [`/${resource}`]: {
-            get: {
-                operationId: operationIds.list,
-                parameters: ['Page', 'PerPage', 'Sort', 'Where', 'Embed'].map(createParameterReference),
-                responses: { 200: createResponse('Successful response', createSchemaReference(`${componentName}Page`)), 400: createErrorResponse('Invalid query') },
-                tags: [resource],
-            },
-            post: {
-                operationId: operationIds.create,
-                requestBody: createRequestBody(`${componentName}Create`),
-                responses: { 201: createResponse('Created', createSchemaReference(componentName)), 400: createErrorResponse('Invalid request') },
-                tags: [resource],
-            },
-        },
-        [`/${resource}/{id}`]: {
-            delete: {
-                operationId: operationIds.remove,
-                parameters: [createParameterReference('Id')],
-                responses: { 200: createResponse('Deleted', createSchemaReference(componentName)), 404: createErrorResponse('Not found') },
-                tags: [resource],
-            },
-            get: {
-                operationId: operationIds.get,
-                parameters: [createParameterReference('Id'), createParameterReference('Embed')],
+        const shape = [selectionParameter(false)];
+        const list = [selectionParameter(true)];
+        const key = { in: 'path', name: entity.primary, required: true, schema: baseField({ ...entity.fields[entity.primary], generated: undefined }) };
+        const errors = { 400: response('Invalid request', ref('Error')), 404: response('Not found', ref('Error')), 409: response('Conflict', ref('Error')) };
+        const make = (operationId, parameters, schema, mutation) => {
+            if (operations.has(operationId))
+                throw new Error(`OpenAPI operation collision: ${operationId}`);
+            operations.add(operationId);
+            return {
+                operationId,
+                tags: [entity.collection],
+                parameters,
+                ...(auth && mutation ? { security: [{ AuthBearer: [] }] } : {}),
+                ...(mutation?.hasBody ? { requestBody: { required: true, ...json(ref(`${name}${capitalize(mutation.mode)}`)) } } : {}),
                 responses: {
-                    200: createResponse('Successful response', createSchemaReference(componentName)),
-                    400: createErrorResponse('Invalid query'),
-                    404: createErrorResponse('Not found'),
+                    [mutation?.status ?? 200]: response('Success', schema),
+                    ...errors,
+                    ...(auth && mutation ? { 401: response('Authentication required', ref('Error')), 403: response('Forbidden', ref('Error')) } : {}),
                 },
-                tags: [resource],
-            },
-            patch: {
-                operationId: operationIds.update,
-                parameters: [createParameterReference('Id')],
-                requestBody: createRequestBody(`${componentName}Update`),
-                responses: {
-                    200: createResponse('Updated', createSchemaReference(componentName)),
-                    400: createErrorResponse('Invalid request'),
-                    404: createErrorResponse('Not found'),
-                },
-                tags: [resource],
-            },
-            put: {
-                operationId: operationIds.replace,
-                parameters: [createParameterReference('Id')],
-                requestBody: createRequestBody(`${componentName}Create`),
-                responses: {
-                    200: createResponse('Replaced', createSchemaReference(componentName)),
-                    400: createErrorResponse('Invalid request'),
-                    404: createErrorResponse('Not found'),
-                },
-                tags: [resource],
-            },
-        },
-    };
-};
-const validateGeneratedNames = (resources, componentNames, files) => {
-    const schemaOwners = new Map([
-        ['Error', 'встроенная схема ошибки'],
-        ...(files
-            ? [
-                ['FileMetadata', 'встроенная схема метаданных файла'],
-                ['FileUpdate', 'встроенная схема изменения файла'],
-            ]
-            : []),
-    ]);
-    resources.forEach((resource) => {
-        const componentName = componentNames[resource];
-        if (componentName === '') {
-            throw new Error(`Не удалось сформировать имя OpenAPI-схемы для ресурса «${resource}». Укажите $schema.${resource}.name`);
+            };
+        };
+        const collectionPath = `/${entity.collection}`;
+        const itemPath = `${collectionPath}/{${entity.primary}}`;
+        paths[collectionPath] = { get: make(`${op}List`, list, page(entity, entity.root)) };
+        paths[itemPath] = { get: make(op, [key, ...shape], output(entity, entity.root)) };
+        for (const mutation of MUTATIONS) {
+            paths[mutation.hasKey ? itemPath : collectionPath][mutation.method.toLowerCase()] = make(`${op}${capitalize(mutation.mode)}`, mutation.hasKey ? [key, ...shape] : shape, output(entity, entity.root), mutation);
         }
-        [componentName, `${componentName}Create`, `${componentName}Update`, `${componentName}Page`].forEach((schemaName) => {
-            const owner = schemaOwners.get(schemaName);
-            if (owner != null) {
-                throw new Error(`Имя OpenAPI-схемы «${schemaName}» используется ресурсами «${owner}» и «${resource}». Укажите уникальный $schema.${resource}.name`);
-            }
-            schemaOwners.set(schemaName, resource);
+    }
+    const parameters = {};
+    if (files) {
+        for (const [name, schema] of Object.entries({ FileMetadata: FILE_METADATA_SCHEMA, FileUpdate: FILE_UPDATE_SCHEMA })) {
+            if (schemas[name])
+                throw new Error(`OpenAPI schema collision: ${name}`);
+            schemas[name] = schema;
+        }
+        Object.assign(parameters, {
+            FilePath: { in: 'path', name: 'path', required: true, schema: { type: 'string' } },
+            ContentDirectory: { in: 'header', name: FILE_HEADERS.directory.name, schema: { type: 'string' } },
+            ContentName: { in: 'header', name: FILE_HEADERS.name.name, required: true, schema: { type: 'string' } },
+            ContentOverride: { in: 'header', name: FILE_HEADERS.override.name, schema: { type: 'string', enum: ['false', 'true'], default: 'false' } },
         });
-    });
-};
-const validateOperationIds = (paths) => {
-    const operationOwners = new Map();
-    Object.entries(paths).forEach(([path, pathItem]) => {
-        Object.entries(pathItem).forEach(([method, operation]) => {
-            if (!isObject(operation) || typeof operation.operationId !== 'string') {
-                return;
-            }
-            const owner = operationOwners.get(operation.operationId);
-            if (owner != null) {
-                throw new Error(`operationId «${operation.operationId}» используется операциями «${owner}» и «${method.toUpperCase()} ${path}»`);
+        for (const [path, item] of Object.entries(createFilePaths())) {
+            if (paths[path])
+                throw new Error(`File path collision: ${path}`);
+            for (const operation of Object.values(item)) {
+                if (isObject(operation) && typeof operation.operationId === 'string') {
+                    if (operations.has(operation.operationId))
+                        throw new Error(`OpenAPI operation collision: ${operation.operationId}`);
+                    operations.add(operation.operationId);
+                }
             }
-            operationOwners.set(operation.operationId, `${method.toUpperCase()} ${path}`);
-        });
-    });
-};
-/** Builds an OpenAPI document without runtime server addresses. */
-export function buildOpenapiDocument(options) {
-    const { database, files = false, maxPageSize = DEFAULT_MAX_PAGE_SIZE, schema: schemaConfig = {} } = options ?? {};
-    if (typeof files !== 'boolean') {
-        throw new Error('Ключ files должен содержать boolean');
-    }
-    validateDatabase(database);
-    if (!Number.isInteger(maxPageSize) || maxPageSize < 1) {
-        throw new Error('Максимальный размер страницы должен быть положительным целым числом');
+            paths[path] = item;
+        }
     }
-    if (!isObject(schemaConfig)) {
-        throw new Error('Схема базы данных должна содержать JSON-объект');
+    if (auth) {
+        for (const [name, schema] of Object.entries(AUTH_SCHEMAS)) {
+            if (schemas[name])
+                throw new Error(`OpenAPI schema collision: ${name}`);
+            schemas[name] = structuredClone(schema);
+        }
+        for (const [path, item] of Object.entries(authOpenapiPaths())) {
+            if (paths[path] || model.entities.some((entity) => path.startsWith(`/${entity.collection}/`)))
+                throw new Error(`Auth path collision: ${path}`);
+            for (const operation of Object.values(item)) {
+                const id = operation.operationId;
+                if (operations.has(id))
+                    throw new Error(`OpenAPI operation collision: ${id}`);
+                operations.add(id);
+            }
+            paths[path] = item;
+        }
     }
-    const resources = getResourceNames(database);
-    const resourceConfigs = normalizeSchemaConfig(schemaConfig, resources);
-    const componentNames = Object.fromEntries(resources.map((resource) => {
-        const resourceConfig = resourceConfigs[resource];
-        const componentName = resourceConfig.name ?? toPascalCase(singularize(resource));
-        return [resource, componentName];
-    }));
-    validateGeneratedNames(resources, componentNames, files);
-    const rawSchemas = Object.fromEntries(resources.map((resource) => {
-        const resourceConfig = resourceConfigs[resource];
-        const inferredSchema = database[resource].length === 0 ? { properties: { id: { type: 'string' } }, type: 'object' } : inferObjectSchema(database[resource]);
-        const configuredSchema = mergeSchemaOverrides(inferredSchema, { properties: resourceConfig.properties });
-        return [resource, applyConfiguredFields(ensureGeneratedIdSchema(configuredSchema), resource, resourceConfig)];
-    }));
-    const schemas = {
-        Error: { properties: { error: { type: 'string' } }, required: ['error'], type: 'object' },
-        ...(files && {
-            FileMetadata: FILE_METADATA_SCHEMA,
-            FileUpdate: FILE_UPDATE_SCHEMA,
-        }),
-    };
-    resources.forEach((resource) => {
-        const componentName = componentNames[resource];
-        const rawSchema = rawSchemas[resource];
-        schemas[componentName] = addForwardRelations(rawSchema, resources, componentNames, resource);
-        schemas[`${componentName}Create`] = omitId(rawSchema, true);
-        schemas[`${componentName}Update`] = omitId(rawSchema, false);
-        schemas[`${componentName}Page`] = {
-            properties: {
-                data: { items: createSchemaReference(componentName), type: 'array' },
-                total: { minimum: 0, type: 'integer' },
-            },
-            required: ['data', 'total'],
-            type: 'object',
-        };
-    });
-    addReverseRelations(schemas, rawSchemas, resources, componentNames);
-    const paths = Object.assign({}, ...resources.map((resource) => createResourcePaths(resource, componentNames[resource])), files ? createFilePaths() : {});
-    validateOperationIds(paths);
-    return {
-        components: { parameters: createParameters(maxPageSize), schemas },
-        info: isObject(schemaConfig.$info) ? schemaConfig.$info : { title: 'Deep JSON Server API', version: '1.0.0' },
-        openapi: '3.0.3',
-        paths,
-        tags: [...new Set([...resources, ...(files ? ['files'] : [])])].map((name) => ({ name })),
-    };
+    return { openapi: '3.0.3', info, components: { schemas, parameters, ...(auth ? { securitySchemes: structuredClone(AUTH_SECURITY_SCHEMES) } : {}) }, paths };
 }
 //# sourceMappingURL=document.js.map