@dyrected/core 2.6.2 → 2.6.4

package/dist/utils/openapi.js

@@ -0,0 +1,981 @@
+function getCollectionLabels(collection) {
+    return (collection.labels || { singular: collection.slug, plural: collection.slug });
+}
+function getCollectionTag(collection) {
+    return `Collection: ${getCollectionLabels(collection).plural}`;
+}
+function getGlobalTag(global) {
+    return `Global: ${global.label || global.slug}`;
+}
+/**
+ * Generate an OpenAPI 3.0 specification based on the Dyrected configuration.
+ */
+export function generateOpenApi(config) {
+    const spec = {
+        openapi: "3.0.0",
+        info: {
+            title: "Dyrected API",
+            version: "1.0.0",
+            description: "Automatically generated OpenAPI specification for the Dyrected project.",
+        },
+        components: {
+            schemas: {
+                WorkflowMetadata: {
+                    type: "object",
+                    required: ["state", "revision"],
+                    properties: {
+                        state: { type: "string" },
+                        revision: { type: "integer", minimum: 1 },
+                        publishedRevision: { type: "integer", minimum: 1 },
+                        publishedAt: { type: "string", format: "date-time" },
+                        publishedBy: { type: "string" },
+                        availableTransitions: { type: "array", items: { type: "string" } },
+                    },
+                },
+                WorkflowTransitionRequest: {
+                    type: "object",
+                    properties: {
+                        expectedRevision: { type: "integer", minimum: 1 },
+                        comment: { type: "string" },
+                    },
+                },
+                WorkflowHistoryEntry: {
+                    type: "object",
+                    required: [
+                        "collection",
+                        "documentId",
+                        "transition",
+                        "from",
+                        "to",
+                        "revision",
+                        "createdAt",
+                    ],
+                    properties: {
+                        id: { type: "string" },
+                        collection: { type: "string" },
+                        documentId: { type: "string" },
+                        transition: { type: "string" },
+                        from: { type: "string" },
+                        to: { type: "string" },
+                        revision: { type: "integer" },
+                        comment: { type: "string", nullable: true },
+                        actorId: { type: "string", nullable: true },
+                        createdAt: { type: "string", format: "date-time" },
+                    },
+                },
+                AuditEntry: {
+                    type: "object",
+                    required: ["collection", "operation", "timestamp"],
+                    properties: {
+                        id: { type: "string" },
+                        collection: { type: "string" },
+                        documentId: { type: "string", nullable: true },
+                        operation: { type: "string" },
+                        user: { type: "string", nullable: true },
+                        timestamp: { type: "string", format: "date-time" },
+                        changes: {
+                            oneOf: [
+                                { type: "string" },
+                                { type: "object", additionalProperties: true },
+                                { type: "null" },
+                            ],
+                        },
+                    },
+                },
+                Error: {
+                    type: "object",
+                    properties: {
+                        message: { type: "string" },
+                        errors: {
+                            type: "array",
+                            items: { type: "object", additionalProperties: true },
+                        },
+                    },
+                },
+                AuthCredentials: {
+                    type: "object",
+                    required: ["email", "password"],
+                    properties: {
+                        email: { type: "string", format: "email" },
+                        password: { type: "string" },
+                    },
+                },
+                TokenResponse: {
+                    type: "object",
+                    properties: {
+                        token: { type: "string" },
+                        user: { type: "object", additionalProperties: true },
+                    },
+                },
+            },
+            securitySchemes: {
+                ApiKeyAuth: {
+                    type: "apiKey",
+                    in: "header",
+                    name: "x-api-key",
+                },
+            },
+        },
+        paths: {},
+        security: [{ ApiKeyAuth: [] }],
+    };
+    spec.paths["/api/schemas"] = {
+        get: {
+            tags: ["System"],
+            summary: "Get the serialized Dyrected schema",
+            security: [],
+            responses: {
+                200: { description: "Collection and global schema definitions" },
+            },
+        },
+    };
+    spec.paths["/api/openapi.json"] = {
+        get: {
+            tags: ["System"],
+            summary: "Get the OpenAPI specification",
+            security: [],
+            responses: { 200: { description: "OpenAPI 3.0 document" } },
+        },
+    };
+    spec.paths["/api/docs"] = {
+        get: {
+            tags: ["System"],
+            summary: "Open interactive API documentation",
+            security: [],
+            responses: { 200: { description: "Swagger UI HTML" } },
+        },
+    };
+    spec.paths["/api/dyrected/options/{collection}/{field}"] = {
+        get: {
+            tags: ["System"],
+            summary: "Resolve dynamic field options",
+            parameters: [
+                {
+                    name: "collection",
+                    in: "path",
+                    required: true,
+                    schema: { type: "string" },
+                },
+                {
+                    name: "field",
+                    in: "path",
+                    required: true,
+                    schema: { type: "string" },
+                },
+            ],
+            responses: { 200: { description: "Resolved option items" } },
+        },
+    };
+    spec.paths["/api/preferences/{key}"] = {
+        get: {
+            tags: ["Preferences"],
+            summary: "Get an authenticated user preference",
+            parameters: [
+                { name: "key", in: "path", required: true, schema: { type: "string" } },
+            ],
+            responses: { 200: { description: "Preference value" } },
+        },
+        put: {
+            tags: ["Preferences"],
+            summary: "Set an authenticated user preference",
+            parameters: [
+                { name: "key", in: "path", required: true, schema: { type: "string" } },
+            ],
+            requestBody: {
+                required: true,
+                content: { "application/json": { schema: { type: "object" } } },
+            },
+            responses: { 200: { description: "Updated preference" } },
+        },
+    };
+    spec.paths["/api/preview-token"] = {
+        post: {
+            tags: ["Preview"],
+            summary: "Create a preview token",
+            responses: { 200: { description: "Short-lived preview token" } },
+        },
+    };
+    spec.paths["/api/preview-data"] = {
+        get: {
+            tags: ["Preview"],
+            summary: "Resolve preview data from a token",
+            security: [],
+            parameters: [
+                {
+                    name: "token",
+                    in: "query",
+                    required: true,
+                    schema: { type: "string" },
+                },
+            ],
+            responses: { 200: { description: "Preview document data" } },
+        },
+    };
+    spec.paths["/api/audit"] = {
+        get: {
+            tags: ["Audit"],
+            summary: "Get audit entries across all readable audited collections",
+            parameters: [
+                {
+                    name: "limit",
+                    in: "query",
+                    schema: { type: "integer", default: 50, maximum: 100 },
+                },
+                { name: "page", in: "query", schema: { type: "integer", default: 1 } },
+                {
+                    name: "where",
+                    in: "query",
+                    schema: { type: "string" },
+                    description: "JSON filter",
+                },
+                {
+                    name: "sort",
+                    in: "query",
+                    schema: { type: "string", default: "-timestamp" },
+                },
+            ],
+            responses: {
+                200: {
+                    description: "Audit entries",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    docs: {
+                                        type: "array",
+                                        items: { $ref: "#/components/schemas/AuditEntry" },
+                                    },
+                                    total: { type: "integer" },
+                                    limit: { type: "integer" },
+                                    page: { type: "integer" },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    // 1. Generate Schemas for Collections
+    for (const collection of config.collections) {
+        spec.components.schemas[collection.slug] = collectionToSchema(collection);
+    }
+    // 2. Generate Schemas for Globals
+    for (const global of config.globals) {
+        spec.components.schemas[global.slug] = globalToSchema(global);
+    }
+    // 3. Generate Paths for Collections
+    for (const collection of config.collections) {
+        const slug = collection.slug;
+        const path = `/api/collections/${slug}`;
+        const labels = getCollectionLabels(collection);
+        const collectionTag = getCollectionTag(collection);
+        spec.paths[path] = {
+            get: {
+                tags: [collectionTag],
+                summary: `Find ${labels.plural}`,
+                parameters: [
+                    {
+                        name: "limit",
+                        in: "query",
+                        schema: { type: "integer", default: 10 },
+                    },
+                    {
+                        name: "page",
+                        in: "query",
+                        schema: { type: "integer", default: 1 },
+                    },
+                    {
+                        name: "where",
+                        in: "query",
+                        schema: { type: "string" },
+                        description: "JSON filter",
+                    },
+                    {
+                        name: "search",
+                        in: "query",
+                        schema: { type: "string" },
+                        description: "Free-text search across configured searchable fields",
+                    },
+                    {
+                        name: "sort",
+                        in: "query",
+                        schema: { type: "string" },
+                        description: "Sort field (e.g. -createdAt)",
+                    },
+                ],
+                responses: {
+                    200: {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        docs: {
+                                            type: "array",
+                                            items: { $ref: `#/components/schemas/${slug}` },
+                                        },
+                                        total: { type: "integer" },
+                                        limit: { type: "integer" },
+                                        page: { type: "integer" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            post: {
+                tags: [collectionTag],
+                summary: `Create ${labels.singular}`,
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: { $ref: `#/components/schemas/${slug}` },
+                        },
+                    },
+                },
+                responses: {
+                    201: {
+                        description: "Created",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${slug}` },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        spec.paths[`${path}/{id}`] = {
+            get: {
+                tags: [collectionTag],
+                summary: `Get a single ${labels.singular}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                    },
+                ],
+                responses: {
+                    200: {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${slug}` },
+                            },
+                        },
+                    },
+                },
+            },
+            patch: {
+                tags: [collectionTag],
+                summary: `Update ${labels.singular}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                    },
+                ],
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: { $ref: `#/components/schemas/${slug}` },
+                        },
+                    },
+                },
+                responses: {
+                    200: {
+                        description: "Updated",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${slug}` },
+                            },
+                        },
+                    },
+                },
+            },
+            delete: {
+                tags: [collectionTag],
+                summary: `Delete ${labels.singular}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                    },
+                ],
+                responses: {
+                    204: { description: "Deleted" },
+                },
+            },
+        };
+        spec.paths[`${path}/delete-many`] = {
+            delete: {
+                tags: [collectionTag],
+                summary: `Delete multiple ${labels.plural}`,
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                required: ["ids"],
+                                properties: {
+                                    ids: { type: "array", items: { type: "string" } },
+                                },
+                            },
+                        },
+                    },
+                },
+                responses: { 200: { description: "Deleted and failed document IDs" } },
+            },
+        };
+        if (collection.audit) {
+            spec.paths[`${path}/__audit`] = {
+                get: {
+                    tags: [collectionTag],
+                    summary: `Get ${labels.singular} audit entries`,
+                    parameters: [
+                        {
+                            name: "limit",
+                            in: "query",
+                            schema: { type: "integer", default: 50, maximum: 100 },
+                        },
+                        {
+                            name: "page",
+                            in: "query",
+                            schema: { type: "integer", default: 1 },
+                        },
+                        {
+                            name: "where",
+                            in: "query",
+                            schema: { type: "string" },
+                            description: "JSON filter",
+                        },
+                        {
+                            name: "sort",
+                            in: "query",
+                            schema: { type: "string", default: "-timestamp" },
+                        },
+                    ],
+                    responses: {
+                        200: {
+                            description: "Audit entries for this collection",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            docs: {
+                                                type: "array",
+                                                items: { $ref: "#/components/schemas/AuditEntry" },
+                                            },
+                                            total: { type: "integer" },
+                                            limit: { type: "integer" },
+                                            page: { type: "integer" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        403: { description: "Collection read access denied" },
+                        404: { description: "Audit is not enabled for this collection" },
+                    },
+                },
+            };
+        }
+        if (collection.upload) {
+            spec.paths[`${path}/media`] = {
+                get: {
+                    tags: [collectionTag],
+                    summary: `List ${labels.plural}`,
+                    responses: { 200: { description: "Paginated media documents" } },
+                },
+                post: {
+                    tags: [collectionTag],
+                    summary: `Upload ${labels.singular}`,
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "multipart/form-data": {
+                                schema: {
+                                    type: "object",
+                                    required: ["file"],
+                                    properties: { file: { type: "string", format: "binary" } },
+                                },
+                            },
+                        },
+                    },
+                    responses: { 201: { description: "Uploaded media document" } },
+                },
+            };
+            spec.paths[`${path}/media/{filename}`] = {
+                get: {
+                    tags: [collectionTag],
+                    summary: `Serve ${labels.singular} bytes`,
+                    parameters: [
+                        {
+                            name: "filename",
+                            in: "path",
+                            required: true,
+                            schema: { type: "string" },
+                        },
+                    ],
+                    security: [],
+                    responses: {
+                        200: { description: "Stored file" },
+                        404: { description: "File not found" },
+                    },
+                },
+            };
+        }
+        if (collection.auth) {
+            const publicAuthPost = (summary) => ({
+                tags: [collectionTag],
+                summary,
+                security: [],
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: { type: "object", additionalProperties: true },
+                        },
+                    },
+                },
+                responses: {
+                    200: { description: "Success" },
+                    400: { description: "Invalid request" },
+                },
+            });
+            spec.paths[`${path}/login`] = {
+                post: {
+                    ...publicAuthPost(`Log in to ${labels.plural}`),
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/AuthCredentials" },
+                            },
+                        },
+                    },
+                    responses: {
+                        200: {
+                            description: "Authenticated",
+                            content: {
+                                "application/json": {
+                                    schema: { $ref: "#/components/schemas/TokenResponse" },
+                                },
+                            },
+                        },
+                        401: { description: "Invalid credentials" },
+                    },
+                },
+            };
+            spec.paths[`${path}/logout`] = {
+                post: {
+                    tags: [collectionTag],
+                    summary: `Log out of ${labels.plural}`,
+                    parameters: [
+                        {
+                            name: "allSessions",
+                            in: "query",
+                            required: false,
+                            schema: { type: "boolean" },
+                            description: "Revoke every active session for this account instead of only the current one.",
+                        },
+                    ],
+                    responses: { 200: { description: "Logged out" } },
+                },
+            };
+            spec.paths[`${path}/init`] = {
+                get: {
+                    tags: [collectionTag],
+                    summary: `Get ${labels.plural} initialization state`,
+                    security: [],
+                    responses: { 200: { description: "Initialization state" } },
+                },
+            };
+            spec.paths[`${path}/first-user`] = {
+                post: publicAuthPost(`Register the first ${labels.singular}`),
+            };
+            spec.paths[`${path}/me`] = {
+                get: {
+                    tags: [collectionTag],
+                    summary: `Get the current ${labels.singular}`,
+                    responses: { 200: { description: "Authenticated user" } },
+                },
+            };
+            spec.paths[`${path}/refresh-token`] = {
+                post: {
+                    tags: [collectionTag],
+                    summary: "Refresh an authentication token",
+                    responses: {
+                        200: {
+                            description: "Refreshed token for the current active session",
+                        },
+                    },
+                },
+            };
+            spec.paths[`${path}/forgot-password`] = {
+                post: publicAuthPost("Request a password reset"),
+            };
+            spec.paths[`${path}/reset-password`] = {
+                post: publicAuthPost("Reset a password"),
+            };
+            spec.paths[`${path}/invite`] = {
+                post: {
+                    tags: [collectionTag],
+                    summary: `Invite a ${labels.singular}`,
+                    responses: { 200: { description: "Invitation sent" } },
+                },
+            };
+            spec.paths[`${path}/accept-invite`] = {
+                post: publicAuthPost("Accept an invitation"),
+            };
+            spec.paths[`${path}/{id}/change-password`] = {
+                post: {
+                    tags: [collectionTag],
+                    summary: `Change a ${labels.singular} password`,
+                    parameters: [
+                        {
+                            name: "id",
+                            in: "path",
+                            required: true,
+                            schema: { type: "string" },
+                        },
+                    ],
+                    responses: {
+                        200: {
+                            description: "Password changed and active sessions revoked",
+                        },
+                    },
+                },
+            };
+        }
+        if (collection.workflow) {
+            spec.paths[`${path}/{id}/transitions/{transition}`] = {
+                post: {
+                    tags: [collectionTag],
+                    summary: `Transition ${labels.singular} workflow`,
+                    parameters: [
+                        {
+                            name: "id",
+                            in: "path",
+                            required: true,
+                            schema: { type: "string" },
+                        },
+                        {
+                            name: "transition",
+                            in: "path",
+                            required: true,
+                            schema: {
+                                type: "string",
+                                enum: collection.workflow.transitions.map((item) => item.name),
+                            },
+                        },
+                    ],
+                    requestBody: {
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: "#/components/schemas/WorkflowTransitionRequest",
+                                },
+                            },
+                        },
+                    },
+                    responses: {
+                        200: {
+                            description: "Transition applied",
+                            content: {
+                                "application/json": {
+                                    schema: { $ref: `#/components/schemas/${slug}` },
+                                },
+                            },
+                        },
+                        400: { description: "Required transition input is missing" },
+                        403: { description: "Transition capability denied" },
+                        409: { description: "Invalid state or stale revision" },
+                    },
+                },
+            };
+            spec.paths[`${path}/{id}/workflow-history`] = {
+                get: {
+                    tags: [collectionTag],
+                    summary: `Get ${labels.singular} workflow history`,
+                    parameters: [
+                        {
+                            name: "id",
+                            in: "path",
+                            required: true,
+                            schema: { type: "string" },
+                        },
+                        {
+                            name: "limit",
+                            in: "query",
+                            schema: { type: "integer", default: 50, maximum: 100 },
+                        },
+                    ],
+                    responses: {
+                        200: {
+                            description: "Workflow transition history",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            docs: {
+                                                type: "array",
+                                                items: {
+                                                    $ref: "#/components/schemas/WorkflowHistoryEntry",
+                                                },
+                                            },
+                                            total: { type: "integer" },
+                                            limit: { type: "integer" },
+                                            page: { type: "integer" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        403: { description: "Collection read access denied" },
+                    },
+                },
+            };
+        }
+    }
+    // 4. Generate Paths for Globals
+    for (const global of config.globals) {
+        const slug = global.slug;
+        const path = `/api/globals/${slug}`;
+        const globalTag = getGlobalTag(global);
+        spec.paths[path] = {
+            get: {
+                tags: [globalTag],
+                summary: `Get ${global.label || slug}`,
+                responses: {
+                    200: {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${slug}` },
+                            },
+                        },
+                    },
+                },
+            },
+            patch: {
+                tags: [globalTag],
+                summary: `Update ${global.label || slug}`,
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: { $ref: `#/components/schemas/${slug}` },
+                        },
+                    },
+                },
+                responses: {
+                    200: {
+                        description: "Updated",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${slug}` },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    // 5. Generate the storage-backed file serving path.
+    if (config.storage) {
+        spec.paths["/api/media/{filename}"] = {
+            get: {
+                tags: ["Media"],
+                summary: "Serve a stored file",
+                security: [],
+                parameters: [
+                    {
+                        name: "filename",
+                        in: "path",
+                        required: true,
+                        schema: { type: "string" },
+                    },
+                ],
+                responses: {
+                    200: { description: "Stored file bytes" },
+                    404: { description: "File not found" },
+                },
+            },
+        };
+    }
+    return spec;
+}
+function collectionToSchema(collection) {
+    const { properties, required } = fieldsToProperties(collection.fields);
+    return {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            createdAt: { type: "string", format: "date-time" },
+            updatedAt: { type: "string", format: "date-time" },
+            ...(collection.workflow
+                ? { _workflow: { $ref: "#/components/schemas/WorkflowMetadata" } }
+                : {}),
+            ...properties,
+        },
+        required: ["id", ...required],
+    };
+}
+function globalToSchema(global) {
+    const { properties, required } = fieldsToProperties(global.fields);
+    return {
+        type: "object",
+        properties,
+        required,
+    };
+}
+function fieldsToProperties(fields) {
+    const props = {};
+    const required = [];
+    for (const field of fields) {
+        if (field.type === "row") {
+            const nested = fieldsToProperties(field.fields || []);
+            Object.assign(props, nested.properties);
+            required.push(...nested.required);
+            continue;
+        }
+        if (!field.name)
+            continue;
+        props[field.name] = fieldToSchema(field);
+        if (field.required) {
+            required.push(field.name);
+        }
+    }
+    return { properties: props, required };
+}
+function fieldToSchema(field) {
+    let schema;
+    switch (field.type) {
+        case "text":
+        case "textarea":
+        case "email":
+            schema = { type: "string" };
+            break;
+        case "url":
+            schema = {
+                oneOf: [
+                    { type: "string" },
+                    { type: "object", additionalProperties: true },
+                ],
+            };
+            break;
+        case "icon":
+            schema = { type: "string" };
+            break;
+        case "number":
+            schema = { type: "number" };
+            break;
+        case "boolean":
+            schema = { type: "boolean" };
+            break;
+        case "date":
+            schema = { type: "string", format: "date" };
+            break;
+        case "datetime":
+            schema = { type: "string", format: "date-time" };
+            break;
+        case "time":
+            schema = { type: "string", format: "time" };
+            break;
+        case "select":
+        case "radio":
+            schema = {
+                type: "string",
+                enum: Array.isArray(field.options)
+                    ? field.options.map((o) => (typeof o === "string" ? o : o.value))
+                    : undefined,
+            };
+            break;
+        case "multiSelect":
+            schema = {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: Array.isArray(field.options)
+                        ? field.options.map((o) => (typeof o === "string" ? o : o.value))
+                        : undefined,
+                },
+            };
+            break;
+        case "relationship":
+        case "image": {
+            const valueSchema = {
+                type: "string",
+                description: `ID of a ${field.relationTo} record`,
+            };
+            schema = field.hasMany
+                ? { type: "array", items: valueSchema }
+                : valueSchema;
+            break;
+        }
+        case "join":
+            schema = {
+                type: "array",
+                readOnly: true,
+                items: { type: "object", additionalProperties: true },
+            };
+            break;
+        case "object": {
+            const { properties, required } = fieldsToProperties(field.fields || []);
+            schema = { type: "object", properties, required };
+            break;
+        }
+        case "array": {
+            const { properties, required } = fieldsToProperties(field.fields || []);
+            schema = {
+                type: "array",
+                items: { type: "object", properties, required },
+            };
+            break;
+        }
+        case "json":
+        case "richText":
+            schema = { type: "object", additionalProperties: true };
+            break;
+        case "blocks":
+            schema = {
+                type: "array",
+                items: {
+                    oneOf: field.blocks?.map((block) => {
+                        const { properties, required } = fieldsToProperties(block.fields);
+                        return {
+                            type: "object",
+                            properties: {
+                                blockType: { type: "string", enum: [block.slug] },
+                                ...properties,
+                            },
+                            required: ["blockType", ...required],
+                        };
+                    }),
+                },
+            };
+            break;
+        default:
+            schema = { type: "string" };
+    }
+    if (field.label)
+        schema.description = field.label;
+    return schema;
+}
+//# sourceMappingURL=openapi.js.map