vsrepo 1.1.2 → 1.1.4

package/README.md

@@ -70,21 +70,21 @@ Equivale a:
 
 ```bash
 npx vsrepo generate \
-  --output src/generated/vsrepo \
-  --prisma src/generated/prisma
+  --output generated/vsrepo \
+  --prisma generated/prisma
 ```
 
 **Flags disponíveis:**
 
 | Flag       | Alias | Padrão                 |
 | ---------- | ----- | ---------------------- |
-| `--output` | `-o`  | `src/generated/vsrepo` |
-| `--prisma` | `-p`  | `src/generated/prisma` |
+| `--output` | `-o`  | `generated/vsrepo` |
+| `--prisma` | `-p`  | `generated/prisma` |
 
 **Arquivos gerados:**
 
 ```
-src/generated/vsrepo/
+generated/vsrepo/
 ├── VSRepoError.ts
 ├── VSRepoError.types.d.ts
 ├── VSRepository.ts
@@ -96,7 +96,7 @@ Após gerar, importe sempre a partir da pasta gerada:
 
 ```ts
 // CORRETO ✅
-import { setupVSRepo } from "../generated/vsrepo";
+import { setupVSRepo } from "../../generated/vsrepo";
 
 // ERRADO ❌
 import { setupVSRepo } from "vsrepo";
@@ -110,7 +110,7 @@ import { setupVSRepo } from "vsrepo";
 
 ```ts
 // src/configs/db.ts
-import { PrismaClient } from '../generated/prisma/client';
+import { PrismaClient } from '../../generated/prisma/client';
 import { PrismaPg } from '@prisma/adapter-pg';
 import 'dotenv/config';
 
@@ -125,8 +125,8 @@ export default prisma;
 ```ts
 // src/repositories/usuarioRepository.ts
 import prisma from "../configs/db";
