genoc 0.4.3 → 0.5.0

package/dist/runtime/requester.d.ts

@@ -1,14 +1,81 @@
 import type { ErrorResponse, StreamResponse } from './responses.js';
+/**
+ * OAuth 2.0 flow configuration, spec-agnostic structural twin of the OpenAPI
+ * OAuth Flow Object. Which URLs are meaningful depends on the flow kind.
+ */
+export type OAuthFlow = {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+};
+/**
+ * OAuth 2.0 flows, spec-agnostic structural twin of the OpenAPI OAuth Flows
+ * Object.
+ */
+export type OAuthFlows = {
+    implicit?: OAuthFlow;
+    password?: OAuthFlow;
+    clientCredentials?: OAuthFlow;
+    authorizationCode?: OAuthFlow;
+};
+/**
+ * Spec-agnostic structural twin of an OpenAPI security scheme object,
+ * discriminated on `type` so implementations can narrow.
+ */
+export type SecurityScheme = {
+    type: 'apiKey';
+    name: string;
+    in: string;
+    description?: string;
+} | {
+    type: 'http';
+    scheme: string;
+    bearerFormat?: string;
+    description?: string;
+} | {
+    type: 'oauth2';
+    flows: OAuthFlows;
+    description?: string;
+} | {
+    type: 'openIdConnect';
+    openIdConnectUrl: string;
+    description?: string;
+} | {
+    type: 'mutualTLS';
+    description?: string;
+};
+/**
+ * One scheme invocation inside a security requirement: the scheme name as
+ * declared in the spec, the scopes requested for it, and the resolved scheme
+ * object.
+ */
+export type SecurityCall = {
+    schemeName: string;
+    scopes: readonly string[];
+    scheme: SecurityScheme;
+};
+/**
+ * One security alternative. Several `SecurityCall`s inside one requirement are
+ * conjunctive — all must be satisfied.
+ */
+export type SecurityRequirement = readonly SecurityCall[];
 /**
  * Performs an HTTP request and returns the response.
  *
  * When `expectStream` is true, the implementation should return
  * a `StreamResponse` containing the stream data, filename (from
  * Content-Disposition header), and response headers.
+ *
+ * When `security` is present, it carries the operation's security requirements
+ * as an OR-list of AND-alternatives (spec `security` semantics): satisfying any
+ * one requirement authorizes the request. Each call carries the fully resolved
+ * scheme object. Absent `security` means the operation is public.
  */
 export type Requester = <TResponse>(method: string, path: string, options: {
     query?: Record<string, unknown>;
     body?: unknown;
     headers?: Record<string, string>;
     expectStream?: true;
+    security?: readonly SecurityRequirement[];
 }) => Promise<TResponse | StreamResponse | ErrorResponse>;

package/dist/types/openapi.d.ts

@@ -72,7 +72,7 @@ export type OperationObject = {
     requestBody?: RequestBodyObject | ReferenceObject;
     responses: ResponsesObject;
     deprecated?: boolean;
-    security?: unknown[];
+    security?: SecurityRequirementObject[];
     servers?: unknown[];
 };
 export type PathItemObject = {
@@ -140,8 +140,9 @@ export type OAuth2FlowsObject = {
     clientCredentials?: OAuth2FlowClientCredentials;
     authorizationCode?: OAuth2FlowAuthorizationCode;
 };
+export type SecurityRequirementObject = Record<string, string[]>;
 export type SecuritySchemeObject = {
-    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect' | 'mutualTLS';
     description?: string;
     name?: string;
     in?: 'query' | 'header' | 'cookie';
@@ -156,7 +157,7 @@ export type ComponentsObject = {
     parameters?: Record<string, ParameterObject | ReferenceObject>;
     requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
     headers?: Record<string, unknown>;
-    securitySchemes?: Record<string, SecuritySchemeObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
     links?: Record<string, unknown>;
     callbacks?: Record<string, unknown>;
     examples?: Record<string, unknown>;
@@ -167,7 +168,7 @@ export type OpenAPIDocument = {
     servers?: ServerObject[];
     paths?: PathsObject;
     components?: ComponentsObject;
-    security?: unknown[];
+    security?: SecurityRequirementObject[];
     tags?: unknown[];
     externalDocs?: {
         description?: string;

package/dist/utils/http-methods.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The eight OpenAPI Operation Object HTTP methods, in canonical generation
+ * order (the order methods appear in generated clients).
+ *
+ * Single source shared by the analyzer (path-item iteration) and the
+ * validators (per-operation checks) — do not inline local copies.
+ */
+export declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete", "options", "head", "trace"];

package/dist/utils/http-methods.js

@@ -0,0 +1,17 @@
+/**
+ * The eight OpenAPI Operation Object HTTP methods, in canonical generation
+ * order (the order methods appear in generated clients).
+ *
+ * Single source shared by the analyzer (path-item iteration) and the
+ * validators (per-operation checks) — do not inline local copies.
+ */
+export const HTTP_METHODS = [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'options',
+    'head',
+    'trace',
+];

package/dist/utils/operation-naming.js

@@ -44,6 +44,7 @@ export const RESERVED_TYPE_NAMES = new Set([
     ...RUNTIME_CLASS_NAMES,
     ...CLIENT_SURFACE_NAMES,
     'FileInput',
+    'SecuritySchemeName',
 ]);
 /**
  * Build a PascalCase type-name prefix from an operation's method + path.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genoc",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Generate typed HTTP clients from OpenAPI 3.0 / 3.1 specifications",
   "keywords": [
     "client",