@povio/openapi-codegen-cli 2.0.8-rc.5 → 2.0.8-rc.8

package/dist/generator.d.mts

@@ -0,0 +1,65 @@
+import { n as GenerateFileData, t as GenerateOptions } from "./options-DBz5YE3s.mjs";
+import { OpenAPIV3 } from "openapi-types";
+
+//#region src/generators/types/metadata.d.ts
+interface GenerateParams {
+  input: string;
+  options?: Partial<GenerateOptions>;
+}
+interface TsTypeBase {
+  type: string;
+  namespace?: string;
+  importPath?: string;
+}
+type TsType = TsTypeBase & TsMetaType;
+type TsPropertyBase = {
+  name: string;
+  isRequired: boolean;
+} & TsTypeBase;
+type TsProperty = TsPropertyBase & TsMetaType;
+interface TsPrimitiveMetaType {
+  metaType: "primitive";
+}
+interface TsObjectMetaType {
+  metaType: "object";
+  objectProperties: TsProperty[];
+  isCircular?: boolean;
+}
+interface TsArrayMetaType {
+  metaType: "array";
+  arrayType: TsType;
+}
+interface TsCompositeMetaType {
+  metaType: "composite";
+  allOf?: TsType[];
+  oneOf?: TsType[];
+  anyOf?: TsType[];
+}
+type TsMetaType = TsPrimitiveMetaType | TsObjectMetaType | TsArrayMetaType | TsCompositeMetaType;
+type ModelMetadata = TsType;
+type QueryMetadata = {
+  name: string;
+  importPath: string;
+  namespace?: string;
+  isQuery: boolean;
+  isMutation: boolean;
+  params: TsProperty[];
+  response: TsType;
+};
+interface GenerateMetadata {
+  openApiDoc: OpenAPIV3.Document;
+  models: ModelMetadata[];
+  queries: QueryMetadata[];
+}
+//#endregion
+//#region src/generator.d.ts
+declare function getGenerateMetadata({
+  input,
+  options: genOptions
+}: GenerateParams): Promise<GenerateMetadata>;
+declare function getGenerateFilesData({
+  input,
+  options: genOptions
+}: GenerateParams): Promise<GenerateFileData[]>;
+//#endregion
+export { getGenerateFilesData, getGenerateMetadata };

package/dist/generator.mjs