-import { setupVSRepo } from "../generated/vsrepo";
-import type { Usuario } from "../generated/prisma/client";
+import { setupVSRepo } from "../../generated/vsrepo";
+import type { Usuario } from "../../generated/prisma/client";
 
 const usuarioRepository = setupVSRepo<Usuario, "usuario">()({
   tableName: "usuario",
@@ -172,11 +172,11 @@ O VSRepository pode ser facilmente integrado em projetos NestJS através de prov
 ### Configurando o repository como provider
 
 ```ts
-// src/repositories/user.repository.ts
+// src/resources/user/user.repository.ts
 import { Provider } from "@nestjs/common";
 import { PrismaService } from "../../database/prisma.service";
-import { UserGetPayload } from "../../generated/prisma/models";
-import { setupVSRepo } from "../../generated/vsrepo";
+import { UserGetPayload } from "../../../generated/prisma/models";
+import { setupVSRepo } from "../../../generated/vsrepo";
 
 const userVSRepo = setupVSRepo<
     UserGetPayload<{ include: { profile: true } }>,
@@ -242,9 +242,9 @@ export const UserRepositoryProvider: Provider = {
 ### Registrando o provider no módulo
 
 ```ts
-// src/modules/user/user.module.ts
+// src/resources/user/user.module.ts
 import { Module } from "@nestjs/common";
-import { UserRepositoryProvider } from "../../repositories/user.repository";
+import { UserRepositoryProvider } from "./user.repository";
 import { UserService } from "./user.service";
 import { UserController } from "./user.controller";
 
@@ -260,9 +260,9 @@ export class UserModule {}
 ### Utilizando o repository em um serviço
 
 ```ts
-// src/modules/user/user.service.ts
+// src/resources/user/user.service.ts
 import { Injectable, Inject } from "@nestjs/common";
-import { USER_REPOSITORY, UserRepository } from "../../repositories/user.repository";
+import { USER_REPOSITORY, UserRepository } from "./user.repository";
 
 @Injectable()
 export class UserService {
@@ -292,7 +292,7 @@ export class UserService {
 ### Usando em um controller
 
 ```ts
-// src/modules/user/user.controller.ts
+// src/resources/user/user.controller.ts
 import { Controller, Get, Post, Body, Param, Patch, Delete } from "@nestjs/common";
 import { UserService } from "./user.service";
 
@@ -723,7 +723,7 @@ methods: {
 Configure relações para que o `save` as gerencie automaticamente. Para que as relações apareçam no autocomplete, o tipo genérico deve incluir as relações usando `GetPayload`:
 
 ```ts
-import type { Prisma } from "../generated/prisma/client";
+import type { Prisma } from "../../generated/prisma/client";
 
 type Usuario = Prisma.usuarioGetPayload<{
   include: { perfil: true; postagens: true };
@@ -818,7 +818,7 @@ const usuarioRepository = setupVSRepo<Usuario, "usuario">()({
 O VSRepository lança `VSRepoError` e suas subclasses em situações específicas (OBS: Erros do Prisma não são sobrescritos como `VSRepoError`):
 
 ```ts
-import { VSRepoError } from "../generated/vsrepo";
+import { VSRepoError } from "../../generated/vsrepo";
 
 try {
   const usuario = await usuarioRepository.get();
@@ -847,7 +847,7 @@ O VSRepository exporta os seguintes tipos para uso nas suas aplicações:
 ### Tipos de cliente
 
 ```ts
-import type { DbClient, DbTransaction, ClientOrTransaction } from "../generated/vsrepo";
+import type { DbClient, DbTransaction, ClientOrTransaction } from "../../generated/vsrepo";
 
 type DbClient           = PrismaClient;
 type DbTransaction      = Prisma.TransactionClient;
@@ -864,7 +864,7 @@ import type {
   OrdenationModel,
   PaginationModel,
   ModelUpsertInput,
-} from "../generated/vsrepo";
+} from "../../generated/vsrepo";
 
 // Select de um campo específico
 type UsuarioSelect = SelectModel<"usuario">;
@@ -888,7 +888,7 @@ type UsuarioUpsertInput = ModelUpsertInput<"usuario">;
 ### Todos os inputs do modelo
 
 ```ts
-import type { PrismaModelInputs } from "../generated/vsrepo";
+import type { PrismaModelInputs } from "../../generated/vsrepo";
 
 type UsuarioInputs = PrismaModelInputs<"usuario">;
 // Contém:
@@ -899,7 +899,7 @@ type UsuarioInputs = PrismaModelInputs<"usuario">;
 ### Tipos de opções de método
 
 ```ts
-import type { MethodOptions, MethodOptionsModel } from "../generated/vsrepo";
+import type { MethodOptions, MethodOptionsModel } from "../../generated/vsrepo";
 
 // MethodOptions<S> — opções passadas nos métodos do repository
 // S = chave do select model ou false
@@ -919,7 +919,7 @@ import type {
   RepositoryRelations,
   ExtractRelationConfig,
   UpsertWithRelations,
-} from "../generated/vsrepo";
+} from "../../generated/vsrepo";
 
 // Configuração de um método dinâmico
 type MeuMethodConfig = MethodConfig<"usuario", typeof meuSelectModels>;
@@ -943,7 +943,7 @@ type UsuarioComRelacoes = UpsertWithRelations<Usuario, "usuario", typeof relatio
 ### Tipo do repository construído
 
 ```ts
-import type { BuiltRepository, RepositoryOf } from "../generated/vsrepo";
+import type { BuiltRepository, RepositoryOf } from "../../generated/vsrepo";
 
 // Tipo completo de um repository construído
 type MeuRepo = BuiltRepository<Usuario, "usuario", typeof config, typeof buildConfig>;
@@ -970,7 +970,7 @@ type UsuarioRepositoryExtended = RepositoryOf<typeof usuarioVSRepo, undefined, t
 ### Tipo auxiliar
 
 ```ts
-import type { DistributiveOmit } from "../generated/vsrepo";
+import type { DistributiveOmit } from "../../generated/vsrepo";
 
 // Omit distributivo — preserva unions ao omitir propriedades
 type SemEmail = DistributiveOmit<Usuario | Perfil, "email">;

package/VSRepository/VSRepoUtils.js

@@ -1,84 +1,127 @@
-import { VSRepoConfigError } from "./VSRepoError.js";
+import z from "zod";
+import { VSRepoConfigError, VSRepoBuildError } from "./VSRepoError.js";
 
-export class FieldValidator {
-    constructor(throws) {
-        this.throws = throws;
-    }
+const stringSchema = z.string().trim().nonempty();
+const objectSchema = z.looseObject({});
+const booleanSchema = z.boolean();
 
-    validate(
-        field,
-        fieldName,
-        mustBe,
-        undefinedAble,
-        nullAble,
-        customReason
-    ) {
-        if (field === undefined) {
-            if (undefinedAble) return;
-            throw this.instanceError(fieldName, customReason ?? "cannot be undefined");
+export function validateConfig(config) {
+    const configSchema = z.strictObject({
+        tableName: stringSchema,
+        pkName: stringSchema,
+        selectModels: z.record(stringSchema, objectSchema).optional(),
+        defaultSelectModel: stringSchema.optional(),
+        requiredWhere: objectSchema.optional(),
+        relations: z.record(
+            stringSchema,
+            z.strictObject({
+                mode: z.enum(['otm', 'mtm', 'mto', 'oto']),
+                restriction: z.enum(['set', 'add']),
+                pk: stringSchema,
+                nullAble: booleanSchema.optional(),
+            })
+        ).optional(),
+        methods: z.record(stringSchema, z.strictObject({
+            map: booleanSchema,
+            selectModel: stringSchema.or(z.literal(false)).optional(),
+            whereType: z.enum(["overwrite", "extending"]).optional(),
+            proxyTo: stringSchema.optional(),
+            pushWhere: objectSchema.optional(),
+            fbMode: z.enum(["one", "list"]).optional(),
+            injectOrdenation: objectSchema.or(z.array(objectSchema)).optional(),
+            injectPagination: objectSchema.optional()
+        })).optional()
+    }).superRefine((config, ctx)=>{
+        if (config.defaultSelectModel && !config.selectModels?.[config.defaultSelectModel]) {
+            ctx.addIssue({
+                code: "vs_custom",
+                path: ["defaultSelectModel"],
+                message: "must be a valid key of 'selectModels'",
+            });
         }
 
-        if (field === null) {
-            if (nullAble) return;
-            throw this.instanceError(fieldName, customReason ?? "cannot be null");
+        if (config.methods) {
+            for (const [key, method] of Object.entries(config.methods)) {
+                if (method.selectModel && !config.selectModels?.[method.selectModel]) {
+                    ctx.addIssue({
+                        code: "vs_custom",
+                        path: ["methods", key, "selectModel"],
+                        message: "must be a valid key of 'selectModels'",
+                    });
+                }
+            }
         }
+    });
 
-        const condition = typeof mustBe === "function" ? !mustBe(field) : typeof field !== mustBe;
+    const configParsed = configSchema.safeParse(config);
 
-        if(condition) {
-            throw this.instanceError(fieldName, customReason ?? `must be a valid ${mustBe}`);
-        };
+    if(!configParsed.success) {
+        const firstIssue = configParsed.error.issues[0];
+        const path = firstIssue.path.length ? firstIssue.path.join(".") : "config";
+        throw new VSRepoConfigError(`[VSRepository] (config) ${path}: ${firstIssue.message}`)
     }
 
-    instanceError(fieldName, reason) {
-        const error = new this.throws("");
-        error.message = `[VSRepository] (${error.type}) '${fieldName}' ${reason}.`;
-        return error;
-    }
+    return configParsed.data;
 }
 
-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'");
+export function validateBuildConfig(buildConfig, buildInstance) {
+    const activeSchema = booleanSchema.default(true);
+    const defaultSelectSchema = buildInstance.selectModels ?
+        z.enum(Object.keys(buildInstance.selectModels)).optional()
+        : z.never("can only be passed if you have configured 'selectModels'.");
+    const ignoreRequiredWhereSchema = booleanSchema.default(false);
+
+    const buildConfigSchema = z.strictObject({
+        freeze: booleanSchema.default(true),
+        showWorking: booleanSchema.default(false),
+        baseMethods: z.strictObject({
+            get: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            getOrThrow: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            getAll: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            remove: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            save: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            removeList: z.strictObject({
+                active: activeSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            total: z.strictObject({
+                active: activeSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            has: z.strictObject({
+                active: activeSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+        }).optional()
+    });
+
+    const buildConfigParsed = buildConfigSchema.safeParse(buildConfig);
+
+    if(!buildConfigParsed.success) {
+        const firstIssue = buildConfigParsed.error.issues[0];
+        const path = firstIssue.path.length ? firstIssue.path.join(".") : "config";
+        throw new VSRepoBuildError(`[VSRepository] (build) ${path}: ${firstIssue.message}`)
     }
 
-    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`);
-        }
-    }
-}
+    return buildConfigParsed.data;
+}

package/VSRepository/VSRepository.d.ts

@@ -590,6 +590,11 @@ export type BuiltRepository<T extends object, M extends Prisma.ModelName, Config
      * Estende o repository com métodos personalizados sem perder a tipagem.
      */
     extend<E>(extensionFunc: (repo: BuiltRepository<T, M, Config, C>) => E): BuiltRepository<T, M, Config, C> & E;
+
+    /**
+     * Instância do Prisma Client passada no `build`.
+     */
+    readonly prisma: DbClient;
 } & DynamicMethods<T, M, Config, PrismaModelInputs<M>> & InjectedBaseMethods<T, M, Config, C>;
 
 /**
@@ -605,7 +610,7 @@ export declare class VSRepository<T extends object, M extends Prisma.ModelName,
     /**
      * Constrói o repository final com os métodos base e dinâmicos.
      */
-    build<C extends BuildConfig<any>>(prisma: DbClient, config?: C): BuiltRepository<T, M, Config, C>;
+    build<C extends BuildConfig<keyof ExtractSelectModels<Config>>>(prisma: DbClient, config?: C): BuiltRepository<T, M, Config, C>;
     vsrepocache: never;
 }
 

package/VSRepository/VSRepository.js

@@ -9,7 +9,7 @@ export * from "./VSRepoError.js";
 
 // * Importando classes de erro
 import { VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from "./VSRepoError.js";
-import { validateConfig } from "./VSRepoUtils.js";
+import { validateBuildConfig, validateConfig } from "./VSRepoUtils.js";
 
 // * Essa é a classe pincipal, é a partir dela que serão criados os objetos dos repositories
 export class VSRepository {
@@ -29,7 +29,7 @@ export class VSRepository {
     methods;
 
     constructor(config) {
-        validateConfig(config);
+        config = validateConfig(config);
 
         this.vsrepocache = new Map();
         this.tableName = config.tableName;
@@ -59,18 +59,17 @@ export class VSRepository {
         return extended;
     }
 
-    build(prisma, config = {}) {
-        const showWorking = config.showWorking;
-
-        if(typeof config !== 'object' || config === null) {
-            throw new VSRepoBuildError(`[VSRepository] (build) 'config' must be a valid object.`);
-        }
-        if(config.freeze === undefined) {
-            config.freeze = true;
+    build(prisma, config = { freeze: true, showWorking: false }) {
+        if(typeof prisma !== 'object' || prisma === null) {
+            throw new VSRepoBuildError(`[VSRepository] (build) 'prisma' must be a valid Prisma Client.`);
         }
 
         const buildInstance = Object.create(this);
 
+        config = validateBuildConfig(config, buildInstance);
+
+        const showWorking = config.showWorking;
+
         const relationsKeys = buildInstance.relations ? Object.keys(buildInstance.relations) : [];
 
         const methods = buildInstance.methods;
@@ -487,10 +486,6 @@ export class VSRepository {
                                 whereArgs.push(buildedWhere);
                             }
 
-                            if(showWorking) {
-                                console.log(`[VSRepository] (build) Where object builded to ${keyToMap}:\n`, JSON.stringify(buildedWhere, null, 2));
-                            }
-
                             if(buildedWhere.autoInjectVal === undefined) argsCount++;
                         }
 
@@ -700,9 +695,9 @@ export class VSRepository {
                     const missingParams = whereParams.concat(otherParams).slice(args.length);
                     throw new VSRepoRuntimeError(`[VSRepository] (runtime) Missing parameters: ${missingParams.join(', ')}`);
                 } else if(args.length > argsCount) {
-                    const optionsArg = args[args.length - 1]
+                    const optionsArg = args[args.length - 1];
                     db = optionsArg.db ?? db;
-                    optionsSelectModel = optionsArg.selectModel
+                    optionsSelectModel = optionsArg.selectModel;
                 } else {
                     args.push('1')
                 }
@@ -1198,7 +1193,9 @@ export class VSRepository {
             }
         }
 
-        if(config.freeze) Object.freeze(buildInstance)
+        buildInstance.prisma = prisma;
+
+        if(config.freeze) Object.freeze(buildInstance);
         return buildInstance;
     }
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "vsrepo",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jaobrabo123/VSRepository"
+    "url": "git+https://github.com/jaobrabo123/VSRepository.git"
   },
   "main": "./VSRepository/index.js",
   "types": "./VSRepository/index.d.ts",
@@ -32,7 +32,7 @@
     "scripts"
   ],
   "bin": {
-    "vsrepo": "./scripts/configure-prisma-import.mjs"
+    "vsrepo": "scripts/configure-prisma-import.mjs"
   },
   "engines": {
     "node": ">=18"
@@ -63,5 +63,8 @@
     "prisma": "^7.8.0",
     "tsx": "^4.22.3",
     "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
   }
-}
+}

package/scripts/configure-prisma-import.mjs

@@ -8,8 +8,8 @@ const workspaceRoot = process.cwd();
 const args = process.argv.slice(2);
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 
-const DEFAULT_OUTPUT = 'src/generated/vsrepo';
-const DEFAULT_PRISMA = 'src/generated/prisma';
+const DEFAULT_OUTPUT = 'generated/vsrepo';
+const DEFAULT_PRISMA = 'generated/prisma';
 const GENERATED_HEADER = `/**
  * ! THIS FILE IS AUTO-GENERATED.
  * ! DO NOT EDIT MANUALLY.
@@ -55,7 +55,7 @@ if (prismaArg.startsWith('-')) {
 const outputDir = path.resolve(workspaceRoot, outputArg);
 
 const prismaTargetPath = stripKnownExtension(
-  path.resolve(workspaceRoot, prismaArg, 'client')
+  path.resolve(workspaceRoot, prismaArg, prismaArg.endsWith('client') ? '' : 'client')
 );
 
 const installedNodeModulesPath = path.join(workspaceRoot, 'node_modules/vsrepo');
@@ -186,7 +186,7 @@ const readmeTarget = path.join(outputDir, 'README.md');
 
 if (fs.existsSync(readmeSource)) {
   fs.copyFileSync(readmeSource, readmeTarget);
-  console.log(`Copiado: ${path.relative(workspaceRoot, readmeTarget)} (origem: ${path.relative(workspaceRoot, readmeSource)})`);
+  console.log(`Gerado: ${path.relative(workspaceRoot, readmeTarget)}`);
 } else {
   console.warn(`README.md do VSRepository nao encontrado em: ${path.relative(workspaceRoot, readmeSource)}. Ignorando a copia.`);
 }