vsrepo 1.0.3 → 1.0.4

package/README.md

@@ -1,22 +1,95 @@
 # VSRepo
 
-Biblioteca de repository para projetos que usam Prisma. Ela permite criar repositories tipados com métodos base (`get`, `save` e `remove`) e métodos dinâmicos mapeados pelo nome, como `findByEmail`, `findManyPaginated`, `updateById` e `deleteManyByIdIn`.
+Biblioteca de repository para projetos que usam Prisma.  
+O VSRepo permite criar repositories tipados com métodos base (`get`, `save` e `remove`) e métodos dinâmicos inferidos pelo nome, como:
 
-## Instalação
+- `findByEmail`
+- `findManyPaginated`
+- `updateById`
+- `deleteManyByIdIn`
+
+Tudo com inferência automática baseada no Prisma Client do próprio projeto.
+
+---
+
+# Instalação
+
+Instale o VSRepo e o Prisma Client:
 
 ```bash
 pnpm add vsrepo @prisma/client
 ```
 
-O Prisma Client deve estar configurado no projeto:
+Gere o Prisma Client:
 
 ```bash
 pnpm prisma generate
 ```
 
-## Uso básico
+---
+
+# Gerando os tipos do VSRepo
+
+O VSRepo precisa conhecer o caminho real do seu Prisma Client para gerar as tipagens corretamente.
+
+Execute:
+
+```bash
+pnpm vsrepo generate --output src/generated/vsrepo --prisma src/generated/prisma/client
+```
+
+ou:
+
+```bash
+pnpm vsrepo generate -o src/generated/vsrepo -p src/generated/prisma/client
+```
+
+## O que esse comando faz
+
+O script:
+
+1. Lê os arquivos de tipagem internos do VSRepo
+2. Substitui o import do Prisma pelo caminho informado em `--prisma`
+3. Gera uma façade tipada dentro da pasta definida em `--output`
+
+Arquivos gerados:
+
+```txt
+src/generated/vsrepo/
+├── VSRepoError.ts
+├── VSRepoError.types.d.ts
+├── VSRepository.ts
+├── VSRepository.types.d.ts
+└── index.ts
+```
+
+---
+
+# Como importar depois
+
+Após gerar os arquivos:
+
+```ts
+import { setupVSRepo } from "../generated/vsrepo";
+```
+
+ou:
+
+```ts
+import {
+  setupVSRepo,
+  type SelectModels,
+  type WhereModel,
+} from "../generated/vsrepo";
+```
+
+Você NÃO deve mais importar diretamente de `vsrepo`.
 
-Crie uma instância do Prisma Client:
+---
+
+# Uso básico
+
+## Criando o Prisma Client
 
 ```ts
 // src/db.ts
@@ -27,12 +100,21 @@ const prisma = new PrismaClient();
 export default prisma;
 ```
 
-Depois crie o repository do modelo:
+---
+
+# Criando um repository
 
 ```ts
 // src/repositories/usuarioRepository.ts
+
 import prisma from "../db";
-import { setupVSRepo, type SelectModels, type WhereModel } from "vsrepo";
+
+import {
+  setupVSRepo,
+  type SelectModels,
+  type WhereModel,
+} from "../generated/vsrepo";
+
 import type { Prisma } from "@prisma/client";
 
 type Usuario = Prisma.usuarioGetPayload<{
@@ -48,6 +130,7 @@ const usuarioSelectModels = {
     nome: true,
     email: true,
   },
+
   minimal: {
     id: true,
   },
@@ -60,15 +143,34 @@ const usuarioRequiredWhere = {
 const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()({
   tableName: "usuario",
   pkName: "id",
+
   selectModels: usuarioSelectModels,
   defaultSelectModel: "public",
+
   requiredWhere: usuarioRequiredWhere,
+
   methods: {
-    findByEmail: { map: true, fbMode: "one" },
-    findManyPaginated: { map: true },
-    updateById: { map: true },
-    deleteManyByIdIn: { map: true, whereType: "overwrite" },
-    count: { map: true },
+    findByEmail: {
+      map: true,
+      fbMode: "one",
+    },
+
+    findManyPaginated: {
+      map: true,
+    },
+
+    updateById: {
+      map: true,
+    },
+
+    deleteManyByIdIn: {
+      map: true,
+      whereType: "overwrite",
+    },
+
+    count: {
+      map: true,
+    },
   },
 });
 
@@ -77,7 +179,9 @@ const usuarioRepository = usuarioVSRepo.build(prisma);
 export default usuarioRepository;
 ```
 
-Use o repository na aplicação:
+---
+
+# Usando o repository
 
 ```ts
 import usuarioRepository from "./repositories/usuarioRepository";
@@ -99,30 +203,44 @@ await usuarioRepository.updateById(usuario.id, {
 await usuarioRepository.remove(usuario.id);
 ```
 
-## Métodos base
+---
 
-Ao chamar `build(prisma)`, o VSRepo cria três métodos por padrão:
+# Métodos base
+
+Ao executar:
+
+```ts
+.build(prisma)
+```
 
-| Método | Descrição |
-| --- | --- |
-| `get(pk, options?)` | Busca um registro pela primary key definida em `pkName`. |
-| `save(obj, options?)` | Cria ou atualiza um registro. Se `obj` tiver a primary key, usa `upsert`; se não tiver, usa `create`. |
-| `remove(pk, options?)` | Remove um registro pela primary key. |
+o VSRepo cria automaticamente:
 
-Você pode configurar esses métodos no `build`:
+| Método       | Descrição               |
+| ------------ | ----------------------- |
+| `get(pk)`    | Busca pela primary key  |
+| `save(obj)`  | Cria ou atualiza        |
+| `remove(pk)` | Remove pela primary key |
+
+---
+
+# Configurando métodos base
 
 ```ts
 const usuarioRepository = usuarioVSRepo.build(prisma, {
   freeze: true,
+
   showWorking: false,
+
   baseMethods: {
     get: {
       active: true,
       defaultSelect: "public",
     },
+
     remove: {
       defaultSelect: "minimal",
     },
+
     save: {
       active: true,
     },
@@ -130,43 +248,82 @@ const usuarioRepository = usuarioVSRepo.build(prisma, {
 });
 ```
 
-## Select models
+---
+
+# Select models
 
-`selectModels` define selects reutilizáveis do Prisma. O `defaultSelectModel` é aplicado quando o método não recebe outro select.
+`selectModels` cria selects reutilizáveis.
 
 ```ts
 const usuario = await usuarioRepository.get(id, {
   selectModel: "minimal",
 });
+```
+
+Para retornar o payload padrão do Prisma:
 
+```ts
 const usuarioCompleto = await usuarioRepository.get(id, {
   selectModel: false,
 });
 ```
 
-Use `selectModel: false` para não aplicar nenhum select model e deixar o Prisma retornar o payload padrão.
+---
+
+# Métodos dinâmicos
 
-## Métodos dinâmicos
+Métodos dinâmicos são definidos em:
 
-Métodos dinâmicos são declarados em `methods` com `map: true`. O nome do método informa qual operação do Prisma será usada e quais campos entram no `where`.
+```ts
+methods: {
+}
+```
 
-Exemplos:
+Exemplo:
 
 ```ts
 methods: {
   findUniqueByIdAndEmail: { map: true },
-  findByNomeContainsInsensitive: { map: true },
-  findManyPaginated: { map: true },
-  findListWhereOrderedAndPaginated: { map: true, whereType: "overwrite" },
-  createManyAndReturn: { map: true },
-  updateById: { map: true },
-  deleteManyByIdIn: { map: true, whereType: "overwrite" },
-  existsByEmail: { map: true },
-  countByPerfil: { map: true },
+
+  findByNomeContainsInsensitive: {
+    map: true,
+  },
+
+  findManyPaginated: {
+    map: true,
+  },
+
+  findListWhereOrderedAndPaginated: {
+    map: true,
+    whereType: 'overwrite',
+  },
+
+  createManyAndReturn: {
+    map: true,
+  },
+
+  updateById: {
+    map: true,
+  },
+
+  deleteManyByIdIn: {
+    map: true,
+    whereType: 'overwrite',
+  },
+
+  existsByEmail: {
+    map: true,
+  },
+
+  countByPerfil: {
+    map: true,
+  },
 }
 ```
 
-Uso:
+---
+
+# Exemplos de uso
 
 ```ts
 const usuario = await usuarioRepository.findUniqueByIdAndEmail(id, email);
@@ -179,43 +336,58 @@ const pagina = await usuarioRepository.findManyPaginated({
 });
 
 const ordenado = await usuarioRepository.findListWhereOrderedAndPaginated(
-  { nome: { startsWith: "A" } },
-  { dataCriacao: "desc" },
-  { take: 10 }
+  {
+    nome: {
+      startsWith: "A",
+    },
+  },
+
+  {
+    dataCriacao: "desc",
+  },
+
+  {
+    take: 10,
+  },
 );
 ```
 
-## Filtros pelo nome do método
+---
 
-O VSRepo interpreta sufixos no nome dos métodos para montar o `where`:
+# Filtros suportados
 
-| Padrão | Exemplo |
-| --- | --- |
-| `And` / `Or` | `findByIdAndEmail`, `findByNomeOrEmail` |
-| `In` / `NotIn` | `deleteManyByIdIn` |
-| `Contains` / `StartsWith` / `EndsWith` | `findByNomeContains` |
-| `Insensitive` | `findByNomeContainsInsensitive` |
-| `GreaterThan` / `GreaterThanEqual` | `findByIdadeGreaterThan` |
-| `LessThan` / `LessThanEqual` | `findByIdadeLessThanEqual` |
-| `IsNull` / `IsNotNull` | `findByPerfilIsNotNull` |
-| `IsTrue` / `IsFalse` | `findByAtivoIsTrue` |
-| `Some` / `Every` / `None` | `findByPostagensSomeTituloContains` |
-| `With` / `Without` | `findByPerfilWith`, `findByPerfilWithout` |
+| Padrão             | Exemplo                             |
+| ------------------ | ----------------------------------- |
+| `And` / `Or`       | `findByIdAndEmail`                  |
+| `In` / `NotIn`     | `deleteManyByIdIn`                  |
+| `Contains`         | `findByNomeContains`                |
+| `StartsWith`       | `findByNomeStartsWith`              |
+| `EndsWith`         | `findByEmailEndsWith`               |
+| `Insensitive`      | `findByNomeContainsInsensitive`     |
+| `GreaterThan`      | `findByIdadeGreaterThan`            |
+| `LessThanEqual`    | `findByIdadeLessThanEqual`          |
+| `IsNull`           | `findByPerfilIsNull`                |
+| `IsTrue`           | `findByAtivoIsTrue`                 |
+| `Some`             | `findByPostagensSomeTituloContains` |
+| `With` / `Without` | `findByPerfilWith`                  |
 
-## Relações no `save`
+---
 
-Configure `relations` para que `save` consiga criar, conectar, atualizar ou remover relações junto com o registro principal.
+# Relações no save
 
 ```ts
 const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()({
   tableName: "usuario",
+
   pkName: "id",
+
   relations: {
     perfil: {
       pk: "id",
       mode: "oto",
       restriction: "set",
     },
+
     postagens: {
       pk: "id",
       mode: "otm",
@@ -225,20 +397,26 @@ const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()({
 });
 ```
 
-Modos disponíveis:
+## Modos disponíveis
 
-| Modo | Relação |
-| --- | --- |
-| `oto` | one-to-one |
-| `otm` | one-to-many |
-| `mto` | many-to-one |
+| Modo  | Relação      |
+| ----- | ------------ |
+| `oto` | one-to-one   |
+| `otm` | one-to-many  |
+| `mto` | many-to-one  |
 | `mtm` | many-to-many |
 
