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

package/dist/shared/types/index.d.ts

@@ -0,0 +1,397 @@
+import { BasePayload, PayloadRequest, SanitizedCollectionConfig, SanitizedGlobalConfig } from "payload";
+import { I18n } from "@payloadcms/translations";
+import { ComponentsObject, Document, InfoObject, PathsObject, SecurityRequirementObject, ServerObject, TagObject } from "@scalar/openapi-types/3.2";
+export type OpenApiVersion = '3.0' | '3.1' | '3.2';
+export type EntityKind = 'collection' | 'global';
+export type OperationKind = EntityKind | 'custom' | 'jobs' | 'system';
+export type HttpMethod = 'get' | 'post' | 'patch' | 'put' | 'delete';
+export type IDType = 'text' | 'number';
+export type Entity = SanitizedCollectionConfig | SanitizedGlobalConfig;
+export type EntityOperation = 'read' | 'create' | 'update' | 'delete' | 'validate';
+export type SecurityMarking = 'public' | 'secured';
+/**
+ * Marking for a collection or global, set in its `custom.openapi.security`:
+ * one marking for every operation, or one per operation. Operations you leave
+ * out keep the marking the access probe found. `read` also marks the version
+ * reads. `validate` falls back to `update` when you leave it out.
+ */
+export type EntitySecurityOverride = SecurityMarking | Partial<Record<EntityOperation, SecurityMarking>>;
+/**
+ * Text that follows the request language: a string, a map of language to
+ * string (`{ en: '…', de: '…' }`), or a function that gets `{ t, i18n }`.
+ */
+export type LocalizedText = string | Record<string, string> | ((args: {
+  t: (key: string, vars?: Record<string, unknown>) => string;
+  i18n: I18n;
+}) => string);
+/** `custom.openapi` on a collection or global. */
+export interface EntityOpenApiMeta {
+  /** Overrides the public or secured marking. See {@link EntitySecurityOverride}. */
+  security?: EntitySecurityOverride;
+}
+/**
+ * `custom.openapi` on a field: a partial Schema Object deep-merged on top of
+ * the inferred one. `description`, `title` and `summary` follow the
+ * request language.
+ */
+export interface FieldOpenApiMeta {
+  description?: LocalizedText;
+  title?: LocalizedText;
+  summary?: LocalizedText;
+  [keyword: string]: unknown;
+}
+declare module 'payload' {
+  interface CollectionCustom {
+    openapi?: EntityOpenApiMeta;
+  }
+  interface GlobalCustom {
+    openapi?: EntityOpenApiMeta;
+  }
+  interface FieldCustom {
+    openapi?: FieldOpenApiMeta;
+  }
+}
+/**
+ * The OpenAPI `info` object. `title` and `version` are required. `description`
+ * can follow the request language, see {@link LocalizedText}.
+ */
+export type OpenApiInfo = Omit<InfoObject, 'description'> & {
+  description?: LocalizedText;
+};
+/**
+ * Base URLs for the spec's `servers`: a fixed list, or a function that gets
+ * the request.
+ */
+export type ServersOption = ServerObject[] | ((args: {
+  req: PayloadRequest;
+}) => ServerObject[] | Promise<ServerObject[]>);
+/**
+ * Interactive "Authorize" login for the docs UI. When on, the plugin adds a
+ * token endpoint and a security scheme so Scalar/Swagger can log in with a
+ * username and password instead of pasting a token. Off by default.
+ *   - `true` — on, at the default path, against the first auth collection.
+ *   - `{ path, collection }` — on, with a custom token endpoint path or auth collection.
+ */
+export type InteractiveAuthOption = boolean | {
+  /**
+   * Token endpoint path, relative to the API route (`/openapi-auth` → `/api/openapi-auth`).
+   * @default '/openapi-auth'
+   */
+  path?: string;
+  /**
+   * Auth collection the login runs against.
+   * @default the first collection with `auth` enabled, or `'users'`
+   */
+  collection?: string;
+};
+/**
+ * Gate for a plugin route. Return `true` to serve the request; anything else
+ * answers 403.
+ */
+export type AccessOption = (args: {
+  req: PayloadRequest;
+}) => boolean | Promise<boolean>;
+/** Match an entity by slug (any kind), a {kind,slug} pair, or a slug pattern. */
+export type EntityMatcher = string | RegExp | {
+  kind: EntityKind;
+  slug: string;
+};
+/**
+ * Drops generated operations. Within one rule, every set field must match (AND);
+ * an operation is removed if any rule matches it. Fields:
+ *   - `method` — HTTP method(s); omit to match any.
+ *   - `slug`   — collection or global slug, exact string or RegExp; omit to match any.
+ *     A rule with `slug` never matches custom, jobs or system operations.
+ *   - `kind`   — restrict to one operation group; omit to match all.
+ *   - `path`   — RegExp tested against the final route path (e.g. `/api/posts/{id}`).
+ */
+export interface OperationRule {
+  method?: HttpMethod | HttpMethod[];
+  slug?: string | RegExp;
+  kind?: OperationKind;
+  path?: RegExp;
+}
+/** Context passed to `excludeOperations` functions and `security` for each operation. */
+export interface OperationContext {
+  method: HttpMethod;
+  path: string;
+  /** Collection or global slug. Unset for custom, jobs and system operations. */
+  slug?: string;
+  kind: OperationKind;
+}
+/** A rule, or a function that drops the operation when it returns (or resolves to) `true`. */
+export type OperationFilter = OperationRule | ((ctx: OperationContext) => boolean | Promise<boolean>);
+type SecurityDecision = SecurityMarking | SecurityRequirementObject[] | undefined;
+/**
+ * Decides the security marking of one operation. `'public'` removes it,
+ * `'secured'` sets the default requirement, an array sets that exact
+ * requirement, and `undefined` keeps `detected`.
+ */
+export type SecurityOption = (ctx: OperationContext & {
+  detected: SecurityMarking;
+}) => SecurityDecision | Promise<SecurityDecision>;
+/**
+ * Controls what appears in the spec, in one flat object: which entities are
+ * documented, which Payload-internal collections to show, which extra endpoint
+ * groups to generate, and which operations to drop.
+ */
+export interface FilterOptions {
+  /**
+   * Allowlist of entities; when non-empty, only matching entities are documented.
+   * @default []
+   */
+  include?: EntityMatcher[];
+  /**
+   * Entities to omit entirely (schemas + paths).
+   * @default []
+   */
+  exclude?: EntityMatcher[];
+  /**
+   * Include collections flagged `hidden`/`admin.hidden`.
+   * @default false
+   */
+  includeHidden?: boolean;
+  /**
+   * Include Payload-internal collections and globals (payload-jobs, payload-preferences, payload-jobs-stats, ...).
+   * @default false
+   */
+  includeSystem?: boolean;
+  /**
+   * Document endpoints carrying `custom.openapi` metadata.
+   * @default true
+   */
+  includeCustom?: boolean;
+  /**
+   * Document auth operation endpoints (login/logout/me/...).
+   * @default true
+   */
+  includeAuth?: boolean;
+  /**
+   * Document admin/bootstrap auth endpoints (/init, first-register, root /access) and the document access endpoints (/{slug}/access/{id}, /globals/{slug}/access).
+   * @default false
+   */
+  includeAdminAuth?: boolean;
+  /**
+   * Document version operation endpoints (/versions, /versions/{id}).
+   * @default true
+   */
+  includeVersions?: boolean;
+  /**
+   * Document jobs endpoints (/payload-jobs/run, /handle-schedules).
+   * @default true
+   */
+  includeJobs?: boolean;
+  /**
+   * Drops operations from every group: collection, global, custom, jobs and
+   * system. An operation is removed when any rule matches it or any function
+   * returns `true`.
+   * @default []
+   */
+  excludeOperations?: OperationFilter[];
+}
+export interface OpenApiExtension {
+  /** Paths deep-merged into the generated ones. */
+  paths?: PathsObject;
+  /** Components deep-merged into the generated ones. */
+  components?: ComponentsObject;
+  /** Tags appended to the list; a tag whose name already exists is skipped. */
+  tags?: TagObject[];
+  /**
+   * Runs on the finished document and returns the document to use. Gets one
+   * object: `doc` plus the {@link ExtensionContext}, e.g. `({ doc, payload }) => doc`.
+   * It can be `async`. If it throws, the spec request fails: the plugin never
+   * serves a document that skipped a transform.
+   */
+  transform?: (args: ExtensionContext) => Document | Promise<Document>;
+}
+/** What `extensions[].transform` gets: the finished document and the build context. */
+export type ExtensionContext = BuildContext & {
+  doc: Document;
+  payload: BasePayload;
+  options: ResolvedOptions;
+};
+export type OpenApiPluginOptions = {
+  /** The document's `info` object. `title` and `version` are required. See {@link OpenApiInfo}. */
+  info: OpenApiInfo;
+  /**
+   * OpenAPI version to serve. The document is always built as 3.2; `3.1` and
+   * `3.0` each run a downconversion pass on the result.
+   * @default '3.2'
+   */
+  openapiVersion?: OpenApiVersion;
+  /**
+   * Where the spec is served, relative to the Payload API route (`routes.api`,
+   * `/api` by default). So the `/openapi.json` default is served at
+   * `/api/openapi.json`.
+   * @default '/openapi.json'
+   */
+  path?: string;
+  /**
+   * Set false to turn the plugin off. It then adds no endpoints, no CLI command
+   * and no translations. The plugin adds no collections, so the schema stays the same.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Mount the runtime spec (and interactive-auth) endpoints. Set false to
+   * register only the `openapi:generate` CLI command and skip serving over
+   * HTTP — generate the spec to a file and host it however you like (static
+   * asset, CDN, committed to the repo). Point the docs UI plugins' `specURL`
+   * at wherever the file ends up.
+   * @default true
+   */
+  serve?: boolean;
+  /**
+   * Who may read the spec endpoint. Runs on every request.
+   * @default open to everyone
+   */
+  access?: AccessOption;
+  /**
+   * The spec's `servers`. A function runs on every request. See {@link ServersOption}.
+   * @default `[{ url: serverURL }]` when the Payload `serverURL` is set, otherwise `[]` (clients use the spec's own origin)
+   */
+  servers?: ServersOption;
+  /**
+   * Hosts the spec may echo back as its server URL. When the request `Host`
+   * header (`host` or `host:port`) is on this list, `servers` is
+   * `https://<host>` (`http` for localhost and 127.*). The `Host` header comes from
+   * the client, so the plugin never uses it unless you list it here. A
+   * `servers` option wins over this list.
+   * @default []
+   */
+  trustedHosts?: string[];
+  /** What appears in the spec. See {@link FilterOptions}. */
+  filters?: FilterOptions;
+  /**
+   * Interactive docs-UI login. See {@link InteractiveAuthOption}.
+   * @default false
+   */
+  interactiveAuth?: InteractiveAuthOption;
+  /**
+   * Emit an OpenAPI 3.2 nested tag hierarchy (nav groups via `kind`/`parent`,
+   * plus per-entity auth/version sub-tags). Off by default: Scalar and Swagger UI
+   * don't render 3.2 nested tags yet and would show a confusing flat list of group
+   * names. When off, `doc.tags` is a flat list of per-entity tags with their
+   * descriptions.
+   * @default false
+   */
+  nestedTags?: boolean;
+  /**
+   * Override the security marking per operation. Runs last, after
+   * `custom.openapi.security` and the access probe, across every operation
+   * group. See {@link SecurityOption}.
+   */
+  security?: SecurityOption;
+  /**
+   * Cache the built document for the life of the process. The Payload config is
+   * static after boot, so the spec is the same every time apart from
+   * `servers`, which is set per request. Set false in dev to rebuild on
+   * every request, e.g. `cache: process.env.NODE_ENV === 'production'`.
+   * @default true
+   */
+  cache?: boolean;
+  /**
+   * Extra paths, components and tags merged into the document, plus a final `transform`.
+   * @default []
+   */
+  extensions?: OpenApiExtension[];
+  /**
+   * Anonymous usage telemetry: plugin, Payload and Node versions and the features in use. On by default.
+   * It never sends secrets, IP addresses, keys, URLs, paths, hostnames or collection names.
+   * The first run logs a notice.
+   *
+   * Off when `payload.config.telemetry` is `false`, when `DO_NOT_TRACK` or `OPENAPI_TELEMETRY_DISABLED`
+   * is set, in CI or with `NODE_ENV=test`. Set `false` to turn it off. Pass `{ url }` to use your own collector.
+   *
+   * @see https://payload-plugin-openapi.seshuk.im/v1/configuration/telemetry
+   * @default true
+   */
+  telemetry?: boolean | {
+    /**
+     * Collector URL that receives the telemetry report.
+     * @default the plugin's public collector
+     */
+    url?: string;
+  };
+};
+export interface UiPluginOptions {
+  /**
+   * Where the docs UI is served, relative to the Payload API route
+   * (`routes.api`, `/api` by default). So the `/docs` default is served at
+   * `/api/docs`.
+   * @default '/docs'
+   */
+  path?: string;
+  /**
+   * URL the UI fetches the OpenAPI document from. Any URL reference works:
+   * absolute, root-relative, or relative to the docs page.
+   * @default the `openapi()` spec route, `<apiRoute>/openapi.json` unless its `path` is set
+   */
+  specURL?: string;
+  /**
+   * Where the UI's assets load from: the script URL for Scalar, the folder with
+   * `swagger-ui-bundle.js` and `swagger-ui.css` for Swagger UI. Set it to
+   * self-host the assets. The default URL is pinned to one version and loads
+   * with Subresource Integrity; a custom URL loads without it.
+   * @default the pinned jsDelivr URL
+   */
+  cdnBase?: string;
+  /**
+   * Extra UI config, merged into the underlying library's init options (Scalar's
+   * `createApiReference` config or Swagger UI's `SwaggerUIBundle`). Must be
+   * JSON-serializable, functions aren't supported here.
+   * @default {}
+   */
+  configuration?: Record<string, unknown>;
+  /**
+   * Who may open the docs page. Runs on every request.
+   * @default open to everyone
+   */
+  access?: AccessOption;
+  /**
+   * Set false to skip mounting the docs UI.
+   * @default true
+   */
+  enabled?: boolean;
+}
+export interface ResolvedFilters {
+  include: EntityMatcher[];
+  exclude: EntityMatcher[];
+  includeHidden: boolean;
+  includeSystem: boolean;
+  includeCustom: boolean;
+  includeAuth: boolean;
+  includeAdminAuth: boolean;
+  includeVersions: boolean;
+  includeJobs: boolean;
+  excludeOperations: OperationFilter[];
+}
+export interface ResolvedOptions {
+  info: OpenApiInfo;
+  openapiVersion: OpenApiVersion;
+  path: string;
+  serve: boolean;
+  access?: AccessOption;
+  servers?: ServersOption;
+  trustedHosts: string[];
+  filters: ResolvedFilters;
+  interactiveAuth: {
+    enabled: boolean;
+    path: string;
+    collection?: string;
+  };
+  nestedTags: boolean;
+  security?: SecurityOption;
+  cache: boolean;
+  extensions: OpenApiExtension[];
+}
+export interface BuildContext {
+  defaultIDType: IDType;
+  locales: string[];
+  apiRoute: string;
+  /** Languages the docs are available in (project `i18n.supportedLanguages`). */
+  docLanguages: string[];
+  /** Request i18n: resolves Payload entity descriptions and, via {@link makeT}, plugin strings. */
+  i18n: I18n;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/{utils.d.ts → shared/utils.d.ts}

@@ -1,3 +1,4 @@
 export declare const upperFirst: (value: string) => string;
 export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
 export declare const deepMerge: (a: Record<string, unknown>, b: Record<string, unknown>) => Record<string, unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/shared/utils.js

@@ -0,0 +1,13 @@
+const upperFirst = (value) => value.length === 0 ? value : value[0].toUpperCase() + value.slice(1);
+const isPlainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const deepMerge = (a, b) => {
+	const out = { ...a };
+	for (const [key, value] of Object.entries(b)) {
+		const prev = out[key];
+		out[key] = isPlainObject(prev) && isPlainObject(value) ? deepMerge(prev, value) : value;
+	}
+	return out;
+};
+export { deepMerge, isPlainObject, upperFirst };
+
+//# sourceMappingURL=utils.js.map

package/dist/shared/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/shared/utils.ts"],"sourcesContent":["export const upperFirst = (value: string): string =>\n  value.length === 0 ? value : value[0]!.toUpperCase() + value.slice(1)\n\nexport const isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  Boolean(value) && typeof value === 'object' && !Array.isArray(value)\n\nexport const deepMerge = (a: Record<string, unknown>, b: Record<string, unknown>): Record<string, unknown> => {\n  const out = { ...a }\n  for (const [key, value] of Object.entries(b)) {\n    const prev = out[key]\n    out[key] = isPlainObject(prev) && isPlainObject(value) ? deepMerge(prev, value) : value\n  }\n  return out\n}\n"],"mappings":"AAAA,MAAa,cAAc,UACzB,MAAM,WAAW,IAAI,QAAQ,MAAM,EAAE,CAAE,YAAY,IAAI,MAAM,MAAM,CAAC;AAEtE,MAAa,iBAAiB,UAC5B,QAAQ,KAAK,KAAK,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;AAErE,MAAa,aAAa,GAA4B,MAAwD;CAC5G,MAAM,MAAM,EAAE,GAAG,EAAE;CACnB,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,CAAC,GAAG;EAC5C,MAAM,OAAO,IAAI;EACjB,IAAI,OAAO,cAAc,IAAI,KAAK,cAAc,KAAK,IAAI,UAAU,MAAM,KAAK,IAAI;CACpF;CACA,OAAO;AACT"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@seshuk/payload-plugin-openapi",
-  "version": "0.2.1",
-  "description": "OpenAPI 3.0/3.1/3.2 spec generator for Payload CMS, with Scalar/Swagger UI.",
+  "version": "1.0.0-beta.1",
+  "description": "OpenAPI 3.0/3.1/3.2 spec generator for Payload, with Scalar/Swagger UI.",
   "keywords": [
     "api-docs",
     "cms",
@@ -23,77 +23,88 @@
     "type": "git",
     "url": "git+https://github.com/maximseshuk/payload-plugin-openapi.git"
   },
-  "funding": "https://ko-fi.com/V7V61UCT39",
+  "funding": {
+    "type": "ko-fi",
+    "url": "https://ko-fi.com/seshuk"
+  },
   "files": [
     "dist"
   ],
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./src/index.ts",
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
-    },
-    "./*": "./*"
-  },
-  "publishConfig": {
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-      ".": {
-        "import": "./dist/index.js",
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
-  "scripts": {
-    "build": "rslib build",
-    "build:watch": "rslib build --watch",
-    "dev": "cross-env PAYLOAD_CONFIG_PATH=./tests/payload.config.ts next dev tests --turbo",
-    "dev:safe": "rm -rf .next && cross-env PAYLOAD_CONFIG_PATH=./tests/payload.config.ts next dev tests --turbo --port 3001",
-    "dev:generate-importmap": "cd tests && cross-env PAYLOAD_CONFIG_PATH=./payload.config.ts payload generate:importmap",
-    "docs:check-links": "pnpm --dir docs check-links",
-    "docs:dev": "pnpm --dir docs dev",
-    "docs:validate": "pnpm --dir docs validate",
-    "lint": "oxlint src tests",
-    "lint:fix": "oxlint src tests --fix",
-    "format": "oxfmt .",
-    "format:check": "oxfmt --check .",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "release:patch": "pnpm version patch -m \"chore(release): v%s\"",
-    "release:minor": "pnpm version minor -m \"chore(release): v%s\"",
-    "release:major": "pnpm version major -m \"chore(release): v%s\""
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
     "@scalar/openapi-types": "^0.9.1"
   },
   "devDependencies": {
-    "@payloadcms/db-sqlite": "^3.85.1",
-    "@payloadcms/next": "^3.85.1",
-    "@payloadcms/translations": "^3.85.1",
-    "@rslib/core": "^0.22.1",
+    "@payloadcms/db-sqlite": "4.0.0-canary.38",
+    "@payloadcms/next": "4.0.0-canary.38",
+    "@payloadcms/translations": "4.0.0-canary.38",
+    "@payloadcms/ui": "4.0.0-canary.38",
     "@seriousme/openapi-schema-validator": "^2.9.0",
+    "@seshuk/payload-plugin-tooling": "0.2.3",
+    "@types/node": "^26.1.2",
+    "@vitest/coverage-v8": "^5.0.3",
     "cross-env": "^10.1.0",
-    "next": "^16.2.9",
-    "oxfmt": "^0.54.0",
-    "oxlint": "^1.69.0",
-    "payload": "^3.85.1",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
-    "typescript": "^6.0.3",
-    "vite-tsconfig-paths": "7.0.0-alpha.1",
-    "vitest": "^4.1.8"
+    "next": "16.4.0",
+    "oxfmt": "^0.71.0",
+    "oxlint": "^1.86.0",
+    "payload": "4.0.0-canary.38",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
+    "tsdown": "^0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "^5.0.3"
   },
   "peerDependencies": {
-    "@payloadcms/translations": "^3.53.0",
-    "payload": "^3.53.0"
+    "@payloadcms/translations": "4.0.0-canary.38",
+    "payload": "4.0.0-canary.38"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "^12.0.0",
+      "onFail": "warn"
+    },
+    "runtime": {
+      "name": "node",
+      "version": ">=24.15.0",
+      "onFail": "warn"
+    }
   },
   "engines": {
-    "node": ">=20.9.0"
+    "node": ">=24.15.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "dev": "cross-env PAYLOAD_CONFIG_PATH=./tests/payload.config.ts DATABASE_URL=file:./tests/payload.db next dev tests",
+    "dev:generate-importmap": "cd tests && cross-env PAYLOAD_CONFIG_PATH=./payload.config.ts payload generate:importmap",
+    "dev:safe": "rm -rf tests/.next && cross-env PAYLOAD_CONFIG_PATH=./tests/payload.config.ts DATABASE_URL=file:./tests/payload.db next dev tests --port 3001",
+    "docs:check-links": "pnpm --dir docs check-links",
+    "docs:dev": "pnpm --dir docs dev",
+    "docs:validate": "pnpm --dir docs validate",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "test": "vitest run -c tests/vitest.config.ts",
+    "test:coverage": "vitest run -c tests/vitest.config.ts --coverage",
+    "test:int": "vitest run -c tests/vitest.config.ts --project int",
+    "test:unit": "vitest run -c tests/vitest.config.ts --project unit",
+    "test:watch": "vitest -c tests/vitest.config.ts",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/dist/bin/generateSpec.d.ts

@@ -1,25 +0,0 @@
-import type { SanitizedConfig } from 'payload';
-interface CliArgs {
-    lang?: string;
-    out?: string;
-    server?: string;
-}
-export declare const parseArgs: (argv: string[]) => CliArgs;
-/**
- * Bin entrypoint registered automatically by the OpenAPI plugin. Reads resolved
- * plugin options from `config.custom[PLUGIN_NAME]` (stashed during config build),
- * then writes the OpenAPI document(s) to disk — no HTTP request required.
- *
- * Flags:
- *   --lang <code|all>  locale for translated descriptions; `all` writes one file
- *                      per supported language. Defaults to the i18n fallback.
- *   --out <path>       output file for a single-language run (default openapi.json).
- *   --server <url>     base URL written to the document's `servers`. The HTTP
- *                      endpoint derives this per request; on disk there's no
- *                      request, so pass it here or leave `servers` empty.
- *
- * Note: the spec reflects public-access marking only (no per-user access),
- * identical to the HTTP endpoint.
- */
-export declare const script: (config: SanitizedConfig) => Promise<void>;
-export {};

package/dist/bin/generateSpec.js

@@ -1,61 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import node_path from "node:path";
-import { getPayload } from "payload";
-import { PLUGIN_NAME } from "../constants.js";
-import { buildOpenApiDocument } from "../spec/build.js";
-const parseArgs = (argv)=>{
-    const args = {};
-    for(let i = 0; i < argv.length; i++){
-        const arg = argv[i];
-        if (void 0 === arg) continue;
-        const read = (key, flag)=>{
-            if (arg === flag) {
-                args[key] = argv[++i];
-                return true;
-            }
-            if (arg.startsWith(`${flag}=`)) {
-                args[key] = arg.slice(flag.length + 1);
-                return true;
-            }
-            return false;
-        };
-        if (!read('lang', '--lang')) {
-            if (!read('out', '--out')) read('server', '--server');
-        }
-    }
-    return args;
-};
-const script = async (config)=>{
-    const resolved = config.custom?.[PLUGIN_NAME];
-    if (!resolved) throw new Error(`${PLUGIN_NAME}: plugin is not registered in payload.config — no resolved options found on config.custom['${PLUGIN_NAME}'].`);
-    const payload = await getPayload({
-        config
-    });
-    const { lang, out, server } = parseArgs(process.argv);
-    const servers = server ? [
-        {
-            url: server
-        }
-    ] : void 0;
-    const fallback = config.i18n?.fallbackLanguage ?? 'en';
-    const supported = config.i18n?.supportedLanguages ? Object.keys(config.i18n.supportedLanguages) : [
-        fallback
-    ];
-    const langs = 'all' === lang ? supported : [
-        lang ?? fallback
-    ];
-    for (const language of langs){
-        const doc = await buildOpenApiDocument({
-            payload,
-            options: resolved,
-            language,
-            servers
-        });
-        const file = langs.length > 1 ? `openapi.${language}.json` : out ?? 'openapi.json';
-        await writeFile(node_path.resolve(file), `${JSON.stringify(doc, null, 2)}\n`);
-        payload.logger.info(`Wrote ${file}`);
-    }
-    await payload.destroy();
-    process.exit(0);
-};
-export { parseArgs, script };

package/dist/constants.d.ts

@@ -1 +0,0 @@
-export declare const PLUGIN_NAME = "@seshuk/payload-plugin-openapi";

package/dist/constants.js

@@ -1,2 +0,0 @@
-const PLUGIN_NAME = '@seshuk/payload-plugin-openapi';
-export { PLUGIN_NAME };