vsrepo 1.1.2 → 1.1.3

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.3",
   "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"
   }
-}
+}