@orpc/openapi 0.18.0 → 0.19.0

package/dist/src/fetch/openapi-handler.d.ts

@@ -2,11 +2,13 @@ import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
 import type { PublicInputBuilderSimple } from './input-builder-simple';
 import { type Context, type Router, type WithSignal } from '@orpc/server';
 import { type Hooks } from '@orpc/shared';
+import { type PublicJSONSerializer } from '../json-serializer';
 import { type PublicInputBuilderFull } from './input-builder-full';
 import { type PublicOpenAPIPayloadCodec } from './openapi-payload-codec';
 import { type Hono, type PublicOpenAPIProcedureMatcher } from './openapi-procedure-matcher';
 import { type SchemaCoercer } from './schema-coercer';
 export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response, T, WithSignal> & {
+    jsonSerializer?: PublicJSONSerializer;
     procedureMatcher?: PublicOpenAPIProcedureMatcher;
     payloadCodec?: PublicOpenAPIPayloadCodec;
     inputBuilderSimple?: PublicInputBuilderSimple;

package/dist/src/fetch/openapi-payload-codec.d.ts

@@ -1,4 +1,7 @@
+import type { PublicJSONSerializer } from '../json-serializer';
 export declare class OpenAPIPayloadCodec {
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: PublicJSONSerializer);
     encode(payload: unknown, accept?: string): {
         body: FormData | Blob | string | undefined;
         headers?: Headers;
@@ -6,7 +9,6 @@ export declare class OpenAPIPayloadCodec {
     private encodeAsJSON;
     private encodeAsFormData;
     private encodeAsURLSearchParams;
-    serialize(payload: unknown): unknown;
     decode(re: Request | Response | Headers | URLSearchParams | FormData): Promise<unknown>;
 }
 export type PublicOpenAPIPayloadCodec = Pick<OpenAPIPayloadCodec, keyof OpenAPIPayloadCodec>;

package/dist/src/index.d.ts

@@ -1,3 +1,12 @@
 /** unnoq */
-export * from './generator';
+export * from './json-serializer';
+export * from './openapi';
+export * from './openapi-content-builder';
+export * from './openapi-generator';
+export * from './openapi-parameters-builder';
+export * from './openapi-path-parser';
+export * from './schema';
+export * from './schema-converter';
+export * from './schema-utils';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/json-serializer.d.ts

@@ -0,0 +1,5 @@
+export declare class JSONSerializer {
+    serialize(payload: unknown): unknown;
+}
+export type PublicJSONSerializer = Pick<JSONSerializer, keyof JSONSerializer>;
+//# sourceMappingURL=json-serializer.d.ts.map

package/dist/src/openapi-content-builder.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPI } from './openapi';
+import type { JSONSchema } from './schema';
+import type { PublicSchemaUtils } from './schema-utils';
+export declare class OpenAPIContentBuilder {
+    private readonly schemaUtils;
+    constructor(schemaUtils: PublicSchemaUtils);
+    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
+}
+export type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
+//# sourceMappingURL=openapi-content-builder.d.ts.map

package/dist/src/openapi-generator.d.ts

@@ -0,0 +1,51 @@
+import type { ContractRouter } from '@orpc/contract';
+import type { ANY_ROUTER } from '@orpc/server';
+import type { PublicOpenAPIPathParser } from './openapi-path-parser';
+import type { SchemaConverter } from './schema-converter';
+import { type PublicJSONSerializer } from './json-serializer';
+import { type OpenAPI } from './openapi';
+import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
+import { type PublicOpenAPIParametersBuilder } from './openapi-parameters-builder';
+import { type PublicSchemaUtils } from './schema-utils';
+export interface OpenAPIGeneratorOptions {
+    contentBuilder?: PublicOpenAPIContentBuilder;
+    parametersBuilder?: PublicOpenAPIParametersBuilder;
+    schemaConverters?: SchemaConverter[];
+    schemaUtils?: PublicSchemaUtils;
+    jsonSerializer?: PublicJSONSerializer;
+    pathParser?: PublicOpenAPIPathParser;
+    /**
+     * Throw error when you missing define tag definition on OpenAPI root tags
+     *
+     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
+     * Because OpenAPI root tags is missing 'bar' tag
+     *
+     * @default false
+     */
+    considerMissingTagDefinitionAsError?: boolean;
+    /**
+     * Weather ignore procedures that has no path defined.
+     *
+     * @default false
+     */
+    ignoreUndefinedPathProcedures?: boolean;
+    /**
+     * Throw error when you have error in OpenAPI generator
+     *
+     * @default false
+     */
+    throwOnError?: boolean;
+}
+export declare class OpenAPIGenerator {
+    private readonly options?;
+    private readonly contentBuilder;
+    private readonly parametersBuilder;
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly jsonSerializer;
+    private readonly pathParser;
+    constructor(options?: OpenAPIGeneratorOptions | undefined);
+    generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
+    private handleError;
+}
+//# sourceMappingURL=openapi-generator.d.ts.map

package/dist/src/openapi-parameters-builder.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPI } from './openapi';
+import type { JSONSchema } from './schema';
+export declare class OpenAPIParametersBuilder {
+    build(paramIn: OpenAPI.ParameterObject['in'], jsonSchema: JSONSchema.JSONSchema & {
+        type: 'object';
+    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.ParameterObject[];
+}
+export type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
+//# sourceMappingURL=openapi-parameters-builder.d.ts.map

package/dist/src/openapi-path-parser.d.ts

@@ -0,0 +1,8 @@
+export declare class OpenAPIPathParser {
+    parseDynamicParams(path: string): {
+        name: string;
+        raw: string;
+    }[];
+}
+export type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
+//# sourceMappingURL=openapi-path-parser.d.ts.map

package/dist/src/openapi.d.ts

@@ -0,0 +1,3 @@
+export { OpenApiBuilder } from 'openapi3-ts/oas31';
+export type * as OpenAPI from 'openapi3-ts/oas31';
+//# sourceMappingURL=openapi.d.ts.map

package/dist/src/schema-converter.d.ts

@@ -0,0 +1,16 @@
+import type { Schema } from '@orpc/contract';
+import type { JSONSchema } from './schema';
+export interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+}
+export interface SchemaConverter {
+    condition: (schema: Schema, options: SchemaConvertOptions) => boolean;
+    convert: (schema: Schema, options: SchemaConvertOptions) => JSONSchema.JSONSchema;
+}
+export declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: SchemaConverter[]);
+    condition(): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+//# sourceMappingURL=schema-converter.d.ts.map

