@seshuk/payload-plugin-openapi 0.2.1 → 1.0.0-beta.1

package/dist/spec/paths/auth.js

@@ -1,274 +0,0 @@
-import { makeT } from "../../translations/index.js";
-import { ERRORS, errorResponses, jsonBody, jsonResponse, messageResponse } from "../components.js";
-import { refTo, schemaName } from "../names.js";
-import { authTagName } from "../tags.js";
-const identifierBody = (auth, extra = {})=>{
-    const email = {
-        type: 'string',
-        format: 'email'
-    };
-    const username = {
-        type: 'string'
-    };
-    const extraRequired = Object.keys(extra);
-    const loginWithUsername = auth?.loginWithUsername;
-    const base = {
-        type: 'object',
-        additionalProperties: false
-    };
-    if (!loginWithUsername) return {
-        ...base,
-        properties: {
-            email,
-            ...extra
-        },
-        required: [
-            'email',
-            ...extraRequired
-        ]
-    };
-    if ('object' == typeof loginWithUsername && loginWithUsername.allowEmailLogin) return {
-        ...base,
-        properties: {
-            email,
-            username,
-            ...extra
-        },
-        ...extraRequired.length > 0 ? {
-            required: extraRequired
-        } : {},
-        anyOf: [
-            {
-                required: [
-                    'email'
-                ]
-            },
-            {
-                required: [
-                    'username'
-                ]
-            }
-        ]
-    };
-    return {
-        ...base,
-        properties: {
-            username,
-            ...extra
-        },
-        required: [
-            'username',
-            ...extraRequired
-        ]
-    };
-};
-const buildAuthPaths = ({ collection, ctx, includeAdmin, nestedTags })=>{
-    const auth = collection.auth;
-    if (!auth || auth.disableLocalStrategy) return {};
-    const t = makeT(ctx.i18n);
-    const name = schemaName(collection.slug);
-    const base = `${ctx.apiRoute}/${collection.slug}`;
-    const tag = [
-        nestedTags ? authTagName(name) : name
-    ];
-    const userRef = {
-        $ref: refTo(name)
-    };
-    const op = (operationId, codes, extra)=>({
-            tags: tag,
-            operationId,
-            ...extra,
-            responses: {
-                ...extra.responses,
-                ...errorResponses(codes, t)
-            }
-        });
-    const paths = {
-        [`${base}/login`]: {
-            post: op(`login${name}`, ERRORS.login, {
-                requestBody: jsonBody(identifierBody(auth, {
-                    password: {
-                        type: 'string'
-                    }
-                })),
-                responses: {
-                    200: jsonResponse(t('authLogin'), {
-                        type: 'object',
-                        properties: {
-                            message: {
-                                type: 'string'
-                            },
-                            user: userRef,
-                            token: {
-                                type: 'string'
-                            },
-                            exp: {
-                                type: 'integer'
-                            }
-                        }
-                    })
-                }
-            })
-        },
-        [`${base}/logout`]: {
-            post: op(`logout${name}`, ERRORS.session, {
-                responses: messageResponse(t('authLogout'))
-            })
-        },
-        [`${base}/me`]: {
-            get: op(`me${name}`, ERRORS.session, {
-                responses: {
-                    200: jsonResponse(t('authMe'), {
-                        type: 'object',
-                        properties: {
-                            user: userRef,
-                            collection: {
-                                type: 'string'
-                            },
-                            token: {
-                                type: 'string'
-                            },
-                            exp: {
-                                type: 'integer'
-                            }
-                        }
-                    })
-                }
-            })
-        },
-        [`${base}/refresh-token`]: {
-            post: op(`refreshToken${name}`, ERRORS.session, {
-                responses: {
-                    200: jsonResponse(t('authRefreshToken'), {
-                        type: 'object',
-                        properties: {
-                            message: {
-                                type: 'string'
-                            },
-                            refreshedToken: {
-                                type: 'string'
-                            },
-                            exp: {
-                                type: 'integer'
-                            },
-                            user: userRef
-                        }
-                    })
-                }
-            })
-        },
-        [`${base}/forgot-password`]: {
-            post: op(`forgotPassword${name}`, ERRORS.authAction, {
-                requestBody: jsonBody(identifierBody(auth)),
-                responses: messageResponse(t('authForgotPassword'))
-            })
-        },
-        [`${base}/reset-password`]: {
-            post: op(`resetPassword${name}`, ERRORS.authAction, {
-                requestBody: jsonBody({
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        token: {
-                            type: 'string'
-                        },
-                        password: {
-                            type: 'string'
-                        }
-                    },
-                    required: [
-                        'token',
-                        'password'
-                    ]
-                }),
-                responses: {
-                    200: jsonResponse(t('authResetPassword'), {
-                        type: 'object',
-                        properties: {
-                            message: {
-                                type: 'string'
-                            },
-                            token: {
-                                type: 'string'
-                            },
-                            user: userRef
-                        }
-                    })
-                }
-            })
-        }
-    };
-    if (includeAdmin) {
-        paths[`${base}/first-register`] = {
-            post: op(`firstRegister${name}`, ERRORS.create, {
-                requestBody: jsonBody({
-                    $ref: refTo(`${name}Create`)
-                }),
-                responses: {
-                    200: jsonResponse(t('authFirstRegister'), {
-                        type: 'object',
-                        properties: {
-                            message: {
-                                type: 'string'
-                            },
-                            user: userRef,
-                            token: {
-                                type: 'string'
-                            },
-                            exp: {
-                                type: 'integer'
-                            }
-                        }
-                    })
-                }
-            })
-        };
-        paths[`${base}/init`] = {
-            get: op(`init${name}`, ERRORS.session, {
-                responses: {
-                    200: jsonResponse(t('authInit'), {
-                        type: 'object',
-                        properties: {
-                            initialized: {
-                                type: 'boolean'
-                            }
-                        }
-                    })
-                }
-            })
-        };
-        paths[`${base}/access`] = {
-            get: op(`access${name}`, ERRORS.session, {
-                responses: {
-                    200: jsonResponse(t('authAccess'), {
-                        type: 'object',
-                        additionalProperties: true
-                    })
-                }
-            })
-        };
-    }
-    paths[`${base}/unlock`] = {
-        post: op(`unlock${name}`, ERRORS.authAction, {
-            requestBody: jsonBody(identifierBody(auth)),
-            responses: messageResponse(t('authUnlock'))
-        })
-    };
-    if (auth.verify) paths[`${base}/verify/{id}`] = {
-        post: op(`verify${name}`, ERRORS.authAction, {
-            parameters: [
-                {
-                    name: 'id',
-                    in: 'path',
-                    required: true,
-                    schema: {
-                        type: 'string'
-                    }
-                }
-            ],
-            responses: messageResponse(t('authVerify'))
-        })
-    };
-    return paths;
-};
-export { buildAuthPaths };

