vsrepo 1.2.6 → 1.2.7

package/dist/internal/resolvers/ugly-where.resolve.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUglyWhere = resolveUglyWhere;
+const uncapitalize_util_1 = require("../utils/uncapitalize.util");
+function resolveUglyWhere(keySplitedAnd) {
+    const uglyWhere = { name: "", pushProperty: "$$$" };
+    let nullMode = undefined;
+    if (keySplitedAnd.includes("IsNull")) {
+        uglyWhere.pushProperty = "$$$";
+        uglyWhere.autoInjectVal = null;
+        nullMode = "is";
+        keySplitedAnd = keySplitedAnd.replace("IsNull", "");
+    }
+    else if (keySplitedAnd.includes("IsNotNull")) {
+        uglyWhere.pushProperty = "not";
+        uglyWhere.autoInjectVal = null;
+        nullMode = "not";
+        keySplitedAnd = keySplitedAnd.replace("IsNotNull", "");
+    }
+    else if (keySplitedAnd.includes("IsTrue")) {
+        uglyWhere.pushProperty = "$$$";
+        uglyWhere.autoInjectVal = true;
+        keySplitedAnd = keySplitedAnd.replace("IsTrue", "");
+    }
+    else if (keySplitedAnd.includes("IsFalse")) {
+        uglyWhere.pushProperty = "$$$";
+        uglyWhere.autoInjectVal = false;
+        keySplitedAnd = keySplitedAnd.replace("IsFalse", "");
+    }
+    else {
+        if (keySplitedAnd.includes("Insensitive")) {
+            uglyWhere.properties = {};
+            uglyWhere.properties.mode = "insensitive";
+            keySplitedAnd = keySplitedAnd.replace("Insensitive", "");
+        }
+        if (keySplitedAnd.includes("Optional")) {
+            keySplitedAnd = keySplitedAnd.replace("Optional", "");
+        }
+        if (keySplitedAnd.includes("NotBetween")) {
+            uglyWhere.pushProperty = "not";
+            uglyWhere.betweenMode = true;
+            keySplitedAnd = keySplitedAnd.replace("NotBetween", "");
+        }
+        else if (keySplitedAnd.includes("Between")) {
+            uglyWhere.pushProperty = "$$$";
+            uglyWhere.betweenMode = true;
+            keySplitedAnd = keySplitedAnd.replace("Between", "");
+        }
+        else if (keySplitedAnd.includes("NotStartsWith")) {
+            uglyWhere.pushProperty = "not.startsWith";
+            keySplitedAnd = keySplitedAnd.replace("NotStartsWith", "");
+        }
+        else if (keySplitedAnd.includes("StartsWith")) {
+            uglyWhere.pushProperty = "startsWith";
+            keySplitedAnd = keySplitedAnd.replace("StartsWith", "");
+        }
+        else if (keySplitedAnd.includes("NotEndsWith")) {
+            uglyWhere.pushProperty = "not.endsWith";
+            keySplitedAnd = keySplitedAnd.replace("NotEndsWith", "");
+        }
+        else if (keySplitedAnd.includes("EndsWith")) {
+            uglyWhere.pushProperty = "endsWith";
+            keySplitedAnd = keySplitedAnd.replace("EndsWith", "");
+        }
+        else if (keySplitedAnd.includes("NotContains")) {
+            uglyWhere.pushProperty = "not.contains";
+            keySplitedAnd = keySplitedAnd.replace("NotContains", "");
+        }
+        else if (keySplitedAnd.includes("Contains")) {
+            uglyWhere.pushProperty = "contains";
+            keySplitedAnd = keySplitedAnd.replace("Contains", "");
+        }
+        else if (keySplitedAnd.includes("LessThanEqual")) {
+            uglyWhere.pushProperty = "lte";
+            keySplitedAnd = keySplitedAnd.replace("LessThanEqual", "");
+        }
+        else if (keySplitedAnd.includes("LessThan")) {
+            uglyWhere.pushProperty = "lt";
+            keySplitedAnd = keySplitedAnd.replace("LessThan", "");
+        }
+        else if (keySplitedAnd.includes("GreaterThanEqual")) {
+            uglyWhere.pushProperty = "gte";
+            keySplitedAnd = keySplitedAnd.replace("GreaterThanEqual", "");
+        }
+        else if (keySplitedAnd.includes("GreaterThan")) {
+            uglyWhere.pushProperty = "gt";
+            keySplitedAnd = keySplitedAnd.replace("GreaterThan", "");
+        }
+        else if (keySplitedAnd.includes("NotIn")) {
+            uglyWhere.pushProperty = "notIn";
+            keySplitedAnd = keySplitedAnd.replace("NotIn", "");
+        }
+        else if (keySplitedAnd.includes("In")) {
+            uglyWhere.pushProperty = "in";
+            keySplitedAnd = keySplitedAnd.replace("In", "");
+        }
+        else if (keySplitedAnd.includes("Not")) {
+            uglyWhere.pushProperty = "not";
+            keySplitedAnd = keySplitedAnd.replace("Not", "");
+        }
+        else {
+            uglyWhere.pushProperty = "$$$";
+        }
+    }
+    if (keySplitedAnd.includes("Without")) {
+        const keySplitedConector = keySplitedAnd.split("Without");
+        const specificField = keySplitedConector[1];
+        if (!specificField) {
+            if (nullMode) {
+                uglyWhere.pushProperty = nullMode === "not" ? "is" : "isNot";
+            }
+            else {
+                uglyWhere.pushProperty = "isNot";
+                uglyWhere.autoInjectVal = {};
+            }
+        }
+        else {
+            uglyWhere.pushProperty = `isNot.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+        }
+        keySplitedAnd = keySplitedConector[0];
+    }
+    else if (keySplitedAnd.includes("With")) {
+        const keySplitedConector = keySplitedAnd.split("With");
+        const specificField = keySplitedConector[1];
+        if (!specificField) {
+            if (nullMode) {
+                uglyWhere.pushProperty = nullMode === "not" ? "isNot" : "is";
+            }
+            else {
+                uglyWhere.pushProperty = "is";
+                uglyWhere.autoInjectVal = {};
+            }
+        }
+        else {
+            uglyWhere.pushProperty = `is.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+        }
+        keySplitedAnd = keySplitedConector[0];
+    }
+    else if (keySplitedAnd.includes("Some")) {
+        const keySplitedConector = keySplitedAnd.split("Some");
+        const specificField = keySplitedConector[1];
+        if (!specificField) {
+            uglyWhere.pushProperty = "some";
+            uglyWhere.autoInjectVal = {};
+        }
+        else {
+            uglyWhere.pushProperty = `some.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+        }
+        keySplitedAnd = keySplitedConector[0];
+    }
+    else if (keySplitedAnd.includes("Every")) {
+        const keySplitedConector = keySplitedAnd.split("Every");
+        const specificField = keySplitedConector[1];
+        if (!specificField) {
+            uglyWhere.pushProperty = "every";
+            uglyWhere.autoInjectVal = {};
+        }
+        else {
+            uglyWhere.pushProperty = `every.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+        }
+        keySplitedAnd = keySplitedConector[0];
+    }
+    else if (keySplitedAnd.includes("None")) {
+        const keySplitedConector = keySplitedAnd.split("None");
+        const specificField = keySplitedConector[1];
+        if (!specificField) {
+            uglyWhere.pushProperty = "none";
+            uglyWhere.autoInjectVal = {};
+        }
+        else {
+            uglyWhere.pushProperty = `none.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+        }
+        keySplitedAnd = keySplitedConector[0];
+    }
+    keySplitedAnd = (0, uncapitalize_util_1.uncapitalize)(keySplitedAnd);
+    uglyWhere.name = keySplitedAnd;
+    return uglyWhere;
+}

package/dist/internal/utils/logger.util.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = logger;
+exports.performanceLoggerStart = performanceLoggerStart;
+exports.performanceLoggerEnd = performanceLoggerEnd;
+function logger(message, moment, tableName, obj) {
+    console.log(`[VSRepository] (${tableName ?? "unknown"}: ${moment}) ${message}`);
+    if (obj)
+        console.log(JSON.stringify(obj, null, 2));
+}
+function performanceLoggerStart(tableName, operation, prismaArgs) {
+    logger(`Executing ${operation}.`, "runtime", tableName);
+    if (prismaArgs)
+        logger(`Built arguments to ${operation}:`, "runtime", tableName, prismaArgs);
+    return performance.now();
+}
+function performanceLoggerEnd(tableName, operation, start) {
+    const end = performance.now();
+    const duration = (end - start).toFixed(2);
+    logger(`Executed ${operation} (took: ${duration}ms).`, "runtime", tableName);
+}

package/dist/internal/utils/schemas.util.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanSchema = exports.objectSchema = exports.stringSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.stringSchema = zod_1.default.string().trim().nonempty();
+exports.objectSchema = zod_1.default.looseObject({});
+exports.booleanSchema = zod_1.default.boolean();

package/dist/internal/utils/uncapitalize.util.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uncapitalize = uncapitalize;
+function uncapitalize(text) {
+    return text[0]?.toLowerCase() + text.slice(1, text.length);
+}

package/dist/internal/validation/build-config.validate.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBuildConfig = validateBuildConfig;
+const zod_1 = __importDefault(require("zod"));
+const schemas_util_1 = require("../utils/schemas.util");
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+const defaultBaseMethodConfig = {
+    active: true,
+    ignoreRequiredWhere: false,
+};
+const defaultBaseMethods = {
+    get: defaultBaseMethodConfig,
+    getOrThrow: defaultBaseMethodConfig,
+    getAll: defaultBaseMethodConfig,
+    remove: defaultBaseMethodConfig,
+    save: defaultBaseMethodConfig,
+    patch: defaultBaseMethodConfig,
+    removeList: defaultBaseMethodConfig,
+    total: defaultBaseMethodConfig,
+    has: defaultBaseMethodConfig,
+    merge: defaultBaseMethodConfig,
+    getList: defaultBaseMethodConfig,
+    saveList: defaultBaseMethodConfig,
+    softRemove: defaultBaseMethodConfig,
+    restore: defaultBaseMethodConfig,
+    softRemoveList: defaultBaseMethodConfig,
+    restoreList: defaultBaseMethodConfig,
+    patchList: defaultBaseMethodConfig,
+};
+function validateBuildConfig(config, buildInstance) {
+    const defaultSelectSchema = buildInstance.selectModels
+        ? zod_1.default.enum(Object.keys(buildInstance.selectModels)).optional()
+        : zod_1.default.never("can only be passed if you have configured 'selectModels'.").optional();
+    const activeSchema = schemas_util_1.booleanSchema.default(true);
+    const ignoreRequiredWhereSchema = schemas_util_1.booleanSchema.default(false);
+    const baseMethodSchema = zod_1.default
+        .strictObject({
+        active: activeSchema,
+        ignoreRequiredWhere: ignoreRequiredWhereSchema,
+    })
+        .default(defaultBaseMethodConfig);
+    const baseMethodWithSelectSchema = zod_1.default
+        .strictObject({
+        active: activeSchema,
+        defaultSelect: defaultSelectSchema,
+        ignoreRequiredWhere: ignoreRequiredWhereSchema,
+    })
+        .default(defaultBaseMethodConfig);
+    const buildConfigSchema = zod_1.default.strictObject({
+        freeze: schemas_util_1.booleanSchema.default(true),
+        showWorking: schemas_util_1.booleanSchema.default(false),
+        baseMethods: zod_1.default
+            .strictObject({
+            get: baseMethodWithSelectSchema,
+            getOrThrow: baseMethodWithSelectSchema,
+            getAll: baseMethodWithSelectSchema,
+            remove: baseMethodWithSelectSchema,
+            save: baseMethodWithSelectSchema,
+            patch: baseMethodWithSelectSchema,
+            removeList: baseMethodSchema,
+            total: baseMethodSchema,
+            has: baseMethodSchema,
+            merge: baseMethodWithSelectSchema,
+            getList: baseMethodWithSelectSchema,
+            saveList: baseMethodWithSelectSchema,
+            softRemove: baseMethodWithSelectSchema,
+            restore: baseMethodWithSelectSchema,
+            softRemoveList: baseMethodWithSelectSchema,
+            restoreList: baseMethodWithSelectSchema,
+            patchList: baseMethodWithSelectSchema,
+        })
+            .default(defaultBaseMethods),
+    });
+    const buildConfigParsed = buildConfigSchema.safeParse(config);
+    if (!buildConfigParsed.success) {
+        const firstIssue = buildConfigParsed.error.issues[0];
+        const path = firstIssue?.path.length ? firstIssue.path.join(".") : "config";
+        throw new vs_repo_error_1.VSRepoBuildError(`[VSRepository] (${buildInstance.tableName}: build) ${path}: ${firstIssue?.message}`);
+    }
+    return buildConfigParsed.data;
+}

package/dist/internal/validation/constructor-config.validate.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConstructorConfig = validateConstructorConfig;
+const zod_1 = __importDefault(require("zod"));
+const schemas_util_1 = require("../utils/schemas.util");
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+function validateConstructorConfig(config) {
+    const configSchema = zod_1.default
+        .strictObject({
+        tableName: schemas_util_1.stringSchema,
+        pkName: schemas_util_1.stringSchema,
+        softRemovekName: schemas_util_1.stringSchema.optional(),
+        selectModels: zod_1.default.record(schemas_util_1.stringSchema, schemas_util_1.objectSchema).optional(),
+        defaultSelectModel: schemas_util_1.stringSchema.optional(),
+        requiredWhere: schemas_util_1.objectSchema.optional(),
+        relations: zod_1.default
+            .record(schemas_util_1.stringSchema, zod_1.default.strictObject({
+            mode: zod_1.default.enum(["otm", "mtm", "mto", "oto"]),
+            restriction: zod_1.default.enum(["set", "add"]),
+            pk: schemas_util_1.stringSchema,
+            nullAble: schemas_util_1.booleanSchema.optional(),
+            nullable: schemas_util_1.booleanSchema.optional(),
+        }))
+            .optional(),
+        methods: zod_1.default
+            .record(schemas_util_1.stringSchema, zod_1.default.strictObject({
+            map: schemas_util_1.booleanSchema,
+            selectModel: schemas_util_1.stringSchema.or(zod_1.default.literal(false)).optional(),
+            whereType: zod_1.default.enum(["overwrite", "extending"]).optional(),
+            proxyTo: schemas_util_1.stringSchema.optional(),
+            pushWhere: schemas_util_1.objectSchema.optional(),
+            fbMode: zod_1.default.enum(["one", "list"]).optional(),
+            injectOrdenation: schemas_util_1.objectSchema.or(zod_1.default.array(schemas_util_1.objectSchema)).optional(),
+            injectPagination: schemas_util_1.objectSchema.optional(),
+        }))
+            .optional(),
+    })
+        .superRefine((config, ctx) => {
+        if (config.defaultSelectModel && !config.selectModels?.[config.defaultSelectModel]) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["defaultSelectModel"],
+                message: "must be a valid key of 'selectModels'",
+            });
+        }
+        if (config.methods) {
+            for (const [key, method] of Object.entries(config.methods)) {
+                if (method.selectModel && !config.selectModels?.[method.selectModel]) {
+                    ctx.addIssue({
+                        code: "custom",
+                        path: ["methods", key, "selectModel"],
+                        message: "must be a valid key of 'selectModels'",
+                    });
+                }
+            }
+        }
+    });
+    const configParsed = configSchema.safeParse(config);
+    if (!configParsed.success) {
+        const firstIssue = configParsed.error.issues[0];
+        const path = firstIssue?.path.length ? firstIssue.path.join(".") : "config";
+        throw new vs_repo_error_1.VSRepoConfigError(`[VSRepository] (unknown: config) ${path}: ${firstIssue?.message}`);
+    }
+    return configParsed.data;
+}

package/dist/internal/validation/extension.validate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExtension = validateExtension;
+const VSRepository_1 = require("../../VSRepository");
+const is_object_validate_1 = require("./is-object.validate");
+function validateExtension(extensionFunc, repo) {
+    if (typeof extensionFunc !== "function") {
+        throw new VSRepository_1.VSRepoExtendError(`[VSRepository] (${repo.tableName}: extend) 'extensionFunc' must be a valid function.`);
+    }
+    const extension = extensionFunc(repo);
+    if (!(0, is_object_validate_1.isObject)(extension)) {
+        throw new VSRepository_1.VSRepoExtendError(`[VSRepository] (${repo.tableName}: extend) The return of the 'extensionFunc' must be a valid object.`);
+    }
+    return extension;
+}

package/dist/internal/validation/is-object.validate.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/internal/validation/method-options.validate.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMethodOptions = validateMethodOptions;
+const zod_1 = __importDefault(require("zod"));
+const schemas_util_1 = require("../utils/schemas.util");
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+function validateMethodOptions(options, instance) {
+    const optionsSchema = zod_1.default.strictObject({
+        db: schemas_util_1.objectSchema.optional(),
+        selectModel: zod_1.default
+            .literal(false)
+            .or(zod_1.default.enum(Object.keys(instance.selectModels ?? {})))
+            .optional(),
+        see: zod_1.default.enum(["active", "removed", "all"]).default("active"),
+    });
+    const optionsParsed = optionsSchema.safeParse(options ?? {});
+    if (!optionsParsed.success) {
+        const firstIssue = optionsParsed.error.issues[0];
+        const path = firstIssue?.path.length ? firstIssue.path.join(".") : "options";
+        throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) ${path}: ${firstIssue?.message}`);
+    }
+    return optionsParsed.data;
+}