@@ -0,0 +1,144 @@
+import { _ as isMediaTypeAllowed, b as formatTag, c as getSchemaTsMetaType, d as getTagImportPath, f as getQueryName, h as GenerateType, i as getDataFromOpenAPIDoc, l as getTsTypeBase, m as getNamespaceName, o as isMutation, p as DEFAULT_GENERATE_OPTIONS, s as isQuery, t as generateCodeFromOpenAPIDoc, v as isParamMediaTypeAllowed, y as invalidVariableNameCharactersToCamel } from "./generateCodeFromOpenAPIDoc-B5lnFNGB.mjs";
+import SwaggerParser from "@apidevtools/swagger-parser";
+
+//#region src/generators/core/getMetadataFromOpenAPIDoc.ts
+async function getMetadataFromOpenAPIDoc(openApiDoc, options) {
+	const { resolver, data } = await getDataFromOpenAPIDoc(openApiDoc, options);
+	const models = [];
+	const queries = [];
+	data.forEach(({ endpoints, zodSchemas }, dataTag) => {
+		Object.keys(zodSchemas).forEach((zodSchemaName) => {
+			const ref = resolver.getRefByZodSchemaName(zodSchemaName);
+			const schema = ref ? resolver.getSchemaByRef(ref) : resolver.getSchemaByCompositeZodSchemaName(zodSchemaName);
+			const tsTypeInfo = getTsTypeBase({
+				zodSchemaName,
+				schema,
+				resolver
+			});
+			let tsMetaType;
+			if (schema) tsMetaType = getSchemaTsMetaType({
+				schema,
+				parentTypes: [tsTypeInfo],
+				resolver
+			});
+			models.push({
+				...tsTypeInfo,
+				metaType: "primitive",
+				...tsMetaType
+			});
+		});
+		endpoints.forEach((endpoint) => {
+			const generateType = GenerateType.Queries;
+			const tag = formatTag(dataTag);
+			queries.push({
+				name: getQueryName(endpoint),
+				importPath: getTagImportPath({
+					type: generateType,
+					tag,
+					includeTagDir: true,
+					options
+				}),
+				namespace: options.tsNamespaces ? getNamespaceName({
+					type: generateType,
+					tag,
+					options
+				}) : void 0,
+				isQuery: isQuery(endpoint),
+				isMutation: isMutation(endpoint),
+				params: getQueryMetadataParams({
+					resolver,
+					endpoint
+				}),
+				response: getQueryMetadataResponse({
+					resolver,
+					endpoint
+				})
+			});
+		});
+	});
+	return {
+		openApiDoc,
+		models,
+		queries
+	};
+}
+function getQueryMetadataParams({ resolver, endpoint }) {
+	return endpoint.parameters.map((param) => {
+		let schema;
+		if (param.parameterObject?.schema) schema = resolver.resolveObject(param.parameterObject.schema);
+		else if (param.bodyObject) {
+			const matchingMediaType = Object.keys(param.bodyObject.content ?? {}).find(isParamMediaTypeAllowed);
+			if (matchingMediaType) schema = resolver.resolveObject(param.bodyObject.content?.[matchingMediaType]?.schema);
+		}
+		const tsTypeInfo = getTsTypeBase({
+			zodSchemaName: param.zodSchema,
+			schema,
+			resolver
+		});
+		let tsMetaType;
+		if (schema) tsMetaType = getSchemaTsMetaType({
+			schema,
+			parentTypes: [tsTypeInfo],
+			resolver
+		});
+		return {
+			name: invalidVariableNameCharactersToCamel(param.name),
+			isRequired: param.parameterObject?.required ?? true,
+			...tsTypeInfo,
+			...tsMetaType,
+			paramType: param.type
+		};
+	}).toSorted((a, b) => {
+		if (a.isRequired === b.isRequired) {
+			const sortedParamTypes = [
+				"Path",
+				"Body",
+				"Query",
+				"Header"
+			];
+			return sortedParamTypes.indexOf(a.paramType) - sortedParamTypes.indexOf(b.paramType);
+		}
+		return a.isRequired ? -1 : 1;
+	}).map(({ paramType: _paramType, ...queryParam }) => queryParam);
+}
+function getQueryMetadataResponse({ resolver, endpoint }) {
+	let schema;
+	const matchingMediaType = Object.keys(endpoint.responseObject?.content ?? {}).find(isMediaTypeAllowed);
+	if (matchingMediaType) schema = resolver.resolveObject(endpoint.responseObject?.content?.[matchingMediaType]?.schema);
+	const tsTypeInfo = getTsTypeBase({
+		zodSchemaName: endpoint.response,
+		schema,
+		resolver
+	});
+	let tsMetaType;
+	if (schema) tsMetaType = getSchemaTsMetaType({
+		schema,
+		parentTypes: [tsTypeInfo],
+		resolver
+	});
+	return {
+		...tsTypeInfo,
+		metaType: "primitive",
+		...tsMetaType
+	};
+}
+
+//#endregion
+//#region src/generator.ts
+async function getGenerateMetadata({ input, options: genOptions }) {
+	const options = {
+		...DEFAULT_GENERATE_OPTIONS,
+		...genOptions
+	};
+	return await getMetadataFromOpenAPIDoc(await SwaggerParser.bundle(input), options);
+}
+async function getGenerateFilesData({ input, options: genOptions }) {
+	const options = {
+		...DEFAULT_GENERATE_OPTIONS,
+		...genOptions
+	};
+	return generateCodeFromOpenAPIDoc(await SwaggerParser.bundle(input), options);
+}
+
+//#endregion
+export { getGenerateFilesData, getGenerateMetadata };

package/dist/index.d.mts

