@povio/openapi-codegen-cli 0.16.0 → 1.0.1

package/README.md

@@ -2,6 +2,8 @@
 
 **NOTE:** This CLI tool is primarily designed for use within our organization. The generated code output aligns with our internal template. If you are using this tool without our internal template, make sure to use it in **standalone** mode.
 
+**NOTE:** Version 1+ requires zod v4 and is not compatible with zod v3.
+
 Use this tool to generate code (Zod schemas, TypeScript types, API definitions, and React queries) from an OpenAPI v3 specification. API definitions are generated to use a REST client wrapper that utilizes Axios. React queries are generated in alignment with our code standards, without the need for explicit types.
 
 The tool partially leverages code from [openapi-zod-client](https://github.com/astahmer/openapi-zod-client) repository.
@@ -84,7 +86,6 @@ yarn openapi-codegen generate --config my-config.ts
   --importPath                        Module import style for generated files (default: 'ts'; options: 'ts' | 'relative' | 'absolute')
   --removeOperationPrefixEndingWith   Remove operation name prefixes that end with the specified string (Default: 'Controller_')
   --extractEnums                      Extract enums into separate Zod schemas (default: true)
-  --branded                           Apply branded types to ambiguous Zod schemas (default: true)
   --replaceOptionalWithNullish        Replace `.optional()` chains with `.nullish()` in generated Zod schemas (default: false)
 
   --axiosRequestConfig                Include Axios request config parameters in query hooks (default: false)

package/dist/commands/check.d.ts

@@ -4,4 +4,4 @@ export type CheckParams = {
     excludeTags?: string;
     verbose?: boolean;
 } & Partial<Pick<GenerateOptions, "input" | "splitByTags" | "defaultTag">>;
-export declare function check({ verbose, ...params }: CheckParams): Promise<void>;
+export declare function check({ verbose, config: configParam, excludeTags: excludeTagsParam, ...params }: CheckParams): Promise<void>;

package/dist/commands/generate.d.ts

@@ -4,5 +4,5 @@ export type GenerateParams = {
     excludeTags?: string;
     prettier?: boolean;
     verbose?: boolean;
-} & Partial<Pick<GenerateOptions, "input" | "output" | "tsNamespaces" | "splitByTags" | "defaultTag" | "removeOperationPrefixEndingWith" | "importPath" | "extractEnums" | "acl" | "checkAcl" | "standalone" | "baseUrl" | "branded" | "replaceOptionalWithNullish" | "infiniteQueries" | "axiosRequestConfig" | "mutationEffects" | "parseRequestParams">>;
-export declare function generate({ prettier, verbose, ...params }: GenerateParams): Promise<void>;
+} & Partial<Pick<GenerateOptions, "input" | "output" | "tsNamespaces" | "splitByTags" | "defaultTag" | "removeOperationPrefixEndingWith" | "importPath" | "extractEnums" | "acl" | "checkAcl" | "standalone" | "baseUrl" | "replaceOptionalWithNullish" | "infiniteQueries" | "axiosRequestConfig" | "mutationEffects" | "parseRequestParams">>;
+export declare function generate({ prettier, verbose, config: configParam, ...params }: GenerateParams): Promise<void>;

package/dist/generators/const/deps.const.d.ts

@@ -36,12 +36,11 @@ export declare const MUTATION_EFFECTS: {
     runFunctionName: string;
 };
 export declare const MUTATION_EFFECTS_FILE: GenerateFile;
