feat: split entity type for endpoint specific types

SH-Exact · SH-Exact · commit 4fa66db7301d · 2025-10-15T14:29:01.000+02:00
diff --git a/src/generator/03-entities/index.ts b/src/generator/03-entities/index.ts
@@ -10,7 +10,7 @@ import {
   isReferenceObject,
   isRelatedEntitySchema
 } from '@utils/openapi/guards';
-import { camelCase } from 'change-case';
+import { camelCase, pascalCase } from 'change-case';
 import { OpenAPIV3 } from 'openapi-types';
 import { loosePascalCase } from '@utils/case';
 
@@ -19,6 +19,7 @@ export interface GeneratedEntity {
   properties: Map<string, PropertyMetaData>;
   parentName?: string;
   source: string;
+  createProperties: InterfaceProperty[];
 }
 
 export const generateEntities = (
@@ -78,12 +79,67 @@ export const generateEntities = (
     entities.set(schemaName, {
       name: schemaName,
       properties,
+      createProperties: entityInterfaceProperties.filter((prop) => !prop.readonly),
       parentName: parentEntityInterfaceName ? camelCase(parentEntityInterfaceName) : undefined,
       source: generateStatements(
-        generateInterface(entityInterfaceName, entityInterfaceProperties, parentEntityInterfaceName)
+        generateInterface(
+          entityInterfaceName,
+          entityInterfaceProperties.map((prop) => ({
+            ...prop,
+            required: !!(prop.required ?? prop.type?.endsWith('[]')) || prop.type !== 'string'
+          })),
+          parentEntityInterfaceName
+        )
       )
     });
   }
 
   return entities;
 };
