vsrepo 1.1.0 → 1.1.1

package/README.md

@@ -7,7 +7,7 @@ Biblioteca de repository pattern para projetos que usam **Prisma**, com suporte
 
 O VSRepository permite criar repositories fortemente tipados com:
 
-- **Métodos base** automáticos: `get`, `save`, `remove`
+- **Métodos base** automáticos: `get`, `getOrThrow`, `save`, `remove`
 - **Métodos dinâmicos** inferidos pelo nome: `findByEmail`, `findManyPaginated`, `updateById`, `deleteManyByIdIn`
 - **Select models** reutilizáveis para diferentes projeções de dados
 - **Type safety** em 100% das operações
@@ -182,7 +182,7 @@ O VSRepository pode ser facilmente integrado em projetos NestJS através de prov
 import { Provider } from "@nestjs/common";
 import { PrismaService } from "../../database/prisma.service";
 import { UserGetPayload } from "../../generated/prisma/models";
-import { RepositoryOf, setupVSRepo } from "../../generated/vsrepo";
+import { setupVSRepo } from "../../generated/vsrepo";
 
 const userVSRepo = setupVSRepo<
     UserGetPayload<{ include: { profile: true } }>,
@@ -220,19 +220,28 @@ const userVSRepo = setupVSRepo<
             proxyTo: "findUniqueByEmail",
             selectModel: "auth",
         },
+        findByEmailEndsWith: {
+            map: true,
+        }
     },
 });
 
-export type UserRepository = RepositoryOf<typeof userVSRepo>;
+const setupUserRepository = (prisma: PrismaService) => {
+    return userVSRepo.build(prisma).extend((repo) => ({
+        buscarPorDominio: async (dominio: string) => {
+            return repo.findByEmailEndsWith(`@${dominio}`);
+        },
+    }));
+};
+
+export type UserRepository = ReturnType<typeof setupUserRepository>;
 
 export const USER_REPOSITORY = Symbol("USER_REPOSITORY");
 
 export const UserRepositoryProvider: Provider = {
     provide: USER_REPOSITORY,
     inject: [PrismaService],
-    useFactory: (prisma: PrismaService) => {
-        return userVSRepo.build(prisma);
-    },
+    useFactory: setupUserRepository,
 };
 ```
 
@@ -323,11 +332,12 @@ export class UserController {
 
 ## Métodos base
 
-Ao chamar `.build(prisma)`, três métodos são automaticamente disponibilizados:
+Ao chamar `.build(prisma)`, quatro métodos são automaticamente disponibilizados:
 
 | Método       | Descrição                                  |
 | ------------ | ------------------------------------------ |
 | `get(pk)`    | Busca um registro pela primary key         |
+| `getOrThrow(pk)` | Busca um registro pela primary key e lança erro se não encontrar |
 | `save(obj)`  | Cria ou atualiza (upsert pela primary key) |
 | `remove(pk)` | Remove um registro pela primary key        |
 
@@ -433,8 +443,11 @@ O prefixo do nome do método determina qual operação Prisma será chamada e qu
 | ------------------------- | ------------------------ | ---------------------- | -------------------------------------------------------- |
 | `findBy`                  | `findMany` / `findFirst` | `T[]` ou `T \| null`   | Padrão é lista; use `fbMode: "one"` para retorno único   |
 | `findUniqueBy`            | `findUnique`             | `T \| null`            |                                                          |
+| `findUniqueOrThrowBy`     | `findUniqueOrThrow`      | `T`                    | Lança erro se não encontrar                                  |
 | `findFirstBy`             | `findFirst`              | `T \| null`            | Aceita campos como filtro                                |
+| `findFirstOrThrowBy`      | `findFirstOrThrow`       | `T`                    | Aceita campos como filtro; lança erro se não encontrar       |
 | `findFirst`               | `findFirst`              | `T \| null`            | Sem filtros de campo; aplica só `requiredWhere` e `pushWhere`          |
+| `findFirstOrThrow`        | `findFirstOrThrow`       | `T`                    | Sem filtros de campo; aplica só `requiredWhere` e `pushWhere`; lança erro se não encontrar |
 | `findManyBy`              | `findMany`               | `T[]`                  | Aceita campos como filtro                                |
 | `findMany`                | `findMany`               | `T[]`                  | Sem filtros de campo; aplica só `requiredWhere` e `pushWhere`           |
 | `findWhere`               | `findFirst`              | `T \| null`            | Recebe um objeto `where` explícito como argumento        |

package/VSRepository/VSRepoUtils.js

@@ -0,0 +1,84 @@
+import { VSRepoConfigError } from "./VSRepoError.js";
+
+export class FieldValidator {
+    constructor(throws) {
+        this.throws = throws;
+    }
+
+    validate(
+        field,
+        fieldName,
+        mustBe,
+        undefinedAble,
+        nullAble,
+        customReason
+    ) {
+        if (field === undefined) {
+            if (undefinedAble) return;
+            throw this.instanceError(fieldName, customReason ?? "cannot be undefined");
+        }
+
+        if (field === null) {
+            if (nullAble) return;
+            throw this.instanceError(fieldName, customReason ?? "cannot be null");
+        }
+
+        const condition = typeof mustBe === "function" ? !mustBe(field) : typeof field !== mustBe;
+
+        if(condition) {
+            throw this.instanceError(fieldName, customReason ?? `must be a valid ${mustBe}`);
+        };
+    }
+
+    instanceError(fieldName, reason) {
+        const error = new this.throws("");
+        error.message = `[VSRepository] (${error.type}) '${fieldName}' ${reason}.`;
+        return error;
+    }
+}
+
+export function validateConfig(config) {
+    const validator = new FieldValidator(VSRepoConfigError);
+
+    validator.validate(config, "config", "object");
+    validator.validate(config.tableName, "tableName", "string");
+    validator.validate(config.pkName, "pkName", "string");
+    validator.validate(config.selectModels, "selectModels", "object", true);
+
+    if(config.defaultSelectModel !== undefined) {
+        validator.validate(config.defaultSelectModel, "defaultSelectModel", "string");
+
+        validator.validate(config.defaultSelectModel, "defaultSelectModel", (field) => {
+            return !!(config.selectModels && Object.keys(config.selectModels).includes(config.defaultSelectModel))
+        }, false, false, "must be a valid key of 'selectModels'");
+    }
+
+    if(config.relations !== undefined) {
+        validator.validate(config.relations, "relations", "object");
+
+        for (const key of Object.keys(config.relations)) {
+            const relation = config.relations[key];
+
+            validator.validate(relation.pk, "pk", "string", false, false, `of relation '${key}' must be a string`);
+            validator.validate(relation.mode, "mode", (field) => ['otm', 'mtm', 'mto', 'oto'].includes(field), false, false, `of relation '${key}' must be 'otm', 'mtm', 'mto' or 'oto'`);
+            validator.validate(relation.restriction, "restriction", (field) => ['set', 'add'].includes(field), false, false, `of relation '${key}' must be 'set' or 'add'`);
+        }
+    }
+
+    validator.validate(config.requiredWhere, "requiredWhere", "object", true);
+
+    if(config.methods !== undefined) {
+        validator.validate(config.methods, "methods", "object");
+
+        for (const [key, value] of Object.entries(config.methods)) {
+            validator.validate(value.map, "map", "boolean", false, false, `on ${key} must be a valid boolean`);
+            validator.validate(value.whereType, "whereType", (field) => ['extending', 'overwrite'].includes(field), true, false, `on ${key} must be 'extending' or 'overwrite'`);
+            validator.validate(value.selectModel, "selectModel", (field) => !!(field === false || (config.selectModels && Object.keys(config.selectModels).includes(field))), true, false, `on ${key} must be a valid key of 'selectModels'`);
+            validator.validate(value.proxyTo, "proxyTo", "string", true, false, `on ${key} must be a valid string`);
+            validator.validate(value.fbMode, "fbMode", (field) => ['one', 'list'].includes(field), true, false, `on ${key} must be 'one' or 'list'`);
+            validator.validate(value.pushWhere, "pushWhere", "object", true, false, `on ${key} must be a valid object`);
+            validator.validate(value.injectOrdenation, "injectOrdenation", "object", true, false, `on ${key} must be a valid object or array`);
+            validator.validate(value.injectPagination, "injectPagination", "object", true, false, `on ${key} must be a valid object`);
+        }
+    }
+}

package/VSRepository/VSRepository.d.ts

@@ -43,9 +43,12 @@ export type PaginationOptions<TCursor = unknown> = {
 export type OrderOptions = OrderPattern | OrderPattern[];
 
 type ValidMethodPatterns =
-    | `existsBy${string}` | `findBy${string}` | `findUniqueBy${string}`
-    | `findFirstBy${string}` | `findFirst${string}` | `findManyBy${string}`
-    | `findMany${string}` | `createManyAndReturn${string}` | `createMany${string}`
+    | `existsBy${string}` | `findBy${string}` 
+    | `findUniqueBy${string}` | `findUniqueOrThrowBy${string}`
+    | `findFirstBy${string}` | `findFirst${string}` 
+    | `findFirstOrThrowBy${string}` | `findFirstOrThrow${string}`
+    | `findManyBy${string}` | `findMany${string}` 
+    | `createManyAndReturn${string}` | `createMany${string}`
     | `create${string}` | `updateManyAndReturnBy${string}` | `updateManyBy${string}`
     | `updateBy${string}` | `upsertBy${string}` | `deleteManyBy${string}`
     | `deleteBy${string}` | `countBy${string}` | `count${string}`
@@ -55,9 +58,6 @@ type StringModifiers =
     | 'NotStartsWith' | 'StartsWith' | 'NotEndsWith' | 'EndsWith' 
     | 'NotContains' | 'Contains' | 'NotIn' | 'In' | 'Not';
 
-type NumberModifiers = 
-    | 'LessThanEqual' | 'LessThan' | 'GreaterThanEqual' | 'GreaterThan';
-
 type StripModifier<S extends string> =
   S extends `${infer Base}${StringModifiers}Insensitive` ? Base :
   S extends `${infer Base}NotStartsWith` ? Base :
@@ -149,7 +149,7 @@ type ResolveReturnType<M extends string, TSelected> =
     M extends 'createMany' | 'updateManyBy' | 'deleteManyBy' ? { count: number } :
     M extends 'findMany' | 'createManyAndReturn' | 'updateManyAndReturnBy' | 'findListWhere' | 'findByList' ? TSelected[] :
     M extends 'findUnique' | 'findFirst' | 'findWhere' | 'findByOne' ? TSelected | null :
-    M extends 'create' | 'updateBy' | 'upsertBy' | 'deleteBy' ? TSelected :
+    M extends 'findUniqueOrThrow' | 'findFirstOrThrow' | 'create' | 'updateBy' | 'upsertBy' | 'deleteBy' ? TSelected :
     M extends 'count' ? number : never;
 
 type ExtraArgs<M extends string, R extends string, I> = [
@@ -218,7 +218,9 @@ type GetMappedMethod<K extends string, MethodConf> =
     K extends `findBy${string}` ? (MethodConf extends { fbMode: 'one' } ? 'findByOne' : 'findByList') :
     K extends `existsBy${string}` ? 'existsBy' :
     K extends `findUniqueBy${string}` ? 'findUnique' :
+    K extends `findUniqueOrThrowBy${string}` ? 'findUniqueOrThrow' :
     K extends `findFirstBy${string}` | `findFirst${string}` ? 'findFirst' :
+    K extends `findFirstOrThrowBy${string}` | `findFirstOrThrow${string}` ? 'findFirstOrThrow' :
     K extends `findManyBy${string}` | `findMany${string}` ? 'findMany' :
     K extends `createManyAndReturn${string}` ? 'createManyAndReturn' :
     K extends `createMany${string}` ? 'createMany' :
@@ -236,7 +238,7 @@ type GetMappedMethod<K extends string, MethodConf> =
 
 type ExtractPatternBase<K extends string> = 
     K extends `${string}By${infer R}` ? R :
-    K extends `findFirst${infer R}` | `findMany${infer R}` | `createManyAndReturn${infer R}` | `createMany${infer R}` | `create${infer R}` | `count${infer R}` | `findWhere${infer R}` | `findListWhere${infer R}` ? R : '';
+    K extends `findFirst${infer R}` | `findFirstOrThrow${infer R}` | `findMany${infer R}` | `createManyAndReturn${infer R}` | `createMany${infer R}` | `create${infer R}` | `count${infer R}` | `findWhere${infer R}` | `findListWhere${infer R}` ? R : '';
 
 type MethodFactory<T, M extends Prisma.ModelName, K extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I, MethodConf> = 
     MethodFn<GetMappedMethod<K, MethodConf>, T, M, ExtractPatternBase<K>, SelectModels, DefaultSelect, I>;
@@ -364,6 +366,8 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
     baseMethods?: {
         /** Configuração do método `get`. */
         get?: BaseMethodConfig<TSelectKeys>;
+        /** Configuração do método `getOrThrow`. */
+        getOrThrow?: BaseMethodConfig<TSelectKeys>;
         /** Configuração do método `remove`. */
         remove?: BaseMethodConfig<TSelectKeys>;
         /** Configuração do método `save`. */
@@ -371,7 +375,7 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
     };
 };
 
-type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'remove' | 'save', TSelects = ExtractSelectModels<Config>> =
+type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'getOrThrow' | 'remove' | 'save', TSelects = ExtractSelectModels<Config>> =
     C extends { baseMethods?: { [_ in Method]?: { defaultSelect?: infer D } } }
         ? D extends keyof TSelects 
             ? D 
@@ -406,6 +410,17 @@ type InjectedGet<
     ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault> | null>;
 };
 
+type InjectedGetOrThrow<
+    T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
+    TSelects = ExtractSelectModels<Config>,
+    TDefault = ExtractDefaultSelect<Config>,
+    TPk = ExtractPkName<T, Config>
+> = C extends { baseMethods: { getOrThrow: { active: false } } } ? {} : {
+    getOrThrow<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'getOrThrow', TSelects>>(
+        pk: T[TPk extends keyof T ? TPk : never], options?: MethodOptions<S>
+    ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault>>;
+};
+
 type InjectedRemove<
     T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
     TSelects = ExtractSelectModels<Config>,
@@ -462,6 +477,7 @@ type InjectedSave<
 
 type InjectedBaseMethods<T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined> = 
     InjectedGet<T, M, Config, C> & 
+    InjectedGetOrThrow<T, M, Config, C> & 
     InjectedRemove<T, M, Config, C> & 
     InjectedSave<T, M, Config, C>;
 

package/VSRepository/VSRepository.js

@@ -9,6 +9,7 @@ export * from "./VSRepoError.js";
 
 // * Importando classes de erro
 import { VSRepoConfigError, VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from "./VSRepoError.js";
+import { validateConfig } from "./VSRepoUtils.js";
 
 // * Essa é a classe pincipal, é a partir dela que serão criados os objetos dos repositories
 export class VSRepository {
@@ -28,92 +29,7 @@ export class VSRepository {
     methods;
 
     constructor(config) {
-        if(typeof config !== 'object' || config === null){
-            throw new VSRepoConfigError(`[VSRepository] (config) 'config' must be a valid object.`);
-        }
-        if(typeof config.tableName !== 'string') {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'tableName' must be a valid string.`);
-        }
-        if(typeof config.pkName !== 'string') {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'pkName' must be a valid string.`);
-        }
-        if(config.selectModels !== undefined && typeof config.selectModels !== 'object' || config.selectModels === null) {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'selectModels' must be a valid object.`);
-        }
-        if(config.defaultSelectModel !== undefined) {
-            if(!config.selectModels) {
-                throw new VSRepoConfigError(`[VSRepository] (config) 'defaultSelectModel' can only be passed with 'selectModels'.`);
-            }
-            if(typeof config.defaultSelectModel !== 'string') {
-                throw new VSRepoConfigError(`[VSRepository] (config) 'defaultSelectModel' must be a valid string.`);
-            }
-            if(!Object.keys(config.selectModels).includes(config.defaultSelectModel)){
-                throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'defaultSelectModel': ${config.defaultSelectModel}`);
-            }
-        }
-        if(config.relations !== undefined) {
-            const relations = config.relations;
-            if(typeof relations !== 'object' || relations === null){
-                throw new VSRepoConfigError(`[VSRepository] (config) 'relations' must be a valid object.`);
-            }
-
-            for (const key of Object.keys(relations)) {
-                const relation = relations[key];
-                if(typeof relation.pk !== 'string'){
-                    throw new VSRepoConfigError(`[VSRepository] (config) The property 'pk' of relation '${key}' must be a string.`);
-                }
-                if(typeof relation.mode !== 'string'){
-                    throw new VSRepoConfigError(`[VSRepository] (config) The property 'mode' of relation '${key}' must be 'otm', 'mtm', 'mto' or 'oto'.`);
-                }
-                if(typeof relation.restriction !== 'string'){
-                    throw new VSRepoConfigError(`[VSRepository] (config) The property 'restriction' of relation '${key}' must be 'set' or 'add'.`);
-                }
-            }
-        }
-        if(config.requiredWhere !== undefined && typeof config.requiredWhere !== 'object' || config.requiredWhere === null) {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'requiredWhere' must be a valid object.`);
-        }
-        if(config.methods !== undefined) {
-            if(typeof config.methods !== 'object' || config.methods === null){
-                throw new VSRepoConfigError(`[VSRepository] (config) 'methods' must be a valid object.`);
-            } else {
-                for (const [key, value] of Object.entries(config.methods)) {
-
-                    if(typeof value.map !== "boolean") {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'map' on ${key} must be a valid boolean.`);
-                    }
-
-                    if(value.whereType !== undefined && !['extending', 'overwrite'].includes(value.whereType)){
-                        throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'whereType' on ${key}: ${value.whereType}`);
-                    }
-
-                    if(value.selectModel !== undefined && value.selectModel !== false && (!config.selectModels || !Object.keys(config.selectModels).includes(value.selectModel))){
-                        throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'selectModel' on ${key}: ${value.selectModel}`);
-                    }
-
-                    if(value.proxyTo !== undefined && typeof value.proxyTo !== 'string') {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'proxyTo' on ${key} must be a valid string.`);
-                    }
-
-                    if(value.fbMode !== undefined && !['one', 'list'].includes(value.fbMode)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'fbMode' on ${key}: ${value.whereType}`);
-                    }
-
-                    if(value.pushWhere !== undefined && (typeof value.pushWhere !== 'object' || value.pushWhere === null)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'pushWhere' on ${key} must be a valid object.`);
-                    }
-
-                    if(value.injectOrdenation !== undefined && (typeof value.injectOrdenation !== 'object' || value.injectOrdenation === null)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'injectOrdenation' on ${key} must be a valid object or array.`);
-                    }
-
-                    if(value.injectPagination !== undefined && (typeof value.injectPagination !== 'object' || value.injectPagination === null)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'injectPagination' on ${key} must be a valid object.`);
-                    }
-
-                }
-            }
-        }
+        validateConfig(config);
 
         this.vsrepocache = new Map();
         this.tableName = config.tableName;
@@ -185,9 +101,22 @@ export class VSRepository {
             const whereParams = [];
             const otherParams = [];
 
-            if(keyToMap.startsWith('findUniqueBy')) {
+            if(keyToMap.startsWith('findUniqueOrThrowBy')) {
+                keyToMapReplaced = keyToMap.replace('findUniqueOrThrowBy', '');
+                method = 'findUniqueOrThrow';
+            } else if(keyToMap.startsWith('findUniqueBy')) {
                 keyToMapReplaced = keyToMap.replace('findUniqueBy', '');
                 method = 'findUnique';
+            } else if(keyToMap.startsWith('findFirstOrThrowBy')) {
+                keyToMapReplaced = keyToMap.replace('findFirstOrThrowBy', '')
+                ignoreOrderByAndPagination = false;
+                method = 'findFirstOrThrow';
+            } else if(keyToMap.startsWith('findFirstOrThrow')) {
+                keyToMapReplaced = keyToMap.replace('findFirstOrThrow', '');
+                ignoreOrderByAndPagination = false;
+                ignoreWhere = true;
+                onlyBaseWheres = true;
+                method = 'findFirstOrThrow';
             } else if(keyToMap.startsWith('findFirstBy')) {
                 keyToMapReplaced = keyToMap.replace('findFirstBy', '')
                 ignoreOrderByAndPagination = false;
@@ -851,6 +780,48 @@ export class VSRepository {
                 }
             }
         }
+        if(config.baseMethods?.getOrThrow?.active !== false) {
+            buildInstance.getOrThrow = async(pk, options = {}) => {
+                let db;
+                if(options?.db) db = options.db;
+                else db = prisma;
+
+                const prismaArgs = {};
+
+                const where = { [buildInstance.pkName]: pk };
+                if(buildInstance.requiredWhere && !config.baseMethods?.getOrThrow?.ignoreRequiredWhere) {
+                    Object.assign(where, buildInstance.requiredWhere);
+                }
+                prismaArgs.where = where;
+
+                let selectModelKey = options?.selectModel ?? config.baseMethods?.getOrThrow?.defaultSelect ?? buildInstance.defaultSelectModel;
+                if(selectModelKey){
+                    prismaArgs.select = buildInstance.selectModels[selectModelKey];
+                }
+
+                let start;
+                if(showWorking){
+                    console.log(`[VSRepository] (runtime) Executing getOrThrow on ${buildInstance.tableName}.`);
+                    console.log(`[VSRepository] (runtime) Built arguments to getOrThrow on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
+                    start = performance.now();
+                }
+
+                try {
+                    const result = await db[buildInstance.tableName].findUniqueOrThrow(prismaArgs);
+
+                    if(showWorking) {
+                        const end = performance.now();
+                        const duration = (end - start).toFixed(2);
+                        console.log(`[VSRepository] (runtime) Executed getOrThrow on ${buildInstance.tableName} (took: ${duration}ms).`);
+                    }
+
+                    return result;
+                } catch (err) {
+                    console.log(`[VSRepository] (runtime) Fatal error when trying to getOrThrow on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
+                    throw err;
+                }
+            }
+        }
         if(config.baseMethods?.remove?.active !== false) {
             buildInstance.remove = async (pk, options = {}) => {
                 let db;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {
@@ -61,6 +61,7 @@
     "@types/node": "^25.6.0",
     "dotenv": "^17.4.2",
     "prisma": "^7.8.0",
+    "tsx": "^4.22.3",
     "typescript": "^6.0.3"
   }
 }

package/scripts/configure-prisma-import.mjs

@@ -10,6 +10,15 @@ const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 
 const DEFAULT_OUTPUT = 'src/generated/vsrepo';
 const DEFAULT_PRISMA = 'src/generated/prisma';
+const GENERATED_HEADER = `/**
+ * ! THIS FILE IS AUTO-GENERATED.
+ * ! DO NOT EDIT MANUALLY.
+ */
+/* eslint-disable */
+/* biome-ignore-all lint: generated file */
+// @ts-nocheck
+
+`;
 
 const command = args[0]?.startsWith('-') ? 'generate' : args[0] ?? 'generate';
 const commandArgs = command === 'generate' && args[0] !== command ? args : args.slice(1);
@@ -91,7 +100,7 @@ for (const fileName of typeFiles) {
     `from '${relativeImportPath(path.dirname(targetFile), prismaTargetPath)}'`
   );
 
-  fs.writeFileSync(targetFile, contents, 'utf8');
+  fs.writeFileSync(targetFile, GENERATED_HEADER + contents, 'utf8');
 
   console.log(`Gerado: ${path.relative(workspaceRoot, targetFile)}`);
 }
@@ -166,7 +175,7 @@ export type * from './VSRepository.types';
 for (const file of tsFiles) {
   const targetFile = path.join(outputDir, file.fileName);
 
-  fs.writeFileSync(targetFile, file.content, 'utf8');
+  fs.writeFileSync(targetFile, GENERATED_HEADER + file.content, 'utf8');
 
   console.log(`Gerado: ${path.relative(workspaceRoot, targetFile)}`);
 }