-export declare const ZOD_UTILS: {
+export declare const ZOD_EXTENDED: {
     namespace: string;
     exports: {
         parse: string;
         sortExp: string;
-        brand: string;
     };
 };
-export declare const ZOD_UTILS_FILE: GenerateFile;
+export declare const ZOD_EXTENDED_FILE: GenerateFile;

package/dist/generators/const/zod.const.d.ts

@@ -8,5 +8,11 @@ export declare const ERROR_RESPONSE_SCHEMA_SUFFIX = "ErrorResponse";
 export declare const VOID_SCHEMA = "z.void()";
 export declare const BLOB_SCHEMA = "z.instanceof(Blob)";
 export declare const ENUM_SCHEMA = "z.enum";
+export declare const INT_SCHEMA = "z.int()";
+export declare const NUMBER_SCHEMA = "z.number()";
 export declare const STRING_SCHEMA = "z.string()";
+export declare const EMAIL_SCHEMA = "z.email()";
+export declare const URL_SCHEMA = "z.url()";
+export declare const UUID_SCHEMA = "z.uuid()";
+export declare const DATETIME_SCHEMA = "z.iso.datetime({ offset: true })";
 export declare const ZOD_IMPORT: Import;

package/dist/generators/core/resolveConfig.d.ts

@@ -0,0 +1,7 @@
+import { GenerateOptions } from "src/generators/types/options";
+export declare function resolveConfig({ fileConfig, params: { excludeTags, ...options }, }: {
+    fileConfig?: Partial<GenerateOptions> | null;
+    params: Partial<Omit<GenerateOptions, "excludeTags"> & {
+        excludeTags: string;
+    }>;
+}): GenerateOptions;

package/dist/generators/generate/generateZodExtended.d.ts

@@ -0,0 +1,2 @@
+import { SchemaResolver } from "src/generators/core/SchemaResolver.class";
+export declare function generateZodExtended(resolver: SchemaResolver): string;

package/dist/generators/types/common.d.ts

@@ -0,0 +1,27 @@
+export type ObjectLiteral<T = any> = Record<string, T>;
+export type List<A = any> = ReadonlyArray<A>;
+export type Length<L extends List> = L["length"];
+/**
+Represents an array of strings split using a given character or character set.
+
+Use-case: Defining the return type of a method like `String.prototype.split`.
+
+@example
+```
+declare function split<S extends string, D extends string>(string: S, separator: D): Split<S, D>;
+
+type Item = 'foo' | 'bar' | 'baz' | 'waldo';
+const items = 'foo,bar,baz,waldo';
+let array: Item[];
+
+array = split(items, ',');
+```
+
+@category String
+@category Template literal
+*/
+export type Split<S extends string, Delimiter extends string> = S extends `${infer Head}${Delimiter}${infer Tail}` ? [Head, ...Split<Tail, Delimiter>] : S extends Delimiter ? [] : [S];
+export type HasNestedPath<Path extends string> = Length<Split<Path, ".">> extends 1 ? false : true;
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};

package/dist/generators/types/endpoint.d.ts

@@ -0,0 +1,47 @@
+import { OpenAPIV3 } from "openapi-types";
+import { OperationAclInfo, ParameterObject } from "./openapi";
+export interface EndpointParameter {
+    name: string;
+    description?: string;
+    type: "Query" | "Body" | "Header" | "Path";
+    zodSchema: string;
+    parameterObject?: ParameterObject;
+    parameterSortingEnumSchemaName?: string;
+    bodyObject?: OpenAPIV3.RequestBodyObject;
+}
+interface EndpointError {
+    status: number | "default";
+    description?: string;
+    zodSchema: string;
+}
+export interface AclConditionsPropertyType {
+    name: string;
+    type?: string;
+    zodSchemaName?: string;
+    required?: boolean;
+    info?: string;
+}
+export type EndpointAclInfo = OperationAclInfo & {
+    conditionsTypes?: AclConditionsPropertyType[];
+};
+export interface Endpoint {
+    method: OpenAPIV3.HttpMethods;
+    path: string;
+    operationName: string;
+    description?: string;
+    summary?: string;
+    tags?: string[];
+    requestFormat: string;
+    responseFormat?: string;
+    parameters: Array<EndpointParameter>;
+    status?: number;
+    response: string;
+    responseObject?: OpenAPIV3.ResponseObject;
+    responseDescription?: string;
+    errors: Array<EndpointError>;
+    responseStatusCodes: string[];
+    acl?: EndpointAclInfo[];
+    mediaUpload?: boolean;
+    mediaDownload?: boolean;
+}
+export {};

package/dist/generators/types/generate.d.ts