-`restriction: "set"` substitui o conjunto atual quando aplicável. `restriction: "add"` adiciona/conecta sem limpar os registros já relacionados.
+---
+
+# Transações
 
-## Transações
+Todos os métodos aceitam:
 
-Todos os métodos aceitam `options.db`. Use isso para executar operações dentro de uma transação do Prisma:
+```ts
+options.db;
+```
+
+Exemplo:
 
 ```ts
 await prisma.$transaction(async (tx) => {
@@ -248,24 +426,34 @@ await prisma.$transaction(async (tx) => {
       email: "maria@email.com",
       senha: "password",
     },
-    { db: tx }
+
+    {
+      db: tx,
+    },
   );
 
   await usuarioRepository.updateById(
     usuario.id,
-    { ativo: true },
-    { db: tx }
+
+    {
+      ativo: true,
+    },
+
+    {
+      db: tx,
+    },
   );
 });
 ```
 
-## Estendendo um repository
+---
 
-Use `extend` para adicionar métodos manuais mantendo os métodos gerados:
+# Extendendo um repository
 
 ```ts
 const repository = usuarioVSRepo
   .build(prisma)
+
   .extend((repo) => ({
     async buscarAtivosPorDominio(dominio: string) {
       return repo.findByEmailEndsWith(`@${dominio}`);
@@ -273,9 +461,48 @@ const repository = usuarioVSRepo
   }));
 ```
 
-## Scripts do projeto
+---
+
+# Estrutura recomendada
+
+```txt
+src/
+├── db.ts
+├── generated/
+│   ├── prisma/
+│   └── vsrepo/
+├── repositories/
+└── services/
+```
+
+---
+
+# Scripts úteis
 
 ```bash
-pnpm test:usuario
-pnpm test:base-methods:user
+pnpm prisma generate
+
+pnpm vsrepo generate \
+  --output src/generated/vsrepo \
+  --prisma src/generated/prisma/client
+```
+
+---
+
+# Requisitos
+
+- TypeScript
+- Prisma
+- Node.js ESM
+- `"moduleResolution": "bundler"` ou `"nodenext"`
+
+Exemplo:
+
+```json
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext"
+  }
+}
 ```

package/VSRepository/VSRepository.d.ts

@@ -4,7 +4,7 @@ export type DbClient = PrismaClient;
 export type DbTransaction = Prisma.TransactionClient;
 export type ClientOrTransaction = DbClient | DbTransaction;
 
-export * from './VSRepoError';
+export * from './VSRepoError.js';
 
 type OrderPattern = {
     [key: string]: 'asc' | 'desc' | { _count: 'asc' | 'desc' } | OrderPattern;
@@ -241,10 +241,16 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
     };
 };
 
-type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'remove' | 'save'> =
-    C extends { baseMethods: Record<Method, { defaultSelect: infer D }> }
-        ? D extends keyof ExtractSelectModels<Config> ? D : ExtractDefaultSelect<Config>
-        : ExtractDefaultSelect<Config>;
+type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'remove' | 'save', TSelects = ExtractSelectModels<Config>> =
+    C extends { baseMethods?: { [_ in Method]?: { defaultSelect?: infer D } } }
+        ? D extends keyof TSelects 
+            ? D 
+            : ExtractDefaultSelect<Config> extends keyof TSelects 
+                ? ExtractDefaultSelect<Config> 
+                : false
+        : ExtractDefaultSelect<Config> extends keyof TSelects 
+            ? ExtractDefaultSelect<Config> 
+            : false;
 
 type ResolveCurrentReturn<M extends Prisma.ModelName, Models, S, D> = 
     [S] extends [false] 
@@ -261,7 +267,7 @@ type InjectedGet<
     TDefault = ExtractDefaultSelect<Config>,
     TPk = ExtractPkName<T, Config>
 > = C extends { baseMethods: { get: { active: false } } } ? {} : {
-    get<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'get'>>(
+    get<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'get', TSelects>>(
         pk: T[TPk extends keyof T ? TPk : never], options?: MethodOptions<S>
     ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault> | null>;
 };
@@ -272,7 +278,7 @@ type InjectedRemove<
     TDefault = ExtractDefaultSelect<Config>,
     TPk = ExtractPkName<T, Config>
 > = C extends { baseMethods: { remove: { active: false } } } ? {} : {
-    remove<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'remove'>>(
+    remove<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'remove', TSelects>>(
         pk: T[TPk extends keyof T ? TPk : never], options?: MethodOptions<S>
     ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault>>;
 };
@@ -304,14 +310,14 @@ type InjectedSave<
 > = C extends { baseMethods: { save: { active: false } } } ? {} : {
     save<
         O extends UpsertWithRelations<T, M, TRelations>, 
-        S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'save'>
+        S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'save', TSelects>
     >(
         obj: O & UpsertWithRelations<T, M, TRelations>, 
         options?: MethodOptions<S>
     ): Promise<RefineSaveResult<ResolveCurrentReturn<M, TSelects, S, TDefault>, O>>;
 };
 
-type InjectedBaseMethods<T, M extends Prisma.ModelName, Config, C extends BuildConfig | undefined> = 
+type InjectedBaseMethods<T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined> = 
     InjectedGet<T, M, Config, C> & 
     InjectedRemove<T, M, Config, C> & 
     InjectedSave<T, M, Config, C>;
@@ -333,24 +339,24 @@ export type RepoConfig<T, M extends Prisma.ModelName, SM extends Record<string,
     tableName: Uncapitalize<M>;
     pkName: keyof T;
     selectModels?: SM;
-    defaultSelectModel?: keyof SM;
+    defaultSelectModel?: Extract<keyof SM, string>;
     requiredWhere?: WhereModel<M>;
     relations?: RepositoryRelations<T>;
     methods?: Record<string, MethodConfig<M, SM>>;
 };
 
-export type BuiltRepository<T extends object, M extends Prisma.ModelName, Config extends RepoConfig<T, M>, C extends BuildConfig<keyof ExtractSelectModels<Config>> | undefined> = {
+export type BuiltRepository<T extends object, M extends Prisma.ModelName, Config extends RepoConfig<T, M, any>, C extends BuildConfig<any> | undefined> = {
     extend<E>(extensionFunc: (repo: BuiltRepository<T, M, Config, C>) => E): BuiltRepository<T, M, Config, C> & E;
 } & DynamicMethods<T, M, Config, PrismaModelInputs<M>> & InjectedBaseMethods<T, M, Config, C>;
 
-export declare class VSRepository<T extends object, M extends Prisma.ModelName, const Config extends RepoConfig<T, M> = RepoConfig<T, M>> {
+export declare class VSRepository<T extends object, M extends Prisma.ModelName, const Config extends RepoConfig<T, M, any> = RepoConfig<T, M, any>> {
     readonly config: Config;
     constructor(config: Config);
-    build<C extends BuildConfig<keyof ExtractSelectModels<Config>>>(prisma: DbClient, config?: C): BuiltRepository<T, M, Config, C>;
+    build<C extends BuildConfig<any>>(prisma: DbClient, config?: C): BuiltRepository<T, M, Config, C>;
     vsrepocache: never;
 }
 
-export type RepositoryOf<TRepo, C = undefined, E = unknown> =
+export type RepositoryOf<TRepo, C extends BuildConfig<any> | undefined = undefined, E = unknown> =
     TRepo extends VSRepository<infer T, infer M, infer Config>
         ? BuiltRepository<T, M, Config, C> & E
         : never;
@@ -359,7 +365,7 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
     tableName: Uncapitalize<M>;
     pkName: keyof T;
     selectModels?: SelectModels<M>;
-    defaultSelectModel?: Config extends { selectModels: infer SM } ? (keyof SM extends never ? string : keyof SM) : string;
+    defaultSelectModel?: Config extends { selectModels: infer SM } ? (keyof SM extends never ? string : Extract<keyof SM, string>) : string;
     requiredWhere?: WhereModel<M>;
     relations?: RepositoryRelations<T>;
     methods?: {

package/VSRepository/index.d.ts

@@ -1,2 +1,2 @@
-export * from './VSRepoError';
-export * from './VSRepository';
+export * from './VSRepoError.js';
+export * from './VSRepository.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Uma biblioteca de repositório virtual para Prisma",
   "main": "./VSRepository/index.js",
   "types": "./VSRepository/index.d.ts",
@@ -8,12 +8,29 @@
     ".": {
       "types": "./VSRepository/index.d.ts",
       "default": "./VSRepository/index.js"
+    },
+    "./VSRepository": {
+      "types": "./VSRepository/VSRepository.d.ts",
+      "import": "./VSRepository/VSRepository.js"
+    },
+    "./VSRepoError": {
+      "types": "./VSRepository/VSRepoError.d.ts",
+      "import": "./VSRepository/VSRepoError.js"
     }
   },
   "type": "module",
   "files": [
-    "VSRepository"
+    "VSRepository",
+    "scripts"
   ],
+  "bin": {
+    "vsrepo": "./scripts/configure-prisma-import.mjs",
+    "vsrepo-configure-prisma-import": "./scripts/configure-prisma-import.mjs"
+  },
+  "scripts": {
+    "vsrepo": "node ./scripts/configure-prisma-import.mjs",
+    "configure:prisma-import": "node ./scripts/configure-prisma-import.mjs"
+  },
   "keywords": [
     "prisma",
     "repository",

package/scripts/configure-prisma-import.mjs

@@ -0,0 +1,155 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const workspaceRoot = process.cwd();
+const args = process.argv.slice(2);
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+
+const command = args[0]?.startsWith('-') ? 'generate' : args[0] ?? 'generate';
+const commandArgs = command === 'generate' && args[0] !== command ? args : args.slice(1);
+
+if (command !== 'generate') {
+  console.error(`Comando desconhecido: ${command}`);
+  console.error('Uso: vsrepo generate --output <dir-output> --prisma <path-prisma-client>');
+  process.exit(1);
+}
+
+const outputFlagIndex = commandArgs.findIndex((arg) => arg === '--output' || arg === '-o');
+const prismaFlagIndex = commandArgs.findIndex((arg) => arg === '--prisma' || arg === '-p');
+
+const outputArg = outputFlagIndex >= 0 ? commandArgs[outputFlagIndex + 1] : commandArgs[0];
+const prismaArg = prismaFlagIndex >= 0 ? commandArgs[prismaFlagIndex + 1] : null;
+
+if (!outputArg || outputArg.startsWith('-')) {
+  console.error('Uso: vsrepo generate --output <dir-output> --prisma <path-prisma-client>');
+  process.exit(1);
+}
+
+if (!prismaArg || prismaArg.startsWith('-')) {
+  console.error('Uso: vsrepo generate --output <dir-output> --prisma <path-prisma-client>');
+  process.exit(1);
+}
+
+const outputDir = path.resolve(workspaceRoot, outputArg);
+const prismaTargetPath = stripKnownExtension(path.resolve(workspaceRoot, prismaArg));
+
+const installedNodeModulesPath = path.join(workspaceRoot, 'node_modules/vsrepo');
+const installedPackageExists = fs.existsSync(installedNodeModulesPath);
+const packageRoot = installedPackageExists
+  ? installedNodeModulesPath
+  : path.resolve(scriptDirectory, '..');
+
+const sourceDir = path.join(packageRoot, 'VSRepository');
+
+if (!fs.existsSync(sourceDir)) {
+  console.error(`Nao foi possivel localizar a pasta VSRepository em: ${sourceDir}`);
+  process.exit(1);
+}
+
+fs.mkdirSync(outputDir, { recursive: true });
+
+const typeFiles = [
+  'VSRepoError.d.ts',
+  'VSRepository.d.ts',
+];
+
+for (const fileName of typeFiles) {
+  const sourceFile = path.join(sourceDir, fileName);
+
+  if (!fs.existsSync(sourceFile)) {
+    console.warn(`Arquivo ignorado (nao encontrado): ${fileName}`);
+    continue;
+  }
+
+  const targetFile = path.join(outputDir, fileName.replace('.d.ts', '.types.d.ts'));
+  let contents = fs.readFileSync(sourceFile, 'utf8');
+
+  contents = contents.replace(
+    /from\s+(['"])@vsrepo\/prisma\/types\1/g,
+    `from '${relativeImportPath(path.dirname(targetFile), prismaTargetPath)}'`
+  );
+
+  fs.writeFileSync(targetFile, contents, 'utf8');
+  console.log(`Gerado: ${path.relative(workspaceRoot, targetFile)}`);
+}
+
+const tsFiles = [
+  {
+    fileName: 'VSRepoError.ts',
+    content: `import {
+  VSRepoError as VSRepoErrorRuntime,
+  VSRepoConfigError as VSRepoConfigErrorRuntime,
+  VSRepoBuildError as VSRepoBuildErrorRuntime,
+  VSRepoExtendError as VSRepoExtendErrorRuntime,
+  VSRepoRuntimeError as VSRepoRuntimeErrorRuntime
+} from 'vsrepo/VSRepoError';
+
+import type {
+  VSRepoError as VSRepoErrorType,
+  VSRepoConfigError as VSRepoConfigErrorType,
+  VSRepoBuildError as VSRepoBuildErrorType,
+  VSRepoExtendError as VSRepoExtendErrorType,
+  VSRepoRuntimeError as VSRepoRuntimeErrorType
+} from './VSRepoError.types';
+
+export const VSRepoError: typeof VSRepoErrorType = VSRepoErrorRuntime;
+export const VSRepoConfigError: typeof VSRepoConfigErrorType = VSRepoConfigErrorRuntime;
+export const VSRepoBuildError: typeof VSRepoBuildErrorType = VSRepoBuildErrorRuntime;
+export const VSRepoExtendError: typeof VSRepoExtendErrorType = VSRepoExtendErrorRuntime;
+export const VSRepoRuntimeError: typeof VSRepoRuntimeErrorType = VSRepoRuntimeErrorRuntime;
+
+export type * from './VSRepoError.types';
+`,
+  },
+  {
+    fileName: 'VSRepository.ts',
+    content: `import {
+  VSRepository as VSRepositoryRuntime,
+  setupVSRepo as setupVSRepoRuntime
+} from 'vsrepo/VSRepository';
+
+import type {
+  VSRepository as VSRepositoryType,
+  setupVSRepo as setupVSRepoType
+} from './VSRepository.types';
+
+export const VSRepository: typeof VSRepositoryType = VSRepositoryRuntime;
+export const setupVSRepo: typeof setupVSRepoType = setupVSRepoRuntime;
+
+export type * from './VSRepository.types';
+`,
+  },
+  {
+    fileName: 'index.ts',
+    content: `export { VSRepoError, VSRepoConfigError, VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from './VSRepoError.js';
+export { VSRepository, setupVSRepo } from './VSRepository.js';
+
+export type * from './VSRepoError.types';
+export type * from './VSRepository.types';
+`,
+  },
+];
+
+for (const file of tsFiles) {
+  const targetFile = path.join(outputDir, file.fileName);
+  fs.writeFileSync(targetFile, file.content, 'utf8');
+  console.log(`Gerado: ${path.relative(workspaceRoot, targetFile)}`);
+}
+
+console.log('\nVSRepository gerado com tipagem do Prisma.');
+console.log(`Prisma usado em: ${prismaTargetPath}`);
+
+function stripKnownExtension(inputPath) {
+  return inputPath.replace(/\.(?:d\.ts|ts|js|mjs|cjs)$/i, '');
+}
+
+function relativeImportPath(fromDirectory, toPath) {
+  const relativePath = path.relative(fromDirectory, toPath);
+  const normalized = relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+  return toPosix(normalized);
+}
+
+function toPosix(inputPath) {
+  return inputPath.split(path.sep).join('/');
+}