vsrepo 1.2.6 → 1.2.7

package/dist/VSRepository.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupVSRepo = exports.VSRepository = void 0;
+__exportStar(require("./internal/errors/vs-repo.error"), exports);
+const build_config_validate_1 = require("./internal/validation/build-config.validate");
+const constructor_config_validate_1 = require("./internal/validation/constructor-config.validate");
+const extension_validate_1 = require("./internal/validation/extension.validate");
+const prisma_client_validate_1 = require("./internal/validation/prisma-client.validate");
+const vs_repo_error_1 = require("./internal/errors/vs-repo.error");
+const base_methods_resolve_1 = require("./internal/resolvers/base-methods.resolve");
+const logger_util_1 = require("./internal/utils/logger.util");
+const dinamic_method_info_resolve_1 = require("./internal/resolvers/dinamic-method-info.resolve");
+const dinamic_method_customization_resolve_1 = require("./internal/resolvers/dinamic-method-customization.resolve");
+const pretty_wheres_resolve_1 = require("./internal/resolvers/pretty-wheres.resolve");
+const specific_where_resolve_1 = require("./internal/resolvers/specific-where.resolve");
+const dbAndPrismaArgs_resolve_1 = require("./internal/resolvers/dbAndPrismaArgs.resolve");
+const method_options_validate_1 = require("./internal/validation/method-options.validate");
+class VSRepository {
+    vsrepocache;
+    tableName;
+    pkName;
+    softRemovekName;
+    selectModels;
+    defaultSelectModel;
+    requiredWhere;
+    relations;
+    methods;
+    constructor(config) {
+        const validatedConfig = (0, constructor_config_validate_1.validateConstructorConfig)(config);
+        this.vsrepocache = new Map();
+        this.tableName = validatedConfig.tableName;
+        this.pkName = validatedConfig.pkName;
+        this.softRemovekName = validatedConfig.softRemovekName;
+        this.selectModels = validatedConfig.selectModels;
+        this.defaultSelectModel = validatedConfig.defaultSelectModel;
+        this.relations = validatedConfig.relations;
+        this.requiredWhere = validatedConfig.requiredWhere;
+        this.methods = validatedConfig.methods;
+    }
+    extend(extensionFunc) {
+        const extension = (0, extension_validate_1.validateExtension)(extensionFunc, this);
+        const extended = Object.assign(Object.create(this), extension);
+        if (Object.isFrozen(this)) {
+            Object.freeze(extended);
+        }
+        return extended;
+    }
+    build(prisma, config) {
+        (0, prisma_client_validate_1.validatePrismaClient)(prisma, this);
+        const buildInstance = Object.create(this);
+        buildInstance.prisma = prisma;
+        if (buildInstance.softRemovekName &&
+            prisma[buildInstance.tableName]["fields"][buildInstance.softRemovekName]["typeName"] !==
+                "DateTime") {
+            throw new vs_repo_error_1.VSRepoBuildError(`[VSRepository] (${buildInstance.tableName}: build) 'typeName' of 'softRemovekName' must be "DateTime": ${buildInstance.softRemovekName}`);
+        }
+        const validatedConfig = (0, build_config_validate_1.validateBuildConfig)(config ?? {}, buildInstance);
+        (0, base_methods_resolve_1.resolveBaseMethods)(buildInstance, validatedConfig);
+        const showWorking = validatedConfig.showWorking;
+        const methods = buildInstance.methods;
+        if (methods) {
+            const methodsToMap = Object.keys(methods).filter(m => methods[m]?.map);
+            if (showWorking)
+                (0, logger_util_1.logger)("Keys to map:", "build", buildInstance.tableName, methodsToMap);
+            for (let methodToMap of methodsToMap) {
+                const originalKey = methodToMap;
+                methodToMap = methods[originalKey]?.proxyTo ?? methodToMap;
+                const dinamicMethodInfo = (0, dinamic_method_info_resolve_1.resolveDinamicMethodInfo)(buildInstance, methodToMap, originalKey);
+                const dinamicMethodCustomization = (0, dinamic_method_customization_resolve_1.resolveDinamicMethodCustomization)(buildInstance, dinamicMethodInfo, originalKey);
+                const dinamicMethodWhereOps = {
+                    uglyWheres: [],
+                    prettyWheres: [],
+                    whereType: methods[originalKey]?.whereType ?? "extending",
+                    pushWhere: methods[originalKey]?.pushWhere,
+                };
+                if (!dinamicMethodInfo.ignoreWhere) {
+                    (0, pretty_wheres_resolve_1.resolvePrettyWheres)(dinamicMethodInfo, dinamicMethodWhereOps);
+                    if (showWorking) {
+                        const argsSimulation = [];
+                        for (let x = 0; x < dinamicMethodInfo.argsCount; x++) {
+                            argsSimulation[x] = "00";
+                        }
+                        (0, logger_util_1.logger)(`Where object resolved to ${methodToMap}:`, "build", buildInstance.tableName, (0, specific_where_resolve_1.resolveSpecificWhere)(argsSimulation, dinamicMethodWhereOps.prettyWheres));
+                        // logger(
+                        //     `Where object resolved to ${methodToMap}:`,
+                        //     "build",
+                        //     buildInstance.tableName,
+                        //     dinamicMethodWhereOps.prettyWheres,
+                        // );
+                    }
+                }
+                let select = undefined;
+                if (dinamicMethodInfo.existsMode) {
+                    select = { [buildInstance.pkName]: true };
+                }
+                buildInstance.vsrepocache.set(originalKey, (args, methodOptions) => {
+                    if (dinamicMethodInfo.prismaArgsIndex !== undefined)
+                        return args.at(dinamicMethodInfo.prismaArgsIndex);
+                    const resolveDbAndPrismaArgsData = {
+                        instance: buildInstance,
+                        options: methodOptions,
+                        alreadyValidatedOptions: true,
+                        baseConfig: {
+                            active: true,
+                            defaultSelect: methods[originalKey]?.selectModel,
+                            ignoreRequiredWhere: dinamicMethodWhereOps.whereType === "overwrite",
+                        },
+                        withoutWhere: dinamicMethodInfo.ignoreWhere,
+                        specificSelect: select,
+                        pushWhere: dinamicMethodWhereOps.pushWhere,
+                        withoutSelect: dinamicMethodInfo.ignoreSelect,
+                        skipDuplicates: dinamicMethodCustomization.skipDuplicates,
+                        ordenation: dinamicMethodCustomization.orderPosition !== undefined
+                            ? args.at(dinamicMethodCustomization.orderPosition)
+                            : dinamicMethodCustomization.injectOrdenation,
+                        pagination: dinamicMethodCustomization.paginationPosition !== undefined
+                            ? args.at(dinamicMethodCustomization.paginationPosition)
+                            : dinamicMethodCustomization.injectPagination,
+                        dataPayload: dinamicMethodInfo.dataIndex !== undefined
+                            ? args.at(dinamicMethodInfo.dataIndex)
+                            : undefined,
+                        createPayload: dinamicMethodInfo.createIndex !== undefined
+                            ? args.at(dinamicMethodInfo.createIndex)
+                            : undefined,
+                        updatePayload: dinamicMethodInfo.updateIndex !== undefined
+                            ? args.at(dinamicMethodInfo.updateIndex)
+                            : undefined,
+                    };
+                    if (!dinamicMethodInfo.ignoreWhere) {
+                        resolveDbAndPrismaArgsData.specificWhere = (0, specific_where_resolve_1.resolveSpecificWhere)(args, dinamicMethodWhereOps.prettyWheres);
+                    }
+                    else if (dinamicMethodInfo.onlyBaseWheres) {
+                        resolveDbAndPrismaArgsData.specificWhere =
+                            dinamicMethodInfo.whereIndex !== undefined
+                                ? args.at(dinamicMethodInfo.whereIndex)
+                                : {};
+                    }
+                    const { prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)(resolveDbAndPrismaArgsData);
+                    return prismaArgs;
+                });
+                buildInstance[originalKey] = async (...args) => {
+                    let db = buildInstance.prisma;
+                    let methodOptions = undefined;
+                    if (args.length < dinamicMethodInfo.argsCount) {
+                        const missingParams = dinamicMethodInfo.whereParams
+                            .concat(dinamicMethodInfo.otherParams)
+                            .slice(args.length);
+                        throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${buildInstance.tableName}: runtime) Missing parameters: ${missingParams.join(", ")}`);
+                    }
+                    else if (args.length > dinamicMethodInfo.argsCount) {
+                        const optionsArg = args[args.length - 1];
+                        methodOptions = (0, method_options_validate_1.validateMethodOptions)(optionsArg, buildInstance);
+                        db = methodOptions.db ?? db;
+                    }
+                    else {
+                        args.push("1");
+                    }
+                    const prismaArgs = buildInstance.vsrepocache.get(originalKey)(args, methodOptions);
+                    const start = showWorking
+                        ? (0, logger_util_1.performanceLoggerStart)(buildInstance.tableName, dinamicMethodInfo.method, prismaArgs)
+                        : undefined;
+                    try {
+                        const result = await db[buildInstance.tableName][dinamicMethodInfo.method](prismaArgs);
+                        if (showWorking)
+                            (0, logger_util_1.performanceLoggerEnd)(buildInstance.tableName, dinamicMethodInfo.method, start);
+                        if (dinamicMethodInfo.existsMode) {
+                            return !!result;
+                        }
+                        return result;
+                    }
+                    catch (err) {
+                        // logger(
+                        //     `Fatal error when executing ${dinamicMethodInfo.method}:`,
+                        //     "runtime",
+                        //     buildInstance.tableName,
+                        //     { prismaArgs },
+                        // );
+                        throw err;
+                    }
+                };
+            }
+        }
+        if (validatedConfig.freeze)
+            Object.freeze(buildInstance);
+        return buildInstance;
+    }
+}
+exports.VSRepository = VSRepository;
+const setupVSRepo = () => (config) => new VSRepository(config);
+exports.setupVSRepo = setupVSRepo;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./VSRepository";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./VSRepository"), exports);

package/dist/internal/errors/types/vs-repo-error-type.type.js

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

package/dist/internal/errors/vs-repo.error.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VSRepoRuntimeError = exports.VSRepoExtendError = exports.VSRepoBuildError = exports.VSRepoConfigError = exports.VSRepoError = void 0;
+class VSRepoError extends Error {
+}
+exports.VSRepoError = VSRepoError;
+class VSRepoConfigError extends VSRepoError {
+    type = "VSREPO_CONFIG";
+}
+exports.VSRepoConfigError = VSRepoConfigError;
+class VSRepoBuildError extends VSRepoError {
+    type = "VSREPO_BUILD";
+}
+exports.VSRepoBuildError = VSRepoBuildError;
+class VSRepoExtendError extends VSRepoError {
+    type = "VSREPO_EXTEND";
+}
+exports.VSRepoExtendError = VSRepoExtendError;
+class VSRepoRuntimeError extends VSRepoError {
+    type = "VSREPO_RUNTIME";
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.VSRepoRuntimeError = VSRepoRuntimeError;