vsrepo 1.4.2 → 2.1.0

package/dist/internal/resolvers/pretty-wheres.resolve.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePrettyWheres = resolvePrettyWheres;
-const ugly_where_resolve_1 = require("./ugly-where.resolve");
-function resolvePrettyWheres(dynamicMethodInfo, dynamicMethodWhereOps) {
-    let ANDMode = false;
-    let keysSplitedAND = dynamicMethodInfo.keyToMapReplaced.split("AND");
-    if (keysSplitedAND.length > 1) {
-        ANDMode = true;
-    }
-    keysSplitedAND.forEach((keySplitedAND, idx) => {
-        let orMode = false;
-        let keysSplitedOr = idx === 0 ? keySplitedAND.split("Or") : [keySplitedAND];
-        if (keysSplitedOr.length > 1) {
-            orMode = true;
-        }
-        for (let i = 0; i < keysSplitedOr.length; i++) {
-            if (keysSplitedOr[i] === "")
-                continue;
-            const keysSplitedAnd = keysSplitedOr[i].split("And");
-            for (const keySplitedAnd of keysSplitedAnd) {
-                if (keySplitedAnd === "")
-                    continue;
-                const uglyWhere = (0, ugly_where_resolve_1.resolveUglyWhere)(keySplitedAnd);
-                if (!orMode) {
-                    if (idx === 1 && ANDMode) {
-                        uglyWhere.name = `AND.${i}idx.${uglyWhere.name}`;
-                    }
-                    dynamicMethodWhereOps.uglyWheres.push(uglyWhere);
-                }
-                else {
-                    uglyWhere.name = `OR.${i}idx.${uglyWhere.name}`;
-                    dynamicMethodWhereOps.uglyWheres.push(uglyWhere);
-                }
-                if (uglyWhere.autoInjectVal === undefined)
-                    dynamicMethodInfo.argsCount++;
-            }
-        }
-    });
-    const prettyWheres = dynamicMethodWhereOps.uglyWheres.map(arg => {
-        let context = [];
-        let otherProps = undefined;
-        let argName = arg.name;
-        const agrNameSplitedOr = argName.split("OR.");
-        if (agrNameSplitedOr.length > 1) {
-            const agrNameSplitedOrIdx = agrNameSplitedOr[1].split("idx.");
-            context.push("OR");
-            context.push(Number(agrNameSplitedOrIdx[0]));
-            argName = agrNameSplitedOrIdx[1];
-        }
-        else {
-            const agrNameSplitedAND = argName.split("AND.");
-            if (agrNameSplitedAND.length > 1) {
-                const agrNameSplitedANDIdx = agrNameSplitedAND[1].split("idx.");
-                context.push("AND");
-                context.push(Number(agrNameSplitedANDIdx[0]));
-                argName = agrNameSplitedANDIdx[1];
-            }
-        }
-        context.push(argName);
-        if (arg.pushProperty !== "$$$") {
-            const pushProperty = arg.pushProperty;
-            const pushPropertySplitedDot = pushProperty.split(".");
-            pushPropertySplitedDot.forEach(prop => context.push(prop));
-        }
-        if (arg.properties !== undefined) {
-            const propertiesKeys = Object.keys(arg.properties);
-            otherProps = {};
-            for (let i = 0; i < propertiesKeys.length; i++) {
-                const key = propertiesKeys[i];
-                otherProps[key] = arg.properties[key];
-            }
-            if (arg.pushProperty === "$$$") {
-                context.push("equals");
-            }
-        }
-        dynamicMethodInfo.whereParams.push(argName);
-        return {
-            context,
-            otherProps,
-            argName,
-            autoVal: arg.autoInjectVal,
-            betweenMode: arg.betweenMode,
-        };
-    });
-    dynamicMethodWhereOps.prettyWheres = prettyWheres;
-}

package/dist/internal/resolvers/select.resolve.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSelect = resolveSelect;
-function resolveSelect(instance, provided, pushed) {
-    const selectModelKey = provided ?? pushed ?? instance.defaultSelectModel;
-    return selectModelKey ? instance.selectModels?.[selectModelKey] : undefined;
-}

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

@@ -1,84 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSpecificWhere = resolveSpecificWhere;
-const deepmerge_1 = __importDefault(require("deepmerge"));
-function resolveSpecificWhere(args, prettyWheres) {
-    let specificWhere = {};
-    let OR;
-    let AND;
-    let adjust = 0;
-    for (let j = 0; j < prettyWheres.length; j++) {
-        let path = {};
-        let current = path;
-        let ormode = false;
-        let andmode = false;
-        let modeIdx;
-        const currentWhereRslvd = prettyWheres[j];
-        const context = currentWhereRslvd.context;
-        const contextLength = context.length;
-        const contextLengthM1 = contextLength - 1;
-        for (let i = 0; i < contextLength; i++) {
-            if (i < contextLengthM1) {
-                if (context[i] === "OR") {
-                    ormode = true;
-                }
-                else if (context[i] === "AND") {
-                    andmode = true;
-                }
-                else if (typeof context[i] === "number") {
-                    modeIdx = context[i];
-                }
-                else {
-                    if (!current[context[i]])
-                        current[context[i]] = {};
-                    current = current[context[i]];
-                }
-            }
-            else {
-                if (currentWhereRslvd.autoVal !== undefined) {
-                    current[context[i]] = currentWhereRslvd.autoVal;
-                    adjust++;
-                }
-                else if (currentWhereRslvd.betweenMode && args[j - adjust] !== undefined) {
-                    current[context[i]] = {};
-                    current[context[i]]["gte"] = args[j - adjust][0];
-                    current[context[i]]["lte"] = args[j - adjust][1];
-                }
-                else {
-                    current[context[i]] = args[j - adjust];
-                }
-            }
-        }
-        if (currentWhereRslvd.otherProps !== undefined) {
-            Object.assign(current, currentWhereRslvd.otherProps);
-        }
-        if (ormode) {
-            if (!OR)
-                OR = [];
-            if (!OR[modeIdx])
-                OR[modeIdx] = {};
-            OR[modeIdx] = (0, deepmerge_1.default)(OR[modeIdx], path);
-            // Object.assign(OR[modeIdx!], path);
-        }
-        else if (andmode) {
-            if (!AND)
-                AND = [];
-            if (!AND[modeIdx])
-                AND[modeIdx] = {};
-            AND[modeIdx] = (0, deepmerge_1.default)(AND[modeIdx], path);
-            // Object.assign(AND[modeIdx!], path);
-        }
-        else {
-            specificWhere = (0, deepmerge_1.default)(specificWhere, path);
-            // Object.assign(specificWhere, path);
-        }
-    }
-    if (OR)
-        specificWhere.OR = OR.filter(x => x !== undefined);
-    if (AND)
-        specificWhere.AND = AND.filter(x => x !== undefined);
-    return specificWhere;
-}

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

@@ -1,178 +0,0 @@
-"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

@@ -1,21 +0,0 @@
-"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(`\n[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

@@ -1,31 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.methodSchema = exports.queryOptionsSchema = 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();
-exports.queryOptionsSchema = zod_1.default.strictObject({
-    value: exports.stringSchema,
-    modifying: exports.booleanSchema.default(false),
-});
-exports.methodSchema = zod_1.default
-    .strictObject({
-    map: exports.booleanSchema,
-    selectModel: exports.stringSchema.or(zod_1.default.literal(false)).optional(),
-    whereType: zod_1.default.enum(["overwrite", "extending"]).optional(),
-    proxyTo: exports.stringSchema.optional(),
-    pushWhere: exports.objectSchema.optional(),
-    fbMode: zod_1.default.enum(["one", "list"]).optional(),
-    injectOrdenation: exports.objectSchema.or(zod_1.default.array(exports.objectSchema)).optional(),
-    injectOrdering: exports.objectSchema.or(zod_1.default.array(exports.objectSchema)).optional(),
-    injectPagination: exports.objectSchema.optional(),
-    query: exports.queryOptionsSchema.optional(),
-})
-    .transform(({ injectOrdenation, injectOrdering, ...value }) => ({
-    ...value,
-    injectOrdering: injectOrdering ?? injectOrdenation,
-}));

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

@@ -1,84 +0,0 @@
-"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

@@ -1,64 +0,0 @@
-"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(),
-        includeModels: 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, schemas_util_1.methodSchema).optional(),
-        defaultOrdenation: schemas_util_1.objectSchema.or(zod_1.default.array(schemas_util_1.objectSchema)).optional(),
-        defaultOrdering: schemas_util_1.objectSchema.or(zod_1.default.array(schemas_util_1.objectSchema)).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'",
-                    });
-                }
-            }
-        }
-    })
-        .transform(({ defaultOrdenation, defaultOrdering, ...value }) => ({
-        ...value,
-        defaultOrdering: defaultOrdering ?? defaultOrdenation,
-    }));
-    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/dynamic-method-config.validate.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDynamicMethodConfig = validateDynamicMethodConfig;
-const vs_repo_error_1 = require("../errors/vs-repo.error");
-const schemas_util_1 = require("../utils/schemas.util");
-const is_object_validate_1 = require("./is-object.validate");
-function validateDynamicMethodConfig(config) {
-    if (!(0, is_object_validate_1.isObject)(config)) {
-        throw new vs_repo_error_1.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) 'config' must be a valid object`);
-    }
-    config["map"] = true;
-    const configParsed = schemas_util_1.methodSchema.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.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) ${path}: ${firstIssue?.message}`);
-    }
-    return configParsed.data;
-}

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

@@ -1,15 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-"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

@@ -1,42 +0,0 @@
-"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(),
-        includeModel: zod_1.default.enum(Object.keys(instance.includeModels ?? {})).optional(),
-        see: zod_1.default.enum(["active", "removed", "all"]).default("active"),
-        include: schemas_util_1.objectSchema.optional(),
-        select: schemas_util_1.objectSchema.optional(),
-    })
-        .refine(data => {
-        const provided = [
-            data.select !== undefined,
-            data.selectModel !== undefined,
-            data.include !== undefined,
-            data.includeModel !== undefined,
-        ].filter(Boolean).length;
-        return provided <= 1;
-    }, {
-        message: "'select', 'selectModel', 'include' and 'includeModel' are mutually exclusive — only one can be provided.",
-        path: ["options"],
-    });
-    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}`, "67542");
-    }
-    return optionsParsed.data;
-}