Add branded zod schemas

Author: monikaboz

README.md

@@ -45,12 +45,15 @@ yarn openapi-codegen generate --input http://localhost:3001/docs-json --standalo
   --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)
   --infiniteQueries                   Generate infinite queries for paginated API endpoints (default: false)
   --mutationEffects                   Add mutation effects options to mutation hooks (default: true)
   --parseRequestParams                Add Zod parsing to API endpoints (default: false)
+
+  --acl                               Generate ACL related files (default: true)
   --checkAcl                          Add ACL check to queries (default: false)
 
   --standalone                        Generate any missing supporting classes/types, e.g., REST client class, React Query type extensions, etc. (default: false)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "main": "./dist/index.js",
   "bin": {
     "openapi-codegen": "./dist/sh.js"

src/commands/generate.command.ts

@@ -46,12 +46,33 @@ class GenerateOptions implements GenerateParams {
   })
   removeOperationPrefixEndingWith!: string;
 
+  @YargOption({
+    envAlias: "acl",
+    default: DEFAULT_GENERATE_OPTIONS.acl,
+    type: "boolean",
+  })
+  acl!: boolean;
+
+  @YargOption({
+    envAlias: "checkAcl",
+    default: DEFAULT_GENERATE_OPTIONS.checkAcl,
+    type: "boolean",
+  })
+  checkAcl!: boolean;
+
   @YargOption({ envAlias: "standalone", default: DEFAULT_GENERATE_OPTIONS.standalone, type: "boolean" })
   standalone!: boolean;
 
   @YargOption({ envAlias: "baseUrl", default: DEFAULT_GENERATE_OPTIONS.baseUrl })
   baseUrl!: string;
 
+  @YargOption({
+    envAlias: "branded",
+    default: DEFAULT_GENERATE_OPTIONS.branded,
+    type: "boolean",
+  })
+  branded!: boolean;
+
   @YargOption({
     envAlias: "replaceOptionalWithNullish",
     default: DEFAULT_GENERATE_OPTIONS.replaceOptionalWithNullish,
@@ -76,13 +97,6 @@ class GenerateOptions implements GenerateParams {
   })
   parseRequestParams!: boolean;
 
-  @YargOption({
-    envAlias: "checkAcl",
-    default: DEFAULT_GENERATE_OPTIONS.checkAcl,
-    type: "boolean",
-  })
-  checkAcl!: boolean;
-
   @YargOption({ envAlias: "axiosRequestConfig", default: DEFAULT_GENERATE_OPTIONS.axiosRequestConfig, type: "boolean" })
   axiosRequestConfig!: boolean;
 

src/commands/generate.ts

@@ -22,14 +22,16 @@ export type GenerateParams = {
   | "removeOperationPrefixEndingWith"
   | "importPath"
   | "extractEnums"
+  | "acl"
+  | "checkAcl"
   | "standalone"
   | "baseUrl"
+  | "branded"
   | "replaceOptionalWithNullish"
   | "infiniteQueries"
   | "axiosRequestConfig"
   | "mutationEffects"
   | "parseRequestParams"
-  | "checkAcl"
 >;
 
 export async function generate({ input, excludeTags, monorepo, prettier, verbose, ...params }: GenerateParams) {

src/generators/const/options.const.ts

@@ -32,6 +32,8 @@ export const DEFAULT_GENERATE_OPTIONS: GenerateOptions = {
       namespaceSuffix: "Acl",
     },
   },
+  acl: true,
+  checkAcl: false,
   standalone: false,
   baseUrl: "",
   abilityContextImportPath: TEMPLATE_IMPORTS.abilityContext.template,
@@ -40,13 +42,13 @@ export const DEFAULT_GENERATE_OPTIONS: GenerateOptions = {
   enumSuffix: ENUM_SUFFIX,
   withDefaultValues: true,
   extractEnums: true,
+  branded: true,
   replaceOptionalWithNullish: false,
   // Endpoints options
   restClientImportPath: TEMPLATE_IMPORTS.appRestClient.template,
   errorHandlingImportPath: TEMPLATE_IMPORTS.errorHandling.template,
   removeOperationPrefixEndingWith: "Controller_",
   parseRequestParams: false,
-  checkAcl: false,
   // Queries options
   queryTypesImportPath: TEMPLATE_IMPORTS.queryTypes.template,
   axiosRequestConfig: false,

src/generators/core/endpoints/getEndpointsFromOpenAPIDoc.test.ts

@@ -168,7 +168,7 @@ describe("getEndpointsFromOpenAPIDoc", () => {
       },
     ]);
     expect(resolver.getZodSchemas()).toStrictEqual({
-      Order: `z.object({ id: z.number().int(), petId: z.number().int(), quantity: z.number().int(), shipDate: z.string().datetime({ offset: true }), status: z.enum(["placed", "approved", "delivered"]), complete: z.boolean() }).partial()`,
+      Order: `z.object({ id: z.number().int(), petId: z.number().int(), quantity: z.number().int(), shipDate: z.string().datetime({ offset: true }).brand('datetime'), status: z.enum(["placed", "approved", "delivered"]), complete: z.boolean() }).partial()`,
     });
     expect(resolver["compositeZodSchemaData"]).toStrictEqual([]);
   });