package/dist/src/schema-utils.d.ts

@@ -0,0 +1,11 @@
+import { type FileSchema, type JSONSchema, type ObjectSchema } from './schema';
+export declare class SchemaUtils {
+    isFileSchema(schema: JSONSchema.JSONSchema): schema is FileSchema;
+    isObjectSchema(schema: JSONSchema.JSONSchema): schema is ObjectSchema;
+    isAnySchema(schema: JSONSchema.JSONSchema): boolean;
+    isUndefinableSchema(schema: JSONSchema.JSONSchema): boolean;
+    separateObjectSchema(schema: ObjectSchema, separatedProperties: string[]): [matched: ObjectSchema, rest: ObjectSchema];
+    filterSchemaBranches(schema: JSONSchema.JSONSchema, check: (schema: JSONSchema.JSONSchema) => boolean, matches?: JSONSchema.JSONSchema[]): [matches: JSONSchema.JSONSchema[], rest: JSONSchema.JSONSchema | undefined];
+}
+export type PublicSchemaUtils = Pick<SchemaUtils, keyof SchemaUtils>;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/schema.d.ts

@@ -0,0 +1,12 @@
+import * as JSONSchema from 'json-schema-typed/draft-2020-12';
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+export { JSONSchema };
+export type ObjectSchema = JSONSchema.JSONSchema & {
+    type: 'object';
+} & object;
+export type FileSchema = JSONSchema.JSONSchema & {
+    type: 'string';
+    contentMediaType: string;
+} & object;
+export declare const NON_LOGIC_KEYWORDS: ("$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "contentEncoding" | "contentMediaType" | "default" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly")[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

@@ -13,5 +13,6 @@ export interface EachContractLeafResultItem {
     path: string[];
 }
 export declare function forEachContractProcedure(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+export declare function forEachAllContractProcedure(router: ContractRouter | ANY_ROUTER, callback: (options: EachLeafCallbackOptions) => void): Promise<void>;
 export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -43,9 +43,9 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/shared": "0.18.0",
-    "@orpc/contract": "0.18.0",
-    "@orpc/server": "0.18.0"
+    "@orpc/contract": "0.19.0",
+    "@orpc/server": "0.19.0",
+    "@orpc/shared": "0.19.0"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",