@@ -15,7 +15,6 @@ export interface GenerateZodSchemaData {
     isCiruclar: boolean;
     isEnum: boolean;
     schemaObj?: OpenAPIV3.SchemaObject;
-    hasBrand: boolean;
 }
 export declare enum GenerateType {
     Models = "models",

package/dist/generators/types/openapi.d.ts

@@ -0,0 +1,22 @@
+import { OpenAPIV3 } from "openapi-types";
+export type CompositeType = "oneOf" | "anyOf" | "allOf" | "enum" | "array" | "empty-object" | "object" | "record";
+export type SingleType = Exclude<OpenAPIV3.SchemaObject["type"], any[] | undefined>;
+export type PrimitiveType = "string" | "number" | "integer" | "boolean";
+export interface OperationAclInfo {
+    action: string;
+    subject: string;
+    conditions?: Record<string, string>;
+    description?: string;
+}
+interface OperationObjectAdditions {
+    "x-acl"?: OperationAclInfo[];
+    "x-media-upload"?: any;
+    "x-media-download"?: any;
+}
+export type OperationObject = OpenAPIV3.OperationObject<OperationObjectAdditions>;
+interface ParameterObjectAdditions {
+    "x-enumNames"?: string[];
+}
+export type ParameterObject = OpenAPIV3.ParameterObject & ParameterObjectAdditions;
+export type SortingParameterObject = OpenAPIV3.ParameterObject & Required<Pick<ParameterObjectAdditions, "x-enumNames">>;
+export {};

package/dist/generators/types/options.d.ts

@@ -0,0 +1,48 @@
+import { GenerateType } from "./generate";
+interface ZodGenerateOptions {
+    schemaSuffix: string;
+    enumSuffix: string;
+    withImplicitRequiredProps?: boolean;
+    withDefaultValues?: boolean;
+    withDescription?: boolean;
+    allReadonly?: boolean;
+    extractEnums?: boolean;
+    replaceOptionalWithNullish?: boolean;
+}
+interface EndpointsGenerateOptions {
+    restClientImportPath: string;
+    errorHandlingImportPath: string;
+    withDeprecatedEndpoints?: boolean;
+    removeOperationPrefixEndingWith?: string;
+    parseRequestParams?: boolean;
+}
+interface QueriesGenerateOptions {
+    queryTypesImportPath: string;
+    axiosRequestConfig?: boolean;
+    infiniteQueries?: boolean;
+    mutationEffects?: boolean;
+    checkAcl?: boolean;
+}
+interface GenerateConfig {
+    outputFileNameSuffix: string;
+    namespaceSuffix: string;
+}
+interface BaseGenerateOptions {
+    input: string;
+    output: string;
+    splitByTags: boolean;
+    defaultTag: string;
+    excludeTags: string[];
+    excludePathRegex: string;
+    excludeRedundantZodSchemas: boolean;
+    tsNamespaces: boolean;
+    importPath: "ts" | "relative" | "absolute";
+    configs: Record<GenerateType, GenerateConfig>;
+    acl: boolean;
+    standalone: boolean;
+    baseUrl: string;
+    abilityContextImportPath: string;
+    abilityContextGenericAppAbilities: boolean;
+}
+export type GenerateOptions = BaseGenerateOptions & ZodGenerateOptions & EndpointsGenerateOptions & QueriesGenerateOptions;
+export {};

package/dist/generators/types/validation.d.ts

@@ -0,0 +1,5 @@
+export type ValidationErrorType = "invalid-schema" | "invalid-operation-id" | "missing-path-parameter" | "not-allowed-inline-enum" | "not-allowed-circular-schema" | "missing-acl-condition-property" | "missing-status-code" | "invalid-status-code" | "multiple-success-status-codes";
+export interface ValidationError {
+    type: ValidationErrorType;
+    message: string;
+}

package/dist/generators/utils/generate/generate.utils.d.ts

@@ -19,6 +19,6 @@ export declare function getQueryTypesImportPath(options: GenerateOptions): strin
 export declare function getQueryModulesImportPath(options: GenerateOptions): string;
 export declare function getMutationEffectsImportPath(options: GenerateOptions): string;
 export declare function getAclCheckImportPath(options: GenerateOptions): string;
-export declare function getZodUtilsImportPath(options: GenerateOptions): string;
+export declare function getZodExtendedImportPath(options: GenerateOptions): string;
 export declare function getAppAbilitiesImportPath(options: GenerateOptions): string;
 export {};

package/dist/generators/utils/generate-files.utils.d.ts

@@ -3,4 +3,4 @@ import { GenerateData, GenerateFileData } from "src/generators/types/generate";
 export declare function getAclFiles(appAclTags: string[], resolver: SchemaResolver): GenerateFileData[];
 export declare function getMutationEffectsFiles(data: GenerateData, resolver: SchemaResolver): GenerateFileData[];
 export declare function getStandaloneFiles(resolver: SchemaResolver): GenerateFileData[];
-export declare function getZodUtilsFiles(data: GenerateData, resolver: SchemaResolver): GenerateFileData[];
+export declare function getZodExtendedFiles(data: GenerateData, resolver: SchemaResolver): GenerateFileData[];