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

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

@@ -1,7 +0,0 @@
-import type { SanitizedConfig } from 'payload';
-import type { PathsObject } from '@scalar/openapi-types/3.2';
-import type { BuildContext } from '../../types.js';
-export declare const buildJobsPaths: ({ config, ctx }: {
-    config: SanitizedConfig;
-    ctx: BuildContext;
-}) => PathsObject;

package/dist/spec/paths/jobs.js

@@ -1,130 +0,0 @@
-import { makeT } from "../../translations/index.js";
-import { errorResponses, jsonResponse } from "../components.js";
-const boolParam = (name, description)=>({
-        name,
-        in: 'query',
-        description,
-        schema: {
-            type: 'boolean'
-        }
-    });
-const collectQueues = (jobs)=>{
-    const queues = new Set([
-        'default'
-    ]);
-    const add = (q)=>{
-        if ('string' == typeof q && q) queues.add(q);
-    };
-    const fromSchedules = (items)=>{
-        if (!Array.isArray(items)) return;
-        for (const item of items)for (const s of item.schedule ?? [])add(s.queue);
-    };
-    fromSchedules(jobs?.tasks);
-    fromSchedules(jobs?.workflows);
-    const autoRun = jobs?.autoRun;
-    if (Array.isArray(autoRun)) for (const cron of autoRun)add(cron.queue);
-    const processingOrder = jobs?.processingOrder;
-    if (processingOrder?.queues) for (const name of Object.keys(processingOrder.queues))add(name);
-    return [
-        ...queues
-    ].toSorted();
-};
-const queueParam = (queues, ctx)=>({
-        name: 'queue',
-        in: 'query',
-        description: makeT(ctx.i18n)('jobsQueue', {
-            queues: queues.map((q)=>`\`${q}\``).join(', ')
-        }),
-        schema: {
-            type: 'string',
-            enum: queues
-        }
-    });
-const buildJobsPaths = ({ config, ctx })=>{
-    const jobs = config.jobs;
-    const hasJobs = Boolean(jobs?.tasks?.length || jobs?.workflows?.length);
-    if (!hasJobs) return {};
-    const t = makeT(ctx.i18n);
-    const queue = queueParam(collectQueues(jobs), ctx);
-    const errors = errorResponses([
-        '401',
-        '403',
-        '500'
-    ], t);
-    return {
-        [`${ctx.apiRoute}/payload-jobs/run`]: {
-            get: {
-                tags: [
-                    'Jobs'
-                ],
-                operationId: 'runJobs',
-                summary: t('jobsRunSummary'),
-                parameters: [
-                    queue,
-                    boolParam('allQueues', t('jobsRunAllQueues')),
-                    {
-                        name: 'limit',
-                        in: 'query',
-                        description: t('jobsLimit'),
-                        schema: {
-                            type: 'integer'
-                        }
-                    },
-                    boolParam('disableScheduling', t('jobsDisableScheduling')),
-                    boolParam('silent', t('jobsSilent'))
-                ],
-                responses: {
-                    200: jsonResponse(t('jobsRunResult'), {
-                        type: 'object',
-                        properties: {
-                            message: {
-                                type: 'string'
-                            },
-                            noJobsRemaining: {
-                                type: 'boolean'
-                            },
-                            remainingJobsFromQueried: {
-                                type: 'integer'
-                            }
-                        }
-                    }),
-                    ...errors
-                }
-            }
-        },
-        [`${ctx.apiRoute}/payload-jobs/handle-schedules`]: {
-            get: {
-                tags: [
-                    'Jobs'
-                ],
-                operationId: 'handleJobSchedules',
-                summary: t('jobsSchedulesSummary'),
-                parameters: [
-                    queue,
-                    boolParam('allQueues', t('jobsSchedulesAllQueues'))
-                ],
-                responses: {
-                    200: jsonResponse(t('jobsSchedulesResult'), {
-                        type: 'object',
-                        properties: {
-                            message: {
-                                type: 'string'
-                            },
-                            queued: {
-                                type: 'integer'
-                            },
-                            errored: {
-                                type: 'integer'
-                            },
-                            skipped: {
-                                type: 'integer'
-                            }
-                        }
-                    }),
-                    ...errors
-                }
-            }
-        }
-    };
-};
-export { buildJobsPaths };

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

@@ -1,19 +0,0 @@
-import type { PathsObject, SchemaObject } from '@scalar/openapi-types/3.2';
-import type { BuildContext, Entity, IDType } from '../../types.js';
-export interface VersionSchemas {
-    version: SchemaObject;
-    versionList: SchemaObject;
-}
-export declare const versionComponentSchemas: ({ docBase, base, idType, }: {
-    docBase: string;
-    base: string;
-    idType: IDType;
-}) => VersionSchemas;
-export declare const buildVersionPaths: ({ entity, pathBase, ctx, schemaBase, nestedTags, global, }: {
-    entity: Entity;
-    pathBase: string;
-    ctx: BuildContext;
-    schemaBase?: string;
-    nestedTags: boolean;
-    global?: boolean;
-}) => PathsObject;

package/dist/spec/paths/versions.js

@@ -1,252 +0,0 @@
-import { makeT } from "../../translations/index.js";
-import { ERRORS, errorResponses, jsonResponse, nullableType } from "../components.js";
-import { refTo, schemaName } from "../names.js";
-import { buildParamSchemas, commonReadParams } from "../params.js";
-import { versionsTagName } from "../tags.js";
-const buildVersionSchema = (base, idType)=>{
-    const id = {
-        type: 'number' === idType ? 'integer' : 'string'
-    };
-    return {
-        type: 'object',
-        properties: {
-            id,
-            parent: id,
-            version: {
-                $ref: refTo(base)
-            },
-            createdAt: {
-                type: 'string',
-                format: 'date-time'
-            },
-            updatedAt: {
-                type: 'string',
-                format: 'date-time'
-            },
-            latest: {
-                type: 'boolean'
-            },
-            autosave: {
-                type: 'boolean'
-            },
-            snapshot: {
-                type: 'boolean'
-            },
-            publishedLocale: {
-                type: 'string'
-            }
-        },
-        required: [
-            'id',
-            'parent',
-            'version',
-            'createdAt',
-            'updatedAt'
-        ]
-    };
-};
-const buildVersionListSchema = (base)=>({
-        type: 'object',
-        properties: {
-            docs: {
-                type: 'array',
-                items: {
-                    $ref: refTo(`${base}Version`)
-                }
-            },
-            totalDocs: {
-                type: 'integer'
-            },
-            limit: {
-                type: 'integer'
-            },
-            totalPages: {
-                type: 'integer'
-            },
-            page: {
-                type: 'integer'
-            },
-            pagingCounter: {
-                type: 'integer'
-            },
-            hasPrevPage: {
-                type: 'boolean'
-            },
-            hasNextPage: {
-                type: 'boolean'
-            },
-            prevPage: nullableType('integer'),
-            nextPage: nullableType('integer')
-        }
-    });
-const versionComponentSchemas = ({ docBase, base, idType })=>({
-        version: buildVersionSchema(docBase, idType),
-        versionList: buildVersionListSchema(base)
-    });
-const versionRef = (base)=>({
-        $ref: refTo(`${base}Version`)
-    });
-const versionListRef = (base)=>({
-        $ref: refTo(`${base}VersionList`)
-    });
-const listVersionParams = ({ base, ctx, refs })=>{
-    const t = makeT(ctx.i18n);
-    return [
-        {
-            name: 'page',
-            in: 'query',
-            schema: {
-                type: 'integer'
-            }
-        },
-        {
-            name: 'limit',
-            in: 'query',
-            schema: {
-                type: 'integer'
-            }
-        },
-        {
-            name: 'pagination',
-            in: 'query',
-            schema: {
-                type: 'boolean'
-            }
-        },
-        {
-            name: 'sort',
-            in: 'query',
-            description: t('paramSortShort'),
-            schema: {
-                type: 'string'
-            }
-        },
-        ...commonReadParams({
-            base,
-            ctx,
-            refs
-        }),
-        {
-            name: 'where',
-            in: 'query',
-            description: t('versionWhere'),
-            content: {
-                'application/json': {
-                    schema: {
-                        type: 'object',
-                        additionalProperties: true
-                    }
-                }
-            }
-        }
-    ];
-};
-const buildVersionPaths = ({ entity, pathBase, ctx, schemaBase, nestedTags, global = false })=>{
-    if (!entity.versions) return {};
-    const t = makeT(ctx.i18n);
-    const name = schemaBase ?? schemaName(entity.slug);
-    const versionsTag = [
-        nestedTags ? versionsTagName(name) : name
-    ];
-    const paramSchemas = buildParamSchemas({
-        fields: entity.fields,
-        ctx
-    });
-    const refs = {
-        select: true,
-        populate: Boolean(paramSchemas.populate),
-        joins: Boolean(paramSchemas.joins)
-    };
-    const idParam = {
-        name: 'id',
-        in: 'path',
-        required: true,
-        schema: {
-            type: 'number' === ctx.defaultIDType ? 'integer' : 'string'
-        }
-    };
-    const message = {
-        type: 'string'
-    };
-    const restoreResponse = global ? {
-        type: 'object',
-        properties: {
-            message,
-            doc: {
-                $ref: refTo(name)
-            }
-        }
-    } : {
-        allOf: [
-            {
-                $ref: refTo(name)
-            },
-            {
-                type: 'object',
-                properties: {
-                    message
-                }
-            }
-        ]
-    };
-    return {
-        [`${pathBase}/versions`]: {
-            get: {
-                tags: versionsTag,
-                operationId: `find${name}Versions`,
-                parameters: listVersionParams({
-                    base: name,
-                    ctx,
-                    refs
-                }),
-                responses: {
-                    200: jsonResponse(t('versionList'), versionListRef(name)),
-                    ...errorResponses(ERRORS.versionList, t)
-                }
-            }
-        },
-        [`${pathBase}/versions/{id}`]: {
-            parameters: [
-                idParam
-            ],
-            get: {
-                tags: versionsTag,
-                operationId: `find${name}VersionById`,
-                parameters: commonReadParams({
-                    base: name,
-                    ctx,
-                    refs
-                }),
-                responses: {
-                    200: jsonResponse(t('versionSingle'), versionRef(name)),
-                    ...errorResponses(ERRORS.versionRead, t)
-                }
-            },
-            post: {
-                tags: versionsTag,
-                operationId: `restore${name}Version`,
-                parameters: [
-                    {
-                        name: 'depth',
-                        in: 'query',
-                        schema: {
-                            type: 'integer'
-                        }
-                    },
-                    {
-                        name: 'draft',
-                        in: 'query',
-                        schema: {
-                            type: 'boolean'
-                        }
-                    }
-                ],
-                responses: {
-                    200: jsonResponse(t('versionRestored'), restoreResponse),
-                    ...errorResponses(ERRORS.versionRestore, t)
-                }
-            }
-        }
-    };
-};
-export { buildVersionPaths, versionComponentSchemas };