package/dist/spec/paths/collections.d.ts

@@ -1,9 +0,0 @@
-import type { SanitizedCollectionConfig } from 'payload';
-import type { PathsObject } from '@scalar/openapi-types/3.2';
-import type { BuildContext } from '../../types.js';
-import type { EntitySecurity } from '../security.js';
-export declare const buildCollectionPaths: ({ collection, ctx, security, }: {
-    collection: SanitizedCollectionConfig;
-    ctx: BuildContext;
-    security?: EntitySecurity;
-}) => PathsObject;

package/dist/spec/paths/collections.js

@@ -1,278 +0,0 @@
-import { makeT } from "../../translations/index.js";
-import { ERRORS, errorResponses, jsonOk, jsonResponse, uploadRequestBody } from "../components.js";
-import { createSchemaName, listSchemaName, refTo, schemaName, updateSchemaName } from "../names.js";
-import { buildListParams, buildParamSchemas, commonReadParams, writeParams } from "../params.js";
-const buildCollectionPaths = ({ collection, ctx, security = {} })=>{
-    const t = makeT(ctx.i18n);
-    const name = schemaName(collection.slug);
-    const base = `${ctx.apiRoute}/${collection.slug}`;
-    const docRef = {
-        $ref: refTo(name)
-    };
-    const listRef = {
-        $ref: refTo(listSchemaName(name))
-    };
-    const createRef = {
-        $ref: refTo(createSchemaName(name))
-    };
-    const updateRef = {
-        $ref: refTo(updateSchemaName(name))
-    };
-    const idType = 'number' === ctx.defaultIDType ? 'integer' : 'string';
-    const { read: secRead, create: secCreate, update: secUpdate, delete: secDelete } = security;
-    const allowBulk = true !== collection.disableBulkEdit;
-    const allowDuplicate = true !== collection.disableDuplicate;
-    const paramSchemas = buildParamSchemas({
-        fields: collection.fields,
-        ctx
-    });
-    const refs = {
-        select: true,
-        populate: Boolean(paramSchemas.populate),
-        joins: Boolean(paramSchemas.joins)
-    };
-    const isUpload = Boolean(collection.upload);
-    const fileRequiredOnCreate = 'object' == typeof collection.upload ? false !== collection.upload.filesRequiredOnCreate : true;
-    const requestBody = (ref, fileRequired)=>isUpload ? uploadRequestBody({
-            bodyRef: ref,
-            fileRequired,
-            t
-        }) : {
-            content: {
-                'application/json': {
-                    schema: ref
-                }
-            }
-        };
-    const mutationSchema = {
-        type: 'object',
-        properties: {
-            message: {
-                type: 'string'
-            },
-            doc: docRef
-        }
-    };
-    const listResponse = {
-        ...jsonOk(t('collectionList'), listRef),
-        ...errorResponses(ERRORS.list, t)
-    };
-    const findByIdResponse = {
-        ...jsonOk(t('collectionDoc'), docRef),
-        ...errorResponses(ERRORS.read, t)
-    };
-    const createResponse = {
-        201: jsonResponse(t('collectionCreated'), mutationSchema),
-        ...errorResponses(ERRORS.create, t)
-    };
-    const updateResponse = {
-        ...jsonOk(t('collectionUpdated'), mutationSchema),
-        ...errorResponses(ERRORS.update, t)
-    };
-    const deleteResponse = {
-        ...jsonOk(t('collectionDeleted'), mutationSchema),
-        ...errorResponses(ERRORS["delete"], t)
-    };
-    const bulkSchema = {
-        type: 'object',
-        properties: {
-            message: {
-                type: 'string'
-            },
-            docs: {
-                type: 'array',
-                items: docRef
-            },
-            errors: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        message: {
-                            type: 'string'
-                        },
-                        id: {
-                            type: idType
-                        }
-                    }
-                }
-            }
-        }
-    };
-    const bulkUpdateResponse = {
-        ...jsonOk(t('collectionBulkUpdate'), bulkSchema),
-        ...errorResponses(ERRORS.update, t)
-    };
-    const bulkDeleteResponse = {
-        ...jsonOk(t('collectionBulkDelete'), bulkSchema),
-        ...errorResponses(ERRORS["delete"], t)
-    };
-    const countResponse = {
-        ...jsonOk(t('collectionCount'), {
-            type: 'object',
-            properties: {
-                totalDocs: {
-                    type: 'integer'
-                }
-            }
-        }),
-        ...errorResponses(ERRORS.list, t)
-    };
-    const listParams = buildListParams({
-        base: name,
-        fields: collection.fields,
-        ctx,
-        refs
-    });
-    const bulkParams = listParams.filter((p)=>'where' === p.name);
-    const bulkUpdateParams = listParams.filter((p)=>[
-            'limit',
-            'sort',
-            'where'
-        ].includes(p.name));
-    const write = (operation)=>writeParams({
-            base: name,
-            entity: collection,
-            ctx,
-            refs,
-            operation
-        });
-    const deleteParams = write('delete');
-    const bulkOps = allowBulk ? {
-        patch: {
-            tags: [
-                name
-            ],
-            operationId: `update${name}`,
-            parameters: [
-                ...bulkUpdateParams,
-                ...write('update')
-            ],
-            requestBody: requestBody(updateRef, false),
-            responses: bulkUpdateResponse,
-            security: secUpdate
-        },
-        delete: {
-            tags: [
-                name
-            ],
-            operationId: `delete${name}`,
-            parameters: [
-                ...bulkParams,
-                ...deleteParams
-            ],
-            responses: bulkDeleteResponse,
-            security: secDelete
-        }
-    } : {};
-    const paths = {
-        [base]: {
-            get: {
-                tags: [
-                    name
-                ],
-                operationId: `find${name}`,
-                parameters: buildListParams({
-                    base: name,
-                    fields: collection.fields,
-                    ctx,
-                    refs
-                }),
-                responses: listResponse,
-                security: secRead
-            },
-            post: {
-                tags: [
-                    name
-                ],
-                operationId: `create${name}`,
-                parameters: write('create'),
-                requestBody: requestBody(createRef, fileRequiredOnCreate),
-                responses: createResponse,
-                security: secCreate
-            },
-            ...bulkOps
-        },
-        [`${base}/count`]: {
-            get: {
-                tags: [
-                    name
-                ],
-                operationId: `count${name}`,
-                parameters: bulkParams,
-                responses: countResponse,
-                security: secRead
-            }
-        },
-        [`${base}/{id}`]: {
-            parameters: [
-                {
-                    name: 'id',
-                    in: 'path',
-                    required: true,
-                    schema: {
-                        type: idType
-                    }
-                }
-            ],
-            get: {
-                tags: [
-                    name
-                ],
-                operationId: `find${name}ById`,
-                parameters: commonReadParams({
-                    base: name,
-                    ctx,
-                    refs
-                }),
-                responses: findByIdResponse,
-                security: secRead
-            },
-            patch: {
-                tags: [
-                    name
-                ],
-                operationId: `update${name}ById`,
-                parameters: write('updateByID'),
-                requestBody: requestBody(updateRef, false),
-                responses: updateResponse,
-                security: secUpdate
-            },
-            delete: {
-                tags: [
-                    name
-                ],
-                operationId: `delete${name}ById`,
-                parameters: deleteParams,
-                responses: deleteResponse,
-                security: secDelete
-            }
-        }
-    };
-    if (allowDuplicate) paths[`${base}/{id}/duplicate`] = {
-        parameters: [
-            {
-                name: 'id',
-                in: 'path',
-                required: true,
-                schema: {
-                    type: idType
-                }
-            }
-        ],
-        post: {
-            tags: [
-                name
-            ],
-            operationId: `duplicate${name}`,
-            parameters: write('duplicate'),
-            responses: {
-                ...jsonOk(t('collectionDuplicated'), mutationSchema),
-                ...errorResponses(ERRORS.create, t)
-            },
-            security: secCreate
-        }
-    };
-    return paths;
-};
-export { buildCollectionPaths };