@@ -1691,7 +1691,7 @@ describe("getEndpointsFromOpenAPIDoc", () => {
       FindPetsByTagsResponse: "z.array(Pet)",
       FindPetsByTagsTagsParam: "z.array(z.string()).optional()",
       GetInventoryResponse: "z.object({}).catchall(z.number().int())",
-      Order: `z.object({ id: z.number().int(), petId: z.number().int(), quantity: z.number().int(), shipDate: z.string().datetime({ offset: true }), status: z.enum(["placed", "approved", "delivered"]), complete: z.boolean() }).partial()`,
+      Order: `z.object({ id: z.number().int(), petId: z.number().int(), quantity: z.number().int(), shipDate: z.string().datetime({ offset: true }).brand('datetime'), status: z.enum(["placed", "approved", "delivered"]), complete: z.boolean() }).partial()`,
       Pet: `z.object({ id: z.number().int().optional(), name: z.string(), category: Category.optional(), photoUrls: z.array(z.string()), tags: z.array(Tag).optional(), status: z.enum(["available", "pending", "sold"]).optional() })`,
       Tag: "z.object({ id: z.number().int(), name: z.string() }).partial()",
       User: "z.object({ id: z.number().int(), username: z.string(), firstName: z.string(), lastName: z.string(), email: z.string(), password: z.string(), phone: z.string(), userStatus: z.number().int() }).partial()",

src/generators/core/zod/getZodChain.ts

@@ -16,7 +16,7 @@ export function getZodChain({
   const chains: string[] = [];
 
   match(schema.type)
-    .with("string", () => chains.push(getZodChainableStringValidations(schema)))
+    .with("string", () => chains.push(getZodChainableStringValidations(schema, options)))
     .with("number", "integer", () => chains.push(getZodChainableNumberValidations(schema)))
     .with("array", () => chains.push(getZodChainableArrayValidations(schema)))
     .otherwise(() => void 0);
@@ -75,7 +75,7 @@ function getZodChainableDefault(schema: OpenAPIV3.SchemaObject) {
   return "";
 }
 
-function getZodChainableStringValidations(schema: OpenAPIV3.SchemaObject) {
+function getZodChainableStringValidations(schema: OpenAPIV3.SchemaObject, options: GenerateOptions) {
   const validations: string[] = [];
 
   if (!schema.enum) {
@@ -97,7 +97,7 @@ function getZodChainableStringValidations(schema: OpenAPIV3.SchemaObject) {
       .with("email", () => "email()")
       .with("hostname", "uri", () => "url()")
       .with("uuid", () => "uuid()")
-      .with("date-time", () => "datetime({ offset: true })")
+      .with("date-time", () => `datetime({ offset: true })${options.branded ? ".brand('datetime')" : ""}`)
       .otherwise(() => "");
 
     if (chain) {

src/generators/core/zod/getZodSchema.test.ts

@@ -58,7 +58,7 @@ describe("getZodSchema", () => {
 
     expect(
       getZodSchemaString({ type: "object", properties: { dt: { type: "string", format: "date-time" } } }),
-    ).toStrictEqual("z.object({ dt: z.string().datetime({ offset: true }) }).partial()");
+    ).toStrictEqual("z.object({ dt: z.string().datetime({ offset: true }).brand('datetime') }).partial()");
 
     expect(
       getZodSchemaString({

src/generators/types/options.d.ts

@@ -9,6 +9,7 @@ interface ZodGenerateOptions {
   allReadonly?: boolean;
   strictObjects?: boolean;
   extractEnums?: boolean;
+  branded?: boolean;
   replaceOptionalWithNullish?: boolean;
 }
 
@@ -18,14 +19,14 @@ interface EndpointsGenerateOptions {
   withDeprecatedEndpoints?: boolean;
   removeOperationPrefixEndingWith?: string;
   parseRequestParams?: boolean;
-  checkAcl?: boolean;
 }
 
 interface QueriesGenerateOptions {
   queryTypesImportPath: string;
   axiosRequestConfig?: boolean;
   infiniteQueries?: boolean;
   mutationEffects?: boolean;
+  checkAcl?: boolean;
 }
 
 interface GenerateConfig {
@@ -44,6 +45,7 @@ interface BaseGenerateOptions {
   tsNamespaces: boolean;
   importPath: "ts" | "relative" | "absolute";
   configs: Record<GenerateType, GenerateConfig>;
+  acl: boolean;
   standalone: boolean;
   baseUrl: string;
   abilityContextImportPath: string;

src/generators/utils/generate-files.utils.ts

@@ -18,15 +18,17 @@ import { getOutputFileName, readAssetSync } from "./file.utils";
 import { getFileNameWithExtension } from "./generate/generate.utils";
 
 export function getAclFiles(appAclTags: string[], resolver: SchemaResolver): GenerateFileData[] {
-  const appAclContent = generateAppAcl(resolver, appAclTags);
+  if (!resolver.options.acl) {
+    return [];
+  }
 
   return [
     {
       fileName: getOutputFileName({
         output: resolver.options.output,
         fileName: getFileNameWithExtension(ACL_APP_ABILITY_FILE),
       }),
-      content: appAclContent,
+      content: generateAppAcl(resolver, appAclTags),
     },
     ...(resolver.options.checkAcl
       ? [