package/dist/spec/security.d.ts

@@ -1,19 +0,0 @@
-import type { Access } from 'payload';
-import type { PathsObject, SecurityRequirementObject } from '@scalar/openapi-types/3.2';
-import type { Entity, EntityKind, EntityOperation, OperationContext } from '../types.js';
-export type EntitySecurity = Partial<Record<EntityOperation, SecurityRequirementObject[] | undefined>>;
-export declare const evaluateAccess: (access: Access | undefined, opts?: {
-    locale?: string;
-    timeoutMs?: number;
-}) => Promise<boolean>;
-export declare const resolveEntitySecurity: ({ entity, operations, locale, }: {
-    entity: Entity;
-    operations: EntityOperation[];
-    locale?: string;
-}) => Promise<EntitySecurity>;
-export declare const applySecurityWhen: ({ paths, slug, kind, securityWhen, }: {
-    paths: PathsObject;
-    slug: string;
-    kind: EntityKind;
-    securityWhen?: (ctx: OperationContext) => boolean | undefined;
-}) => PathsObject;

package/dist/spec/security.js

@@ -1,96 +0,0 @@
-import { SECURITY_SCHEME_NAME } from "./components.js";
-const HTTP_METHODS = [
-    'get',
-    'post',
-    'patch',
-    'put',
-    'delete'
-];
-const securedRequirement = ()=>[
-        {
-            [SECURITY_SCHEME_NAME]: []
-        }
-    ];
-const withTimeout = async (promise, timeoutMs)=>{
-    let timer;
-    const guard = new Promise((resolve)=>{
-        timer = setTimeout(()=>resolve(false), timeoutMs);
-    });
-    try {
-        return await Promise.race([
-            promise.then((value)=>true === value, ()=>false),
-            guard
-        ]);
-    } finally{
-        if (timer) clearTimeout(timer);
-    }
-};
-const evaluateAccess = async (access, opts = {})=>{
-    if (!access) return false;
-    const { locale, timeoutMs = 250 } = opts;
-    const payloadTrap = new Proxy({}, {
-        get () {
-            throw new Error('req.payload accessed during build');
-        }
-    });
-    const req = {
-        user: null,
-        headers: new Headers(),
-        context: {},
-        locale,
-        payload: payloadTrap
-    };
-    try {
-        const result = access({
-            req
-        });
-        if (result && 'function' == typeof result.then) return await withTimeout(result, timeoutMs);
-        return true === result;
-    } catch  {
-        return false;
-    }
-};
-const readSecurityOverride = (entity)=>{
-    const meta = entity.custom?.openapi?.security;
-    if ('boolean' == typeof meta) return meta;
-    if (meta && 'object' == typeof meta) return meta;
-};
-const overrideFor = (override, op)=>{
-    if (void 0 === override) return;
-    if ('boolean' == typeof override) return override;
-    return override[op];
-};
-const resolveEntitySecurity = async ({ entity, operations, locale })=>{
-    const override = readSecurityOverride(entity);
-    const access = entity.access;
-    const out = {};
-    for (const op of operations){
-        const declared = overrideFor(override, op);
-        const isPublic = declared ?? await evaluateAccess(access?.[op], {
-            locale
-        });
-        out[op] = isPublic ? void 0 : securedRequirement();
-    }
-    return out;
-};
-const applySecurityWhen = ({ paths, slug, kind, securityWhen })=>{
-    if (!securityWhen) return paths;
-    for (const [path, item] of Object.entries(paths)){
-        if (!item) continue;
-        const ops = item;
-        for (const method of HTTP_METHODS){
-            const op = ops[method];
-            if (!op) continue;
-            const decision = securityWhen({
-                method,
-                path,
-                slug,
-                kind
-            });
-            if (true === decision) delete op.security;
-            else if (false === decision) op.security = securedRequirement();
-        }
-    }
-    return paths;
-};
-export { applySecurityWhen, evaluateAccess, resolveEntitySecurity };