package/dist/spec/paths/custom.d.ts

@@ -1,9 +0,0 @@
-import type { SanitizedCollectionConfig, SanitizedConfig, SanitizedGlobalConfig } from 'payload';
-import type { PathsObject } from '@scalar/openapi-types/3.2';
-import type { BuildContext } from '../../types.js';
-export declare const buildCustomEndpointPaths: ({ config, collections, globals, ctx, }: {
-    config: SanitizedConfig;
-    collections: SanitizedCollectionConfig[];
-    globals: SanitizedGlobalConfig[];
-    ctx: BuildContext;
-}) => PathsObject;

package/dist/spec/paths/custom.js

@@ -1,41 +0,0 @@
-const getOpenapiMeta = (endpoint)=>{
-    const meta = endpoint.custom?.openapi;
-    return meta && 'object' == typeof meta ? meta : void 0;
-};
-const normalizePath = (prefix, path)=>{
-    const joined = `${prefix}${path.startsWith('/') ? path : `/${path}`}`;
-    return joined.replace(/:([A-Za-z0-9_]+)/g, '{$1}');
-};
-const collect = ({ endpoints, prefix, out })=>{
-    if (!endpoints) return;
-    for (const endpoint of endpoints){
-        const meta = getOpenapiMeta(endpoint);
-        if (!meta) continue;
-        const path = normalizePath(prefix, endpoint.path);
-        const method = endpoint.method.toLowerCase();
-        out[path] = {
-            ...out[path],
-            [method]: meta
-        };
-    }
-};
-const buildCustomEndpointPaths = ({ config, collections, globals, ctx })=>{
-    const out = {};
-    collect({
-        endpoints: config.endpoints,
-        prefix: '',
-        out
-    });
-    for (const collection of collections)collect({
-        endpoints: collection.endpoints,
-        prefix: `${ctx.apiRoute}/${collection.slug}`,
-        out
-    });
-    for (const global of globals)collect({
-        endpoints: global.endpoints,
-        prefix: `${ctx.apiRoute}/globals/${global.slug}`,
-        out
-    });
-    return out;
-};
-export { buildCustomEndpointPaths };

package/dist/spec/paths/globals.d.ts

@@ -1,9 +0,0 @@
-import type { SanitizedGlobalConfig } from 'payload';
-import type { PathsObject } from '@scalar/openapi-types/3.2';
-import type { BuildContext } from '../../types.js';
-import type { EntitySecurity } from '../security.js';
-export declare const buildGlobalPaths: ({ global, ctx, security, }: {
-    global: SanitizedGlobalConfig;
-    ctx: BuildContext;
-    security?: EntitySecurity;
-}) => PathsObject;

package/dist/spec/paths/globals.js

@@ -1,78 +0,0 @@
-import { makeT } from "../../translations/index.js";
-import { ERRORS, errorResponses, jsonOk } from "../components.js";
-import { globalSchemaName, refTo, updateSchemaName } from "../names.js";
-import { buildParamSchemas, commonReadParams, writeParams } from "../params.js";
-const buildGlobalPaths = ({ global, ctx, security = {} })=>{
-    const t = makeT(ctx.i18n);
-    const name = globalSchemaName(global.slug);
-    const docRef = {
-        $ref: refTo(name)
-    };
-    const updateRef = {
-        $ref: refTo(updateSchemaName(name))
-    };
-    const { read: secRead, update: secUpdate } = security;
-    const paramSchemas = buildParamSchemas({
-        fields: global.fields,
-        ctx
-    });
-    const refs = {
-        select: true,
-        populate: Boolean(paramSchemas.populate),
-        joins: Boolean(paramSchemas.joins)
-    };
-    return {
-        [`${ctx.apiRoute}/globals/${global.slug}`]: {
-            get: {
-                tags: [
-                    name
-                ],
-                operationId: `find${name}`,
-                parameters: commonReadParams({
-                    base: name,
-                    ctx,
-                    refs
-                }),
-                responses: {
-                    ...jsonOk(t('globalDoc'), docRef),
-                    ...errorResponses(ERRORS.globalRead, t)
-                },
-                security: secRead
-            },
-            post: {
-                tags: [
-                    name
-                ],
-                operationId: `update${name}`,
-                parameters: writeParams({
-                    base: name,
-                    entity: global,
-                    ctx,
-                    refs,
-                    operation: 'globalUpdate'
-                }),
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: updateRef
-                        }
-                    }
-                },
-                responses: {
-                    ...jsonOk(t('globalDoc'), {
-                        type: 'object',
-                        properties: {
-                            message: {
-                                type: 'string'
-                            },
-                            result: docRef
-                        }
-                    }),
-                    ...errorResponses(ERRORS.globalUpdate, t)
-                },
-                security: secUpdate
-            }
-        }
-    };
-};
-export { buildGlobalPaths };