+
+export const generateCreateEntityStatements = (
+  entities: Map<string, GeneratedEntity>,
+  enums: Map<string, GeneratedEnum>
+): string[] => {
+  const isPrimitiveOrEnumOrObject = (propType?: string) => {
+    return (
+      !propType ||
+      enums.has(propType) ||
+      propType === 'string' ||
+      propType === 'number' ||
+      propType === 'boolean' ||
+      propType === '{}'
+    );
+  };
+
+  const transformCreateEntityInterfaceProps = (props: InterfaceProperty[]) => {
+    return props.map((prop) => {
+      if (isPrimitiveOrEnumOrObject(prop.type)) {
+        return prop;
+      }
+
+      if (prop.type?.endsWith('[]')) {
+        const typeWithoutBrackets = prop.type.replace(/^\((.*?)\)\[\]$/, '$1');
+        return isPrimitiveOrEnumOrObject(typeWithoutBrackets) ? prop : { ...prop, type: `(${typeWithoutBrackets}_Create)[]` };
+      }
+
+      return { ...prop, type: `${prop.type}_Create` };
+    });
+  };
+
+  const createEntityStatements: string[] = [];
+
+  const generateCreateEntityStatement = (entity: GeneratedEntity, entityName: string): string => {
+    const name = `${pascalCase(entityName)}_Create`;
+    const parentName = entity.parentName ? `${pascalCase(entity.parentName)}_Create` : undefined;
+    const interfaceProperties = Array.from(transformCreateEntityInterfaceProps(entity.createProperties));
+
+    return generateStatements(generateInterface(name, interfaceProperties, parentName));
+  };
+
+  entities.forEach((entity, name) => {
+    createEntityStatements.push(generateCreateEntityStatement(entity, name));
+  });
+
+  return createEntityStatements;
+};
diff --git a/src/generator/04-services/endpoints/count.ts b/src/generator/04-services/endpoints/count.ts
@@ -30,7 +30,8 @@ export const generateCountEndpoint: ServiceFunctionGenerator = ({
   const functionTypeSource = generateArrowFunctionType({
     type: functionTypeName,
     params: [
-      `query${parametersType.isFullyOptional() ? '?' : ''}: CountQuery<${filterTypeName}>${path.parameters?.length ? ' & ' + parametersTypeName : ''}`, 'requestOptions?: RequestOptions'
+      `query${parametersType.isFullyOptional() ? '?' : ''}: CountQuery<${filterTypeName}>${path.parameters?.length ? ' & ' + parametersTypeName : ''}`,
+      'requestOptions?: RequestOptions'
     ],
     returns: `${resolveResponseType(target)}<number>`
   });
diff --git a/src/generator/04-services/endpoints/create.ts b/src/generator/04-services/endpoints/create.ts
@@ -1,23 +1,24 @@
 import { resolveResponseType } from '../../../target';
 import { GeneratedServiceFunction, ServiceFunctionGenerator } from '@generator/04-services/types';
-import { generateRequestBodyType } from '@generator/04-services/utils/generateRequestBodyType';
 import { generateResponseBodyType } from '@generator/04-services/utils/generateResponseBodyType';
 import { generateArrowFunction } from '@ts/generateArrowFunction';
 import { generateArrowFunctionType } from '@ts/generateArrowFunctionType';
 import { generateString } from '@ts/generateString';
 import { pascalCase } from 'change-case';
+import { generateRequestBodyType } from '@generator/04-services/utils/generateRequestBodyType';
 
 export const generateCreateEndpoint: ServiceFunctionGenerator = ({
   target,
   path,
   endpoint
 }): GeneratedServiceFunction => {
+  const endpointName = pascalCase(endpoint.service);
   const functionName = 'create';
-  const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+  const functionTypeName = `${endpointName}Service_${pascalCase(functionName)}`;
 
   const functionTypeSource = generateArrowFunctionType({
     type: functionTypeName,
-    params: [`data: DeepPartial<${generateRequestBodyType(path).toString()}>`, 'requestOptions?: RequestOptions'],
+    params: [`data: ${generateRequestBodyType(path).toString()}_Create`, 'requestOptions?: RequestOptions'],
     returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
   });
 
@@ -29,7 +30,7 @@ export const generateCreateEndpoint: ServiceFunctionGenerator = ({
   });
 
   return {
-    entity: pascalCase(endpoint.service),
+    entity: endpointName,
     name: functionName,
     type: { name: functionTypeName, source: functionTypeSource },
     func: { name: functionName, source: functionSource }
diff --git a/src/generator/04-services/endpoints/generic.ts b/src/generator/04-services/endpoints/generic.ts
@@ -31,15 +31,19 @@ export const generateGenericEndpoint =
     const hasId = endpoint.path.includes('{id}');
 
     const params = createObjectType({
-      params: convertToTypeScriptType(convertParametersToSchema(path.parameters)),
-      body: method === 'get' ? undefined : wrapBody(generateRequestBodyType(path), target)
+      params: convertToTypeScriptType(convertParametersToSchema(path.parameters), undefined, true),
+      body: method === 'get' ? undefined : wrapBody(generateRequestBodyType(path, true), target)
     });
 
     const responseBody = generateResponseBodyType(path);
 
     const functionTypeSource = generateArrowFunctionType({
       type: functionTypeName,
-      params: [...(hasId ? ['id: string'] : []), `query${params.isFullyOptional() ? '?' : ''}: ${entityQuery}`, 'requestOptions?: RequestOptions'],
+      params: [
+        ...(hasId ? ['id: string'] : []),
+        `query${params.isFullyOptional() ? '?' : ''}: ${entityQuery}`,
+        'requestOptions?: RequestOptions'
+      ],
       returns: `${resolveResponseType(target)}<${wrapBody(responseBody, target).toString()}>`
     });
 
diff --git a/src/generator/04-services/endpoints/update.ts b/src/generator/04-services/endpoints/update.ts
@@ -1,11 +1,11 @@
 import { resolveResponseType } from '../../../target';
 import { GeneratedServiceFunction, ServiceFunctionGenerator } from '@generator/04-services/types';
-import { generateRequestBodyType } from '@generator/04-services/utils/generateRequestBodyType';
 import { generateResponseBodyType } from '@generator/04-services/utils/generateResponseBodyType';
 import { insertPathPlaceholder } from '@generator/04-services/utils/insertPathPlaceholder';
 import { generateArrowFunction } from '@ts/generateArrowFunction';
 import { generateArrowFunctionType } from '@ts/generateArrowFunctionType';
 import { pascalCase } from 'change-case';
+import { generateRequestBodyType } from '@generator/04-services/utils/generateRequestBodyType';
 
 export const generateUpdateEndpoint: ServiceFunctionGenerator = ({
   target,
@@ -17,7 +17,12 @@ export const generateUpdateEndpoint: ServiceFunctionGenerator = ({
 
   const functionTypeSource = generateArrowFunctionType({
     type: functionTypeName,
-    params: ['id: string', `data: DeepPartial<${generateRequestBodyType(path).toString()}>`, 'options?: UpdateQuery', 'requestOptions?: RequestOptions'],
+    params: [
+      'id: string',
+      `data: ${generateRequestBodyType(path).toString()}`,
+      'options?: UpdateQuery',
+      'requestOptions?: RequestOptions'
+    ],
     returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
   });
 
diff --git a/src/generator/04-services/utils/generateBodyType.ts b/src/generator/04-services/utils/generateBodyType.ts
@@ -3,7 +3,8 @@ import { isReferenceObject } from '@utils/openapi/guards';
 import { OpenAPIV3 } from 'openapi-types';
 
 export const generateBodyType = (
-  body?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject | OpenAPIV3.ResponseObject
+  body?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject | OpenAPIV3.ResponseObject,
+  isDeepPartialType?: boolean
 ): AnyType | undefined => {
   if (isReferenceObject(body)) {
     return convertToTypeScriptType(body);
@@ -12,7 +13,7 @@ export const generateBodyType = (
   const types: AnyType[] = [];
   for (const { schema } of Object.values(body?.content ?? {})) {
     if (schema) {
-      types.push(convertToTypeScriptType(schema));
+      types.push(convertToTypeScriptType(schema, undefined, isDeepPartialType));
     }
   }
 
diff --git a/src/generator/04-services/utils/generateRequestBodyType.ts b/src/generator/04-services/utils/generateRequestBodyType.ts
@@ -2,6 +2,9 @@ import { generateBodyType } from '@generator/04-services/utils/generateBodyType'
 import { AnyType, createRawType } from '@utils/openapi/convertToTypeScriptType';
 import { OpenAPIV3 } from 'openapi-types';
 
-export const generateRequestBodyType = ({ requestBody }: OpenAPIV3.OperationObject): AnyType => {
-  return generateBodyType(requestBody) ?? createRawType('unknown');
+export const generateRequestBodyType = (
+  { requestBody }: OpenAPIV3.OperationObject,
+  isDeepPartialType?: boolean
+): AnyType => {
+  return generateBodyType(requestBody, isDeepPartialType) ?? createRawType('unknown');
 };
diff --git a/src/generator/generate.ts b/src/generator/generate.ts
@@ -1,7 +1,7 @@
 import { Target } from '../target';
 import { generateBase } from '@generator/01-base';
 import { generateEnums } from '@generator/02-enums';
-import { generateEntities } from '@generator/03-entities';
+import { generateCreateEntityStatements, generateEntities } from '@generator/03-entities';
 import { generateServices } from '@generator/04-services';
 import { generateMaps } from '@generator/05-maps';
 import { generateBlockComment } from '@ts/generateComment';
@@ -25,13 +25,17 @@ export const generate = (doc: OpenAPIV3.Document, options: GeneratorOptions): st
 
   const enums = generateEnums(schemas);
   const entities = generateEntities(schemas, enums);
+  const createEntityStatements = generateCreateEntityStatements(entities, enums);
   const services = generateServices(doc.paths, entities, aliases, options);
   const maps = generateMaps(enums, entities, services, aliases, options);
 
   return generateStatements(
     generateBase(options.target, doc.info.version, options),
     generateBlockComment('ENUMS', generateStatements(...[...enums.values()].map((v) => v.source))),
-    generateBlockComment('ENTITIES', generateStatements(...[...entities.values()].map((v) => v.source))),
+    generateBlockComment(
+      'ENTITIES',
+      generateStatements(...[...entities.values()].map((v) => v.source), ...createEntityStatements)
+    ),
     generateBlockComment('SERVICES', generateStatements(...[...services.values()].map((v) => v.source))),
     generateBlockComment('MAPS', generateStatements(maps.source))
   );
diff --git a/src/utils/openapi/convertToTypeScriptType.ts b/src/utils/openapi/convertToTypeScriptType.ts
@@ -53,7 +53,11 @@ export const createTupleType = (value: (Type | string)[]): TupleType => ({
   toString: () => concat([...new Set(value.map((v) => (typeof v === 'string' ? `'${v}'` : v.toString())))], ' | ')
 });
 
-export const createObjectType = (value: Record<string, Type | undefined>, required: string[] = []): ObjectType => ({
+export const createObjectType = (
+  value: Record<string, Type | undefined>,
+  required: string[] = [],
+  isDeepPartialType?: boolean
+): ObjectType => ({
   type: 'object',
   isFullyOptional: () => {
     return (
@@ -72,7 +76,10 @@ export const createObjectType = (value: Record<string, Type | undefined>, requir
         const isRequired =
           required.includes(name) ||
           (value.type === 'object' && !value.isFullyOptional() && propagateOptionalProperties);
-        return `${name + (isRequired ? '' : '?')}: ${value.toString()};`;
+        const valueString =
+          isDeepPartialType && value.type === 'reference' ? `DeepPartial<${value.toString()}>` : value.toString();
+
+        return `${name + (isRequired ? '' : '?')}: ${valueString};`;
       });
 
     return properties.length ? `{\n${indent(properties.join('\n'))}\n}` : '{}';
@@ -87,7 +94,8 @@ export const getRefName = (obj: OpenAPIV3.ReferenceObject) => {
 
 export const convertToTypeScriptType = (
   schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
-  property?: string
+  property?: string,
+  isDeepPartialType?: boolean
 ): AnyType => {
   if (isReferenceObject(schema)) {
     return createReferenceType(getRefName(schema));
@@ -108,7 +116,8 @@ export const convertToTypeScriptType = (
         const { properties = {}, required = [] } = schema;
         return createObjectType(
           Object.fromEntries(Object.entries(properties).map((v) => [v[0], convertToTypeScriptType(v[1])])),
-          required
+          required,
+          isDeepPartialType
         );
       }
       case 'array':
