@povio/openapi-codegen-cli 2.0.8-rc.2 → 2.0.8-rc.20

package/dist/generator.d.mts

@@ -0,0 +1,65 @@
+import { n as GenerateFileData, t as GenerateOptions } from "./options-BNqkO_OS.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-DZ5swy4U.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,230 @@
+import { a as GeneralErrorCodes, i as ErrorHandlerOptions, n as ErrorEntry, o as SharedErrorHandler, r as ErrorHandler, t as ApplicationException } from "./error-handling-CXeVTk1T.mjs";
+import "./options-BNqkO_OS.mjs";
+import { t as OpenAPICodegenConfig } from "./config-BHkVxL6S.mjs";
+import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosResponseHeaders, CreateAxiosDefaults } from "axios";
+import { z } from "zod";
+import "i18next";
+import * as react from "react";
+import { PropsWithChildren, ReactNode } from "react";
+import { InfiniteData, QueryKey, UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#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/queryConfig.context.d.ts
+type QueryModule = string | number | symbol;
+type InvalidationMapFunc<TData = any, TVariables = any> = (data: TData, variables: TVariables) => QueryKey[];
+type InvalidationMap<TQueryModule extends QueryModule = QueryModule, TData = any, TVariables = any> = Partial<Record<TQueryModule, InvalidationMapFunc<TData, TVariables>>>;
+declare namespace OpenApiQueryConfig {
+  export interface Type<TQueryModule extends QueryModule = QueryModule> {
+    preferUpdate?: boolean;
+    invalidateCurrentModule?: boolean;
+    invalidationMap?: InvalidationMap<TQueryModule>;
+    crossTabInvalidation?: boolean;
+    onError?: (error: unknown) => void;
+  }
+  type ProviderProps<TQueryModule extends QueryModule = QueryModule> = Type<TQueryModule>;
+  export function Provider<TQueryModule extends QueryModule = QueryModule>({
+    preferUpdate,
+    invalidateCurrentModule,
+    invalidationMap,
+    crossTabInvalidation,
+    onError,
+    children
+  }: PropsWithChildren<ProviderProps<TQueryModule>>): react_jsx_runtime0.JSX.Element;
+  export const useConfig: <TQueryModule extends QueryModule = QueryModule>() => Type<TQueryModule>;
+  export {};
+}
+//#endregion
+//#region src/lib/react-query/useMutationEffects.d.ts
+interface MutationEffectsOptions<TQueryModule extends QueryModule = QueryModule> {
+  invalidateCurrentModule?: boolean;
+  crossTabInvalidation?: boolean;
+  invalidationMap?: InvalidationMap<TQueryModule>;
+  invalidateModules?: TQueryModule[];
+  invalidateKeys?: QueryKey[];
+  preferUpdate?: boolean;
+}
+interface UseMutationEffectsProps<TQueryModule extends QueryModule = QueryModule> {
+  currentModule: TQueryModule;
+}
+declare function useMutationEffects<TQueryModule extends QueryModule = QueryModule>({
+  currentModule
+}: UseMutationEffectsProps<TQueryModule>): {
+  runMutationEffects: <TData, TVariables>(data: TData, variables: TVariables, options?: MutationEffectsOptions<TQueryModule>, updateKeys?: QueryKey[]) => Promise<void>;
+};
+//#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/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, type InvalidationMapFunc, type MutationEffectsOptions, OpenAPICodegenConfig, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, type QueryModule, type RequestConfig, type RequestInfo, type Response, RestClient$1 as RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources, useMutationEffects };