package/dist/internal/validation/obj-with-relations.validate.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateObjWithRelations = validateObjWithRelations;
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+const is_object_validate_1 = require("./is-object.validate");
+function validateObjWithRelations(instance, obj, relationsKeys) {
+    const relations = instance.relations;
+    if (!relations)
+        return;
+    for (let i = 0; i < relationsKeys.length; i++) {
+        const key = relationsKeys[i];
+        if (obj[key] === undefined)
+            continue;
+        const relation = relations[key];
+        if (relation.mode === "mtm" || relation.mode === "otm") {
+            if (obj[key] === null) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' cannot be 'null' when relation mode is "mtm" or "otm", use an empty array instead.`);
+            }
+            else if (!Array.isArray(obj[key]) || obj[key].some(val => !(0, is_object_validate_1.isObject)(val))) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' must be a valid array of objects when relation mode is "mtm" or "otm".`);
+            }
+        }
+        else {
+            if (obj[key] === null) {
+                if (relation.mode === "oto" && relation.restriction !== "set") {
+                    throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' can be 'null' only if the relation restriction is "set" and mode is "oto".`);
+                }
+                else if (relation.mode === "mto" && !relation.nullable && !relation.nullAble) {
+                    throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' can be 'null' only if the relation 'nullable' is 'true' and mode is "mto".`);
+                }
+            }
+            else if (!(0, is_object_validate_1.isObject)(obj[key])) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' must be a valid object when relation mode is "oto" or "mto".`);
+            }
+        }
+    }
+}

package/dist/internal/validation/prisma-client.validate.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePrismaClient = validatePrismaClient;
+const VSRepository_1 = require("../../VSRepository");
+const is_object_validate_1 = require("./is-object.validate");
+function validatePrismaClient(prisma, repo) {
+    if (!(0, is_object_validate_1.isObject)(prisma) || prisma["$transaction"] === undefined) {
+        throw new VSRepository_1.VSRepoBuildError(`[VSRepository] (${repo.tableName}: build) 'prisma' must be a valid Prisma Client.`);
+    }
+}

package/dist/internal/validation/types/base-methods.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/build-config.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/constructor-config.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/method-options.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/method.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/pagination.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/relation.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/see-mode.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,70 +1,72 @@
-{
-  "name": "vsrepo",
-  "version": "1.2.6",
-  "description": "Uma biblioteca de repository pattern para Prisma",
-  "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jaobrabo123/VSRepository.git"
-  },
-  "main": "./VSRepository/index.js",
-  "types": "./VSRepository/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./VSRepository/index.d.ts",
-      "import": "./VSRepository/index.js",
-      "require": "./VSRepository/index.js"
-    },
-    "./VSRepository": {
-      "types": "./VSRepository/VSRepository.d.ts",
-      "import": "./VSRepository/VSRepository.js",
-      "require": "./VSRepository/VSRepository.js"
-    },
-    "./VSRepoError": {
-      "types": "./VSRepository/VSRepoError.d.ts",
-      "import": "./VSRepository/VSRepoError.js",
-      "require": "./VSRepository/VSRepoError.js"
-    }
-  },
-  "type": "module",
-  "files": [
-    "VSRepository",
-    "scripts"
-  ],
-  "bin": {
-    "vsrepo": "scripts/configure-prisma-import.mjs"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "scripts": {
-    "vsrepo": "node ./scripts/configure-prisma-import.mjs"
-  },
-  "keywords": [
-    "prisma",
-    "repository",
-    "orm",
-    "typescript",
-    "vsrepo",
-    "vsrepository",
-    "jparepository"
-  ],
-  "author": "João Pedro Azevedo Freire Mecenas",
-  "license": "MIT",
-  "peerDependencies": {
-    "@prisma/client": "^7.8.0"
-  },
-  "devDependencies": {
-    "@paralleldrive/cuid2": "^3.3.0",
-    "@prisma/adapter-pg": "^7.8.0",
-    "@prisma/client": "^7.8.0",
-    "@types/node": "^25.6.0",
-    "dotenv": "^17.4.2",
-    "prisma": "^7.8.0",
-    "tsx": "^4.22.3",
-    "typescript": "^6.0.3"
-  },
-  "dependencies": {
-    "zod": "^4.4.3"
-  }
-}
+{
+  "name": "vsrepo",
+  "version": "1.2.7",
+  "description": "Uma biblioteca de repository pattern para Prisma",
+  "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaobrabo123/VSRepository.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./VSRepository": {
+      "types": "./dist/VSRepository.d.ts",
+      "import": "./dist/VSRepository.js",
+      "require": "./dist/VSRepository.js"
+    },
+    "./VSRepoError": {
+      "types": "./dist/VSRepoError.d.ts",
+      "import": "./dist/VSRepoError.js",
+      "require": "./dist/VSRepoError.js"
+    }
+  },
+  "type": "commonjs",
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "bin": {
+    "vsrepo": "scripts/configure-prisma-import.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "vsrepo": "node ./scripts/configure-prisma-import.mjs",
+    "build": "tsc -p tsconfig.build.json && node ./scripts/copy-types.mjs",
+    "prepack": "pnpm build"
+  },
+  "keywords": [
+    "prisma",
+    "repository",
+    "orm",
+    "typescript",
+    "vsrepo",
+    "vsrepository",
+    "jparepository"
+  ],
+  "author": "João Pedro Azevedo Freire Mecenas",
+  "license": "MIT",
+  "peerDependencies": {
+    "@prisma/client": "^7.8.0"
+  },
+  "devDependencies": {
+    "@prisma/adapter-pg": "^7.8.0",
+    "@prisma/client": "^7.8.0",
+    "@types/node": "^25.6.0",
+    "dotenv": "^17.4.2",
+    "prisma": "^7.8.0",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "deepmerge": "^4.3.1",
+    "zod": "^4.4.3"
+  }
+}