@@ -0,0 +1,246 @@
+import "./options-DBz5YE3s.mjs";
+import { t as OpenAPICodegenConfig } from "./config-Cu_GYfai.mjs";
+import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosResponseHeaders, CreateAxiosDefaults } from "axios";
+import { z } from "zod";
+import { TFunction } from "i18next";
+import * as react from "react";
+import { PropsWithChildren, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { InfiniteData, QueryKey, UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+
+//#region src/lib/rest/error-handling.d.ts
+type GeneralErrorCodes = "DATA_VALIDATION_ERROR" | "NETWORK_ERROR" | "CANCELED_ERROR" | "INTERNAL_ERROR" | "UNKNOWN_ERROR";
+declare class ApplicationException<CodeT> extends Error {
+  code: CodeT;
+  serverMessage: string | null;
+  constructor(message: string, code: CodeT, serverMessage: string | null);
+}
+interface ErrorEntry<CodeT> {
+  code: CodeT;
+  condition?: (error: unknown) => boolean;
+  getMessage: (t: TFunction, error: unknown) => string;
+}
+interface ErrorHandlerOptions<CodeT extends string> {
+  entries: ErrorEntry<CodeT>[];
+  t?: TFunction;
+  onRethrowError?: (error: unknown, exception: ApplicationException<CodeT | GeneralErrorCodes>) => void;
+}
+declare class ErrorHandler<CodeT extends string> {
+  entries: ErrorEntry<CodeT | GeneralErrorCodes>[];
+  private t;
+  private onRethrowError?;
+  constructor({
+    entries,
+    t,
+    onRethrowError
+  }: ErrorHandlerOptions<CodeT>);
+  private matchesEntry;
+  setTranslateFunction(t: TFunction): void;
+  rethrowError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes>;
+  getError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes> | null;
+  getErrorCode(error: unknown): CodeT | GeneralErrorCodes | null;
+  static getErrorMessage(error: unknown, fallbackToUnknown?: boolean): string | null;
+}
+declare const SharedErrorHandler: ErrorHandler<never>;
+//#endregion
+//#region src/lib/rest/rest-interceptor.d.ts
+declare class RestInterceptor<T extends any[]> {
+  private applyInterceptor;
+  private interceptorIdMap;
+  constructor(applyInterceptor: (client: AxiosInstance, ...args: T) => number);
+  addInterceptor(client: AxiosInstance, ...args: T): void;
+  removeInterceptor(client: AxiosInstance): void;
+}
+//#endregion
+//#region src/lib/rest/rest-client.types.d.ts
+type GeneralErrorCodes$1 = string;
+interface RequestInfo<ZOutput, ECodes extends string> {
+  resSchema: z.ZodType<ZOutput>;
+  errorHandler?: ErrorHandler<ECodes>;
+}
+interface RequestConfig<IsRawRes extends boolean = false> {
+  rawResponse?: IsRawRes;
+}
+type Response<ZOutput, IsRawRes extends boolean = false> = IsRawRes extends true ? AxiosResponse<ZOutput> : ZOutput;
+interface RestClient {
+  attachInterceptors<T extends any[]>(interceptors?: RestInterceptor<T>[], ...args: T): void;
+  attachInterceptor<T extends any[]>(interceptor: RestInterceptor<T>, ...args: T): void;
+  ejectInterceptor<T extends any[]>(interceptor: RestInterceptor<T>): void;
+  get<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  post<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  patch<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  put<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  delete<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+}
+//#endregion
+//#region src/lib/rest/rest-client.d.ts
+declare class RestClient$1 implements RestClient {
+  private readonly client;
+  private readonly errorHandler;
+  constructor({
+    config,
+    interceptors,
+    errorHandler
+  }?: {
+    config?: CreateAxiosDefaults;
+    interceptors?: RestInterceptor<any[]>[];
+    errorHandler?: ErrorHandler<any>;
+  });
+  attachInterceptors<T extends any[]>(interceptors?: RestInterceptor<T>[], ...args: T): void;
+  attachInterceptor<T extends any[]>(interceptor: RestInterceptor<T>, ...args: T): void;
+  ejectInterceptor<T extends any[]>(interceptor: RestInterceptor<T>): void;
+  get<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  post<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  patch<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  put<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  delete<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  private makeRequest;
+}
+//#endregion
+//#region src/lib/rest/rest.utils.d.ts
+declare namespace RestUtils {
+  const extractServerResponseCode: (e: unknown) => string | null;
+  const doesServerErrorMessageContain: (e: AxiosError, text: string) => boolean;
+  const extractServerErrorMessage: (e: unknown) => string | null;
+  const extractContentDispositionFilename: (headers: AxiosResponseHeaders) => string | undefined;
+}
+//#endregion
+//#region src/lib/react-query.types.d.ts
+type Function = (...args: any) => any;
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type IsAny<T> = IfAny<T, true, never>;
+type IsUnknown<T, Y, N = T> = IsAny<T> extends never ? (unknown extends T ? Y : N) : N;
+type AppQueryOptions<TFunction extends Function, TData = Awaited<ReturnType<TFunction>>, TErrorCodes = GeneralErrorCodes> = Omit<UseQueryOptions<Awaited<ReturnType<TFunction>>, ApplicationException<TErrorCodes>, IsUnknown<TData, Awaited<ReturnType<TFunction>>>>, "queryKey" | "queryFn">;
+type AppMutationOptions<TFunction extends Function, TVariables = void, TData = Awaited<ReturnType<TFunction>>, TErrorCodes = GeneralErrorCodes> = Omit<UseMutationOptions<TData, ApplicationException<TErrorCodes>, TVariables>, "mutationKey" | "mutationFn">;
+type AppInfiniteQueryOptions<TFunction extends Function, TData = InfiniteData<Awaited<ReturnType<TFunction>>>, TErrorCodes = GeneralErrorCodes, TQueryKey extends QueryKey = QueryKey, TPageParam = number> = Omit<UseInfiniteQueryOptions<Awaited<ReturnType<TFunction>>, ApplicationException<TErrorCodes>, IsUnknown<TData, InfiniteData<Awaited<ReturnType<TFunction>>>>, TQueryKey, TPageParam>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+//#endregion
+//#region src/lib/config/router.context.d.ts
+interface RouterProviderProps {
+  replace: (url: string) => void;
+}
+declare namespace OpenApiRouter {
+  const Provider: ({
+    children,
+    replace
+  }: PropsWithChildren<RouterProviderProps>) => react_jsx_runtime0.JSX.Element;
+  const useRouter: () => RouterProviderProps;
+}
+//#endregion
+//#region src/lib/config/queryConfig.context.d.ts
+type QueryModule = string | number | symbol;
+type InvalidationMapFunc<TData = any, TVariables = any> = (data: TData, variables: TVariables) => QueryKey[];
+type InvalidationMap<TData = any, TVariables = any> = Record<QueryModule, InvalidationMapFunc<TData, TVariables>>;
+declare namespace OpenApiQueryConfig {
+  interface Type {
+    preferUpdate?: boolean;
+    invalidateCurrentModule?: boolean;
+    invalidationMap?: InvalidationMap;
+    crossTabInvalidation?: boolean;
+    onError?: (error: unknown) => void;
+  }
+  type ProviderProps = Type;
+  export const Provider: ({
+    preferUpdate,
+    invalidateCurrentModule,
+    invalidationMap,
+    crossTabInvalidation,
+    onError,
+    children
+  }: PropsWithChildren<ProviderProps>) => react_jsx_runtime0.JSX.Element;
+  export const useConfig: () => Type;
+  export {};
+}
+//#endregion
+//#region src/lib/config/workspace.context.d.ts
+type WorkspaceValues = Record<string, unknown>;
+interface WorkspaceProviderProps {
+  values?: WorkspaceValues;
+}
+declare namespace OpenApiWorkspaceContext {
+  const Provider: ({
+    values,
+    children
+  }: PropsWithChildren<WorkspaceProviderProps>) => react_jsx_runtime0.JSX.Element;
+  const useContext: () => WorkspaceValues;
+  const resolveParam: <T>(context: WorkspaceValues, name: string, value: T | null | undefined) => T;
+}
+//#endregion
+//#region src/lib/config/i18n.d.ts
+declare const ns = "openapi";
+declare const resources: {
+  readonly en: {
+    readonly openapi: {
+      openapi: {
+        sharedErrors: {
+          dataValidation: string;
+          internalError: string;
+          networkError: string;
+          canceledError: string;
+          unknownError: string;
+          unknownErrorWithCode: string;
+        };
+      };
+    };
+  };
+  readonly sl: {
+    readonly openapi: {
+      openapi: {
+        sharedErrors: {
+          dataValidation: string;
+          internalError: string;
+          networkError: string;
+          canceledError: string;
+          unknownError: string;
+          unknownErrorWithCode: string;
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/lib/auth/auth.context.d.ts
+declare namespace AuthContext {
+  export interface Routes {
+    authenticated?: string;
+    unauthenticated?: string;
+  }
+  interface Type<TUser = unknown> {
+    isAuthenticated: boolean;
+    isInitializing: boolean;
+    logout: () => void;
+    updateTokens?: (accessToken: string | null, refreshToken?: string | null) => void;
+    accessToken?: string | null;
+    user?: TUser | null;
+    userPromise?: () => Promise<TUser | null>;
+    routes?: Routes;
+    loadingState?: ReactNode;
+  }
+  type ProviderProps<TUser = unknown> = Type<TUser>;
+  export const Provider: <TUser>({
+    isAuthenticated,
+    isInitializing,
+    logout,
+    updateTokens,
+    accessToken,
+    user,
+    userPromise,
+    routes,
+    loadingState,
+    children
+  }: PropsWithChildren<ProviderProps<TUser>>) => react_jsx_runtime0.JSX.Element;
+  export const useAuth: <TUser>() => Type<TUser>;
+  export {};
+}
+//#endregion
+//#region src/lib/auth/AuthGuard.d.ts
+interface AuthGuardProps {
+  type: "public-only" | "private";
+  redirectTo?: string;
+}
+declare const AuthGuard: ({
+  type,
+  redirectTo,
+  children
+}: PropsWithChildren<AuthGuardProps>) => react.ReactNode;
+//#endregion
+export { type AppInfiniteQueryOptions, type AppMutationOptions, type AppQueryOptions, ApplicationException, AuthContext, AuthGuard, type AuthGuardProps, type ErrorEntry, ErrorHandler, type ErrorHandlerOptions, type GeneralErrorCodes, type RestClient as IRestClient, type InvalidationMap, OpenAPICodegenConfig, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, type RequestConfig, type RequestInfo, type Response, RestClient$1 as RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources };