fix(core): add non readonly only inside implementation file when needed

Author: anymaniax

packages/core/src/getters/res-req-types.ts

@@ -148,17 +148,10 @@ export const getResReqTypes = (
             const isFormUrlEncoded =
               formUrlEncodedContentTypes.includes(contentType);
 
-            const imports = [
-              ...resolvedValue.imports,
-              ...(resolvedValue.hasReadonlyProps
-                ? [{ name: 'NonReadonly' }]
-                : []),
-            ];
-
             if ((!isFormData && !isFormUrlEncoded) || !propName) {
               return {
                 ...resolvedValue,
-                imports,
+                imports: resolvedValue.imports,
                 contentType,
               };
             }
@@ -182,7 +175,7 @@ export const getResReqTypes = (
 
             return {
               ...resolvedValue,
-              imports,
+              imports: resolvedValue.imports,
               formData,
               formUrlEncoded,
               contentType,

packages/core/src/writers/schemas.ts

@@ -130,7 +130,7 @@ export const writeSchemas = async ({
       .sort()
       .join('\n');
 
-    const fileContent = `${header}\n${exports}\n${getOrvalGeneratedTypes()}`;
+    const fileContent = `${header}\n${exports}`;
 
     await fs.writeFile(schemaFilePath, fileContent);
   } catch (e) {

packages/core/src/writers/single-mode.ts

@@ -8,6 +8,7 @@ import {
   upath,
 } from '../utils';
 import { generateTarget } from './target';
+import { getOrvalGeneratedTypes } from './types';
 
 export const writeSingleMode = async ({
   builder,
@@ -90,6 +91,11 @@ export const writeSingleMode = async ({
       data += generateMutatorImports({ mutators: formUrlEncoded });
     }
 
+    if (implementation.includes('NonReadonly<')) {
+      data += getOrvalGeneratedTypes();
+      data += '\n';
+    }
+
     if (!output.schemas && needSchema) {
       data += generateModelsInline(builder.schemas);
     }

packages/core/src/writers/split-mode.ts

@@ -8,6 +8,7 @@ import {
   upath,
 } from '../utils';
 import { generateTarget } from './target';
+import { getOrvalGeneratedTypes } from './types';
 
 export const writeSplitMode = async ({
   builder,
@@ -102,6 +103,10 @@ export const writeSplitMode = async ({
       });
     }
 
+    if (implementation.includes('NonReadonly<')) {
+      implementationData += getOrvalGeneratedTypes();
+    }
+
     implementationData += `\n${implementation}`;
     mswData += `\n${implementationMSW}`;
 

packages/core/src/writers/split-tags-mode.ts

@@ -8,6 +8,7 @@ import {
   upath,
 } from '../utils';
 import { generateTargetForTags } from './target-tags';
+import { getOrvalGeneratedTypes } from './types';
 
 export const writeSplitTagsMode = async ({
   builder,
@@ -109,6 +110,11 @@ export const writeSplitTagsMode = async ({
           });
         }
 
+        if (implementation.includes('NonReadonly<')) {
+          implementationData += getOrvalGeneratedTypes();
+          implementationData += '\n';
+        }
+
         implementationData += `\n${implementation}`;
         mswData += `\n${implementationMSW}`;
 

packages/core/src/writers/tags-mode.ts

@@ -9,6 +9,7 @@ import {
   upath,
 } from '../utils';
 import { generateTargetForTags } from './target-tags';
+import { getOrvalGeneratedTypes } from './types';
 
 export const writeTagsMode = async ({
   builder,
@@ -104,6 +105,12 @@ export const writeTagsMode = async ({
         }
 
         data += '\n\n';
+
+        if (implementation.includes('NonReadonly<')) {
+          data += getOrvalGeneratedTypes();
+          data += '\n';
+        }
+
         data += implementation;
 
         if (output.mock) {

packages/core/src/writers/types.ts

@@ -19,7 +19,7 @@ type UnionToIntersection<U> =
 type DistributeReadOnlyOverUnions<T> = T extends any ? NonReadonly<T> : never;
 
 type Writable<T> = Pick<T, WritableKeys<T>>;
-export type NonReadonly<T> = [T] extends [UnionToIntersection<T>] ? {
+type NonReadonly<T> = [T] extends [UnionToIntersection<T>] ? {
   [P in keyof Writable<T>]: T[P] extends object
     ? NonReadonly<NonNullable<T[P]>>
     : T[P];