package/dist/spec/tags.d.ts

@@ -1,27 +0,0 @@
-import type { TagObject } from '@scalar/openapi-types/3.2';
-import type { Translate } from '../translations/types.js';
-export declare const NAV_COLLECTIONS = "Collections";
-export declare const NAV_GLOBALS = "Globals";
-export declare const NAV_SYSTEM = "System";
-export declare const entityTagName: (base: string) => string;
-export declare const authTagName: (base: string) => string;
-export declare const versionsTagName: (base: string) => string;
-export interface CollectionTagInfo {
-    base: string;
-    hasAuth: boolean;
-    hasVersions: boolean;
-    description?: string;
-}
-export interface GlobalTagInfo {
-    base: string;
-    hasVersions: boolean;
-    description?: string;
-}
-export interface TagHierarchyInput {
-    collections: CollectionTagInfo[];
-    globals: GlobalTagInfo[];
-    hasJobs: boolean;
-    t: Translate;
-    nested: boolean;
-}
-export declare const buildTagHierarchy: ({ collections, globals, hasJobs, t, nested }: TagHierarchyInput) => TagObject[];

package/dist/spec/tags.js

@@ -1,79 +0,0 @@
-const NAV_COLLECTIONS = 'Collections';
-const NAV_GLOBALS = 'Globals';
-const NAV_SYSTEM = 'System';
-const entityTagName = (base)=>base;
-const authTagName = (base)=>`${base} Auth`;
-const versionsTagName = (base)=>`${base} Versions`;
-const buildTagHierarchy = ({ collections, globals, hasJobs, t, nested })=>{
-    if (!nested) return [
-        ...collections.map((c)=>({
-                name: entityTagName(c.base),
-                description: c.description
-            })),
-        ...globals.map((g)=>({
-                name: entityTagName(g.base),
-                description: g.description
-            }))
-    ];
-    const tags = [];
-    if (collections.length > 0) {
-        tags.push({
-            name: NAV_COLLECTIONS,
-            summary: t('tagCollections'),
-            description: t('tagCollectionsDesc'),
-            kind: 'nav'
-        });
-        for (const c of collections){
-            tags.push({
-                name: entityTagName(c.base),
-                parent: NAV_COLLECTIONS,
-                description: c.description
-            });
-            if (c.hasAuth) tags.push({
-                name: authTagName(c.base),
-                parent: c.base,
-                summary: t('tagAuth')
-            });
-            if (c.hasVersions) tags.push({
-                name: versionsTagName(c.base),
-                parent: c.base,
-                summary: t('tagVersions')
-            });
-        }
-    }
-    if (globals.length > 0) {
-        tags.push({
-            name: NAV_GLOBALS,
-            summary: t('tagGlobals'),
-            description: t('tagGlobalsDesc'),
-            kind: 'nav'
-        });
-        for (const g of globals){
-            tags.push({
-                name: entityTagName(g.base),
-                parent: NAV_GLOBALS,
-                description: g.description
-            });
-            if (g.hasVersions) tags.push({
-                name: versionsTagName(g.base),
-                parent: g.base,
-                summary: t('tagVersions')
-            });
-        }
-    }
-    if (hasJobs) {
-        tags.push({
-            name: NAV_SYSTEM,
-            summary: t('tagSystem'),
-            description: t('tagSystemDesc'),
-            kind: 'nav'
-        });
-        tags.push({
-            name: 'Jobs',
-            parent: NAV_SYSTEM,
-            summary: t('tagJobs')
-        });
-    }
-    return tags;
-};
-export { NAV_COLLECTIONS, NAV_GLOBALS, NAV_SYSTEM, authTagName, buildTagHierarchy, entityTagName, versionsTagName };

package/dist/translations/index.d.ts

@@ -1,6 +0,0 @@
-import type { AcceptedLanguages, I18n } from '@payloadcms/translations';
-import type { PluginDefaultTranslationsObject, Translate } from './types.js';
-export declare const makeT: (i18n: Pick<I18n, "t">) => Translate;
-export declare const translations: {
-    [key in AcceptedLanguages]?: PluginDefaultTranslationsObject;
-};

package/dist/translations/locales/ar.d.ts

@@ -1,2 +0,0 @@
-import type { PluginDefaultTranslationsObject } from '../types.js';
-export declare const ar: PluginDefaultTranslationsObject;