vsrepo 1.3.5 → 1.3.7

package/dist/VSRepoError.d.ts

@@ -8,6 +8,24 @@ export type VSRepoErrorType =
     | 'VSREPO_RUNTIME'
     | 'VSREPO_DECORATOR';
 
+/**
+ * Catalog of the internal codes used by `VSRepoRuntimeError`. Each code identifies
+ * a category of runtime failure, so consuming code can discriminate on
+ * `error.code` without parsing the (human-readable) message. See the
+ * "Error handling" section of the README for the full description of each code.
+ */
+export type VSRepoRuntimeErrorCode =
+    /** A required argument is missing or has an invalid shape (e.g. missing `pk`, `pks`/`objs`/`tuples` that aren't an array, or `options`/`obj` that isn't a valid object). */
+    | '65706'
+    /** No record was found for the provided primary key (`getOrThrow` when fetching the base record). */
+    | '20727'
+    /** Validation (zod) of a method's `options`, or of a `@QueryMethod` argument, failed. */
+    | '67542'
+    /** A relation passed to `save`/`patch`/`merge` has an invalid shape for the configured `mode`/`restriction`. */
+    | '91868'
+    /** A dynamic method (`config.methods`) was called with fewer positional arguments than its `where` fields require. */
+    | '48670';
+
 /**
  * Base class for all errors thrown by the VSRepository.
  */
@@ -59,5 +77,7 @@ export declare class VSRepoDecoratorError extends VSRepoError {
  */
 export declare class VSRepoRuntimeError extends VSRepoError {
     readonly type: 'VSREPO_RUNTIME';
-    constructor(message: string, code: string);
+    /** Internal code identifying the category of runtime failure. See {@link VSRepoRuntimeErrorCode}. */
+    readonly code: VSRepoRuntimeErrorCode;
+    constructor(message: string, code: VSRepoRuntimeErrorCode);
 }

package/dist/VSRepository.d.ts

@@ -30,7 +30,7 @@ export type DbTransaction = Prisma.TransactionClient;
  */
 export type ClientOrTransaction = DbClient | DbTransaction;
 
-export * from './VSRepoError';
+export type * from './VSRepoError';
 
 type OrderPattern = {
     [key: string]: 'asc' | 'desc' | { _count: 'asc' | 'desc' } | OrderPattern;
@@ -409,7 +409,7 @@ type ExtractIncludeModels<Config> = Config extends { includeModels: infer IM } ?
 type ExtractDefaultSelect<Config> = Config extends { defaultSelectModel: infer D } ? D : never;
 type ExtractRelations<Config> = Config extends { relations: infer R } ? (R extends object ? R : {}) : {};
 type ExtractSoftRemovekName<Config> = Config extends { softRemovekName: infer S } ? S : never;
-type ExtractDefaultOrdenation<Config> = Config extends { defaultOrdenation: infer O } ? O : never;
+type ExtractDefaultOrdering<Config> = Config extends { defaultOrdering: infer O } ? O : Config extends { defaultOrdenation: infer O } ? O : never;
 
 type AggregateMethod<M extends PrismaModelName> = <A extends Prisma.TypeMap['model'][M]['operations']['aggregate']['args']>(
     prismaArgs: A, 
@@ -529,7 +529,13 @@ export type CursorModel<M extends PrismaModelName> = PrismaModelInputs<M>['curso
 /**
  * Type of the `orderBy` object of a Prisma model.
  */
-export type OrdenationModel<M extends PrismaModelName> = PrismaModelInputs<M>['orderByInput'];
+export type OrderingModel<M extends PrismaModelName> = PrismaModelInputs<M>['orderByInput'];
+
+/**
+ * Type of the `orderBy` object of a Prisma model.
+ * @deprecated Use `OrderingModel` instead.
+ */
+export type OrdenationModel<M extends PrismaModelName> = OrderingModel<M>;
 
 /**
  * Pagination options with typed cursor for a Prisma model.
@@ -563,7 +569,12 @@ export type MethodConfig<M extends PrismaModelName, SelectModels = any> = {
      */
     readonly fbMode?: 'one' | 'list';
     /** Injects a fixed ordering automatically into the query. */
-    readonly injectOrdenation?: OrdenationModel<M>;
+    readonly injectOrdering?: OrderingModel<M>;
+    /**
+     * Injects a fixed ordering automatically into the query.
+     * @deprecated Use `injectOrdering` instead.
+     */
+    readonly injectOrdenation?: OrderingModel<M>;
     /** Injects a fixed pagination automatically into the query. */
     readonly injectPagination?: PaginationModel<M>;
     /**
@@ -814,7 +825,7 @@ type _Inc<Config> = ExtractIncludeModels<Config>;
 type _Def<Config> = ExtractDefaultSelect<Config>;
 type _Rel<Config> = ExtractRelations<Config>;
 type _Soft<Config> = ExtractSoftRemovekName<Config>;
-type _DOrd<Config> = ExtractDefaultOrdenation<Config>;
+type _DOrd<Config> = ExtractDefaultOrdering<Config>;
 
 // ─── refactored mapped type — optimized for the TS compiler ──────────────────
 
@@ -829,7 +840,7 @@ type AllBaseMethods<
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
     I         = PrismaModelInputs<M>,
-    TDefaultOrdenation = _DOrd<Config>,
+    TDefaultOrdering = _DOrd<Config>,
     TIncludes = _Inc<Config>
 > = {
     /** Fetches a record by its primary key (PK). */
@@ -886,7 +897,7 @@ type AllBaseMethods<
             pagination?: PaginationOptions<I extends { cursorInput: infer Curs } ? Curs : unknown>;
             /**
              * Ordering to apply to the query.
-             * When omitted and `defaultOrdenation` is configured on the repository,
+             * When omitted and `defaultOrdering` is configured on the repository,
              * the default ordering is applied automatically.
              */
             order?: I extends { orderByInput: infer OB } ? OB : OrderOptions;
@@ -927,10 +938,10 @@ type InjectedBaseMethods<
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
     I         = PrismaModelInputs<M>,
-    TDefaultOrdenation = _DOrd<Config>,
+    TDefaultOrdering = _DOrd<Config>,
     TIncludes = _Inc<Config>
 > = Pick<
-    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I, TDefaultOrdenation, TIncludes>,
+    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I, TDefaultOrdering, TIncludes>,
     | (C extends { baseMethods: { get:          { active: false } } } ? never : 'get')
     | (C extends { baseMethods: { getOrThrow:   { active: false } } } ? never : 'getOrThrow')
     | (C extends { baseMethods: { getList:      { active: false } } } ? never : 'getList')
@@ -1034,7 +1045,9 @@ export type RepoConfig<T, M extends PrismaModelName, SM extends Record<string, A
     defaultSelectModel?: Extract<keyof SM, string>;
     includeModels?: IncludeModels<M>;
     requiredWhere?: WhereModel<M>;
-    defaultOrdenation?: OrdenationModel<M>;
+    defaultOrdering?: OrderingModel<M>;
+    /** @deprecated Use `defaultOrdering` instead. */
+    defaultOrdenation?: OrderingModel<M>;
     relations?: RepositoryRelations<T>;
     methods?: Record<string, MethodConfig<M, SM>>;
 };
@@ -1132,12 +1145,23 @@ export type ValidateRepoConfig<T extends object, M extends PrismaModelName, Conf
 
     /**
      * Default ordering automatically injected into all queries that accept `orderBy`,
-     * unless the method already has `injectOrdenation` configured or uses the `Ordered` suffix.
+     * unless the method already has `injectOrdering` configured or uses the `Ordered` suffix.
+     *
+     * Useful for ensuring a consistent sort order across the repository without repeating
+     * the `order` argument on every call.
+     */
+    defaultOrdering?: OrderingModel<M>;
+
+    /**
+     * Default ordering automatically injected into all queries that accept `orderBy`,
+     * unless the method already has `injectOrdering` configured or uses the `Ordered` suffix.
      *
      * Useful for ensuring a consistent sort order across the repository without repeating
      * the `order` argument on every call.
+     *
+     * @deprecated Use `defaultOrdering` instead.
      */
-    defaultOrdenation?: OrdenationModel<M>;
+    defaultOrdenation?: OrderingModel<M>;
 
     /**
      * Configures automatic relation management.

package/dist/VSRepository.js

@@ -23,8 +23,8 @@ const prisma_client_validate_1 = require("./internal/validation/prisma-client.va
 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 dynamic_method_info_resolve_1 = require("./internal/resolvers/dynamic-method-info.resolve");
+const dynamic_method_customization_resolve_1 = require("./internal/resolvers/dynamic-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");
@@ -41,7 +41,7 @@ class VSRepository {
     requiredWhere;
     relations;
     methods;
-    defaultOrdenation;
+    defaultOrdering;
     constructor(config) {
         const validatedConfig = (0, constructor_config_validate_1.validateConstructorConfig)(config);
         this.vsrepocache = new Map();
@@ -54,7 +54,7 @@ class VSRepository {
         this.relations = validatedConfig.relations;
         this.requiredWhere = validatedConfig.requiredWhere;
         this.methods = validatedConfig.methods;
-        this.defaultOrdenation = validatedConfig.defaultOrdenation;
+        this.defaultOrdering = validatedConfig.defaultOrdering;
     }
     extend(extensionFunc) {
         const extension = (0, extension_validate_1.validateExtension)(extensionFunc, this);
@@ -105,19 +105,19 @@ class VSRepository {
                     continue;
                 }
                 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 = {
+                const dynamicMethodInfo = (0, dynamic_method_info_resolve_1.resolveDynamicMethodInfo)(buildInstance, methodToMap, originalKey);
+                const dynamicMethodCustomization = (0, dynamic_method_customization_resolve_1.resolveDynamicMethodCustomization)(buildInstance, dynamicMethodInfo, originalKey);
+                const dynamicMethodWhereOps = {
                     uglyWheres: [],
                     prettyWheres: [],
                     whereType: methods[originalKey]?.whereType ?? "extending",
                     pushWhere: methods[originalKey]?.pushWhere,
                 };
-                if (!dinamicMethodInfo.ignoreWhere) {
-                    (0, pretty_wheres_resolve_1.resolvePrettyWheres)(dinamicMethodInfo, dinamicMethodWhereOps);
+                if (!dynamicMethodInfo.ignoreWhere) {
+                    (0, pretty_wheres_resolve_1.resolvePrettyWheres)(dynamicMethodInfo, dynamicMethodWhereOps);
                     // if (showWorking) {
                     //     const argsSimulation: any[] = [];
-                    //     for (let x = 0; x < dinamicMethodInfo.argsCount; x++) {
+                    //     for (let x = 0; x < dynamicMethodInfo.argsCount; x++) {
                     //         argsSimulation[x] = "00";
                     //     }
                     //     logger(
@@ -126,24 +126,24 @@ class VSRepository {
                     //         buildInstance.tableName,
                     //         resolveSpecificWhere(
                     //             argsSimulation,
-                    //             dinamicMethodWhereOps.prettyWheres,
+                    //             dynamicMethodWhereOps.prettyWheres,
                     //         ),
                     //     );
                     //     // logger(
                     //     //     `Where object resolved to ${methodToMap}:`,
                     //     //     "build",
                     //     //     buildInstance.tableName,
-                    //     //     dinamicMethodWhereOps.prettyWheres,
+                    //     //     dynamicMethodWhereOps.prettyWheres,
                     //     // );
                     // }
                 }
                 let select = undefined;
-                if (dinamicMethodInfo.existsMode) {
+                if (dynamicMethodInfo.existsMode) {
                     select = { [buildInstance.pkName]: true };
                 }
                 buildInstance.vsrepocache.set(originalKey, (args, methodOptions) => {
-                    if (dinamicMethodInfo.prismaArgsIndex !== undefined)
-                        return args.at(dinamicMethodInfo.prismaArgsIndex);
+                    if (dynamicMethodInfo.prismaArgsIndex !== undefined)
+                        return args.at(dynamicMethodInfo.prismaArgsIndex);
                     const resolveDbAndPrismaArgsData = {
                         instance: buildInstance,
                         options: methodOptions,
@@ -151,58 +151,58 @@ class VSRepository {
                         baseConfig: {
                             active: true,
                             defaultSelect: methods[originalKey]?.selectModel,
-                            ignoreRequiredWhere: dinamicMethodWhereOps.whereType === "overwrite",
+                            ignoreRequiredWhere: dynamicMethodWhereOps.whereType === "overwrite",
                         },
-                        withoutWhere: dinamicMethodInfo.ignoreWhere && !dinamicMethodInfo.onlyBaseWheres,
+                        withoutWhere: dynamicMethodInfo.ignoreWhere && !dynamicMethodInfo.onlyBaseWheres,
                         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)
+                        pushWhere: dynamicMethodWhereOps.pushWhere,
+                        withoutSelect: dynamicMethodInfo.ignoreSelect,
+                        skipDuplicates: dynamicMethodCustomization.skipDuplicates,
+                        ordering: dynamicMethodCustomization.orderPosition !== undefined
+                            ? args.at(dynamicMethodCustomization.orderPosition)
+                            : dynamicMethodCustomization.injectOrdering,
+                        pagination: dynamicMethodCustomization.paginationPosition !== undefined
+                            ? args.at(dynamicMethodCustomization.paginationPosition)
+                            : dynamicMethodCustomization.injectPagination,
+                        dataPayload: dynamicMethodInfo.dataIndex !== undefined
+                            ? args.at(dynamicMethodInfo.dataIndex)
                             : undefined,
-                        createPayload: dinamicMethodInfo.createIndex !== undefined
-                            ? args.at(dinamicMethodInfo.createIndex)
+                        createPayload: dynamicMethodInfo.createIndex !== undefined
+                            ? args.at(dynamicMethodInfo.createIndex)
                             : undefined,
-                        updatePayload: dinamicMethodInfo.updateIndex !== undefined
-                            ? args.at(dinamicMethodInfo.updateIndex)
+                        updatePayload: dynamicMethodInfo.updateIndex !== undefined
+                            ? args.at(dynamicMethodInfo.updateIndex)
                             : undefined,
-                        withOrdenationAndPagination: !dinamicMethodInfo.ignoreOrderByAndPagination,
-                        distinctKeys: dinamicMethodCustomization.distinctKeys,
+                        withOrderingAndPagination: !dynamicMethodInfo.ignoreOrderByAndPagination,
+                        distinctKeys: dynamicMethodCustomization.distinctKeys,
                     };
-                    if (!dinamicMethodInfo.ignoreWhere) {
-                        resolveDbAndPrismaArgsData.specificWhere = (0, specific_where_resolve_1.resolveSpecificWhere)(args, dinamicMethodWhereOps.prettyWheres);
+                    if (!dynamicMethodInfo.ignoreWhere) {
+                        resolveDbAndPrismaArgsData.specificWhere = (0, specific_where_resolve_1.resolveSpecificWhere)(args, dynamicMethodWhereOps.prettyWheres);
                     }
-                    else if (dinamicMethodInfo.onlyBaseWheres) {
+                    else if (dynamicMethodInfo.onlyBaseWheres) {
                         resolveDbAndPrismaArgsData.specificWhere =
-                            dinamicMethodInfo.whereIndex !== undefined
-                                ? args.at(dinamicMethodInfo.whereIndex)
+                            dynamicMethodInfo.whereIndex !== undefined
+                                ? args.at(dynamicMethodInfo.whereIndex)
                                 : {};
                     }
                     const { prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)(resolveDbAndPrismaArgsData);
                     return prismaArgs;
                 });
                 if (showWorking) {
-                    const argsSimulation = new Array(dinamicMethodInfo.argsCount).fill("00");
+                    const argsSimulation = new Array(dynamicMethodInfo.argsCount).fill("00");
                     const prismaArgs = buildInstance.vsrepocache.get(originalKey)(argsSimulation);
                     (0, logger_util_1.logger)(`PrismaArgs preview for ${methodToMap}:`, "build", buildInstance.tableName, prismaArgs);
                 }
                 buildInstance[originalKey] = async (...args) => {
                     let db = buildInstance.prisma;
                     let methodOptions = undefined;
-                    if (args.length < dinamicMethodInfo.argsCount) {
-                        const missingParams = dinamicMethodInfo.whereParams
-                            .concat(dinamicMethodInfo.otherParams)
+                    if (args.length < dynamicMethodInfo.argsCount) {
+                        const missingParams = dynamicMethodInfo.whereParams
+                            .concat(dynamicMethodInfo.otherParams)
                             .slice(args.length);
                         throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${buildInstance.tableName}: runtime) Missing parameters: ${missingParams.join(", ")}`, "48670");
                     }
-                    else if (args.length > dinamicMethodInfo.argsCount) {
+                    else if (args.length > dynamicMethodInfo.argsCount) {
                         const optionsArg = args[args.length - 1];
                         methodOptions = (0, method_options_validate_1.validateMethodOptions)(optionsArg, buildInstance);
                         db = methodOptions.db ?? db;
@@ -212,20 +212,20 @@ class VSRepository {
                     }
                     const prismaArgs = buildInstance.vsrepocache.get(originalKey)(args, methodOptions);
                     const start = showWorking
-                        ? (0, logger_util_1.performanceLoggerStart)(buildInstance.tableName, dinamicMethodInfo.method, prismaArgs)
+                        ? (0, logger_util_1.performanceLoggerStart)(buildInstance.tableName, dynamicMethodInfo.method, prismaArgs)
                         : undefined;
                     try {
-                        const result = await db[buildInstance.tableName][dinamicMethodInfo.method](prismaArgs);
+                        const result = await db[buildInstance.tableName][dynamicMethodInfo.method](prismaArgs);
                         if (showWorking)
-                            (0, logger_util_1.performanceLoggerEnd)(buildInstance.tableName, dinamicMethodInfo.method, start);
-                        if (dinamicMethodInfo.existsMode) {
+                            (0, logger_util_1.performanceLoggerEnd)(buildInstance.tableName, dynamicMethodInfo.method, start);
+                        if (dynamicMethodInfo.existsMode) {
                             return !!result;
                         }
                         return result;
                     }
                     catch (err) {
                         // logger(
-                        //     `Fatal error when executing ${dinamicMethodInfo.method}:`,
+                        //     `Fatal error when executing ${dynamicMethodInfo.method}:`,
                         //     "runtime",
                         //     buildInstance.tableName,
                         //     { prismaArgs },

package/dist/internal/constants/dynamic-methods-key.constant.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DYNAMIC_METHODS_KEY = void 0;
+exports.DYNAMIC_METHODS_KEY = Symbol("dynamic-methods-key");

package/dist/internal/decorators/dynamic-method.decorator.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicMethod = DynamicMethod;
-const dinamic_methods_key_constant_1 = require("../constants/dinamic-methods-key.constant");
+const dynamic_methods_key_constant_1 = require("../constants/dynamic-methods-key.constant");
 const dynamic_method_metadata_entity_1 = require("../entities/dynamic-method-metadata.entity");
 const dynamic_method_config_validate_1 = require("../validation/dynamic-method-config.validate");
 function DynamicMethod(config) {
     const validatedConfig = config ? (0, dynamic_method_config_validate_1.validateDynamicMethodConfig)(config) : undefined;
     return (target, propertyKey) => {
-        const methods = Reflect.getMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, target) ?? [];
-        methods.push(new dynamic_method_metadata_entity_1.DynamicMethodMetadata(propertyKey, true, validatedConfig?.proxyTo, validatedConfig?.whereType, validatedConfig?.pushWhere, validatedConfig?.fbMode, validatedConfig?.injectOrdenation, validatedConfig?.injectPagination));
-        Reflect.defineMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, methods, target);
+        const methods = Reflect.getMetadata(dynamic_methods_key_constant_1.DYNAMIC_METHODS_KEY, target) ?? [];
+        methods.push(new dynamic_method_metadata_entity_1.DynamicMethodMetadata(propertyKey, true, validatedConfig?.proxyTo, validatedConfig?.whereType, validatedConfig?.pushWhere, validatedConfig?.fbMode, validatedConfig?.injectOrdering, validatedConfig?.injectPagination));
+        Reflect.defineMetadata(dynamic_methods_key_constant_1.DYNAMIC_METHODS_KEY, methods, target);
     };
 }

package/dist/internal/decorators/query-method.decorator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryMethod = QueryMethod;
-const dinamic_methods_key_constant_1 = require("../constants/dinamic-methods-key.constant");
+const dynamic_methods_key_constant_1 = require("../constants/dynamic-methods-key.constant");
 const dynamic_method_metadata_entity_1 = require("../entities/dynamic-method-metadata.entity");
 const vs_repo_error_1 = require("../errors/vs-repo.error");
 const query_method_options_validate_1 = require("../validation/query-method-options.validate");
@@ -13,8 +13,8 @@ function QueryMethod(value, options) {
         ? (0, query_method_options_validate_1.validateQueryMethodOptions)(options)
         : { modifying: false };
     return (target, propertyKey) => {
-        const methods = Reflect.getMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, target) ?? [];
+        const methods = Reflect.getMetadata(dynamic_methods_key_constant_1.DYNAMIC_METHODS_KEY, target) ?? [];
         methods.push(new dynamic_method_metadata_entity_1.DynamicMethodMetadata(propertyKey, true, undefined, undefined, undefined, undefined, undefined, undefined, { value, ...validatedConfig }));
-        Reflect.defineMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, methods, target);
+        Reflect.defineMetadata(dynamic_methods_key_constant_1.DYNAMIC_METHODS_KEY, methods, target);
     };
 }

package/dist/internal/entities/dynamic-method-metadata.entity.js

@@ -8,17 +8,17 @@ class DynamicMethodMetadata {
     whereType;
     pushWhere;
     fbMode;
-    injectOrdenation;
+    injectOrdering;
     injectPagination;
     query;
-    constructor(propertyKey, map, proxyTo, whereType, pushWhere, fbMode, injectOrdenation, injectPagination, query) {
+    constructor(propertyKey, map, proxyTo, whereType, pushWhere, fbMode, injectOrdering, injectPagination, query) {
         this.propertyKey = propertyKey;
         this.map = map;
         this.proxyTo = proxyTo;
         this.whereType = whereType;
         this.pushWhere = pushWhere;
         this.fbMode = fbMode;
-        this.injectOrdenation = injectOrdenation;
+        this.injectOrdering = injectOrdering;
         this.injectPagination = injectPagination;
         this.query = query;
     }

package/dist/internal/resolvers/base-methods.resolve.js

@@ -91,8 +91,8 @@ function resolveBaseMethods(instance, config) {
                 baseConfig: baseMethods.getAll,
                 options: restOptions,
                 pagination,
-                ordenation: order,
-                withOrdenationAndPagination: true,
+                ordering: order,
+                withOrderingAndPagination: true,
             });
             const start = showWorking
                 ? (0, logger_util_1.performanceLoggerStart)(tableName, "getAll", prismaArgs)

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

@@ -5,7 +5,7 @@ const method_options_validate_1 = require("../validation/method-options.validate
 const merge_wheres_resolve_1 = require("./merge-wheres.resolve");
 const select_resolve_1 = require("./select.resolve");
 function resolveDbAndPrismaArgs(data) {
-    const { baseConfig, instance, options, wherePkValue, withoutSelect, withoutWhere, specificSelect, dataPayload, createPayload, updatePayload, alreadyValidatedOptions, specificWhere, pushWhere, ordenation, pagination, skipDuplicates, forceSeeMode, withOrdenationAndPagination, distinctKeys, } = data;
+    const { baseConfig, instance, options, wherePkValue, withoutSelect, withoutWhere, specificSelect, dataPayload, createPayload, updatePayload, alreadyValidatedOptions, specificWhere, pushWhere, ordering, pagination, skipDuplicates, forceSeeMode, withOrderingAndPagination, distinctKeys, } = data;
     const validatedOptions = alreadyValidatedOptions && options
         ? options
         : (0, method_options_validate_1.validateMethodOptions)(options, instance);
@@ -43,9 +43,9 @@ function resolveDbAndPrismaArgs(data) {
     if (updatePayload) {
         prismaArgs.update = updatePayload;
     }
-    if (withOrdenationAndPagination) {
-        if (instance.defaultOrdenation || ordenation) {
-            prismaArgs.orderBy = ordenation ?? instance.defaultOrdenation;
+    if (withOrderingAndPagination) {
+        if (instance.defaultOrdering || ordering) {
+            prismaArgs.orderBy = ordering ?? instance.defaultOrdering;
         }
         if (pagination) {
             prismaArgs.skip = pagination.skip;

package/dist/internal/resolvers/dynamic-method-customization.resolve.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDynamicMethodCustomization = resolveDynamicMethodCustomization;
+const uncapitalize_util_1 = require("../utils/uncapitalize.util");
+function resolveDynamicMethodCustomization(instance, dynamicMethodInfo, originalKey) {
+    const dynamicMethodCustomization = {};
+    if (!dynamicMethodInfo.ignoreSkipDuplicates) {
+        if (dynamicMethodInfo.keyToMapReplaced.endsWith("SkipDuplicates")) {
+            dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("SkipDuplicates", "");
+            dynamicMethodCustomization.skipDuplicates = true;
+        }
+    }
+    if (!dynamicMethodInfo.ignoreOrderByAndPagination) {
+        dynamicMethodCustomization.injectOrdering =
+            instance.methods?.[originalKey]?.injectOrdering;
+        dynamicMethodCustomization.injectPagination =
+            instance.methods?.[originalKey]?.injectPagination;
+        if (dynamicMethodInfo.keyToMapReplaced.endsWith("PaginatedAndOrdered")) {
+            dynamicMethodCustomization.orderPosition = -2;
+            dynamicMethodCustomization.paginationPosition = -3;
+            dynamicMethodInfo.otherParams.push("pagination");
+            dynamicMethodInfo.otherParams.push("order");
+            dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("PaginatedAndOrdered", "");
+            dynamicMethodInfo.argsCount += 2;
+        }
+        else if (dynamicMethodInfo.keyToMapReplaced.endsWith("OrderedAndPaginated")) {
+            dynamicMethodCustomization.orderPosition = -3;
+            dynamicMethodCustomization.paginationPosition = -2;
+            dynamicMethodInfo.otherParams.push("order");
+            dynamicMethodInfo.otherParams.push("pagination");
+            dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("OrderedAndPaginated", "");
+            dynamicMethodInfo.argsCount += 2;
+        }
+        else if (dynamicMethodInfo.keyToMapReplaced.endsWith("Paginated")) {
+            dynamicMethodCustomization.paginationPosition = -2;
+            dynamicMethodInfo.otherParams.push("pagination");
+            dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("Paginated", "");
+            dynamicMethodInfo.argsCount++;
+        }
+        else if (dynamicMethodInfo.keyToMapReplaced.endsWith("Ordered")) {
+            dynamicMethodCustomization.orderPosition = -2;
+            dynamicMethodInfo.otherParams.push("order");
+            dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("Ordered", "");
+            dynamicMethodInfo.argsCount++;
+        }
+    }
+    if (!dynamicMethodInfo.ignoreDistinct) {
+        const keySplitedDistinct = dynamicMethodInfo.keyToMapReplaced.split("Distinct");
+        if (keySplitedDistinct[1]) {
+            dynamicMethodCustomization.distinctKeys = keySplitedDistinct[1]
+                .split("And")
+                .map(uncapitalize_util_1.uncapitalize);
+        }
+        dynamicMethodInfo.keyToMapReplaced = keySplitedDistinct[0];
+    }
+    return dynamicMethodCustomization;
+}