vsrepo 1.3.3 → 1.3.4

package/dist/DynamicRepository.d.ts

@@ -91,7 +91,9 @@ type DynamicTransformCreatePayload<U, T, M extends PrismaModelName, TRelations>
 export type DynamicSaveInput<TEntity, UName extends PrismaModelName, WRelations = undefined> =
     ModelUpsertInput<UName> extends infer U
         ? U extends any
-            ? Simplify<DynamicTransformCreatePayload<U, TEntity, UName, ResolveRelations<WRelations>>>
+            ? Simplify<
+                  DynamicTransformCreatePayload<U, TEntity, UName, ResolveRelations<WRelations>>
+              >
             : never
         : never;
 
@@ -108,12 +110,14 @@ export type DynamicPatchInput<
     UName extends PrismaModelName,
     WRelations = undefined,
 > = Simplify<
-    DistributiveOmit<PrismaModelInputs<UName>["updateInput"], keyof ResolveRelations<WRelations>> & {
-        [K in Extract<keyof ResolveRelations<WRelations>, keyof TEntity>]?: DynamicRelationCreatePayload<
-            TEntity[K],
-            UName,
-            K
-        >;
+    DistributiveOmit<
+        PrismaModelInputs<UName>["updateInput"],
+        keyof ResolveRelations<WRelations>
+    > & {
+        [K in Extract<
+            keyof ResolveRelations<WRelations>,
+            keyof TEntity
+        >]?: DynamicRelationCreatePayload<TEntity[K], UName, K>;
     }
 >;
 
@@ -129,12 +133,14 @@ export type DynamicMergeInput<
     UName extends PrismaModelName,
     WRelations = undefined,
 > = Simplify<
-    DistributiveOmit<PrismaModelInputs<UName>["updateInput"], keyof ResolveRelations<WRelations>> & {
-        [K in Extract<keyof ResolveRelations<WRelations>, keyof TEntity>]?: DynamicRelationUpdatePayload<
-            TEntity[K],
-            UName,
-            K
-        >;
+    DistributiveOmit<
+        PrismaModelInputs<UName>["updateInput"],
+        keyof ResolveRelations<WRelations>
+    > & {
+        [K in Extract<
+            keyof ResolveRelations<WRelations>,
+            keyof TEntity
+        >]?: DynamicRelationUpdatePayload<TEntity[K], UName, K>;
     }
 >;
 
@@ -395,7 +401,7 @@ export type DynamicMethodConfig<M extends PrismaModelName = PrismaModelName> = {
  * class UserRepository extends DynamicRepository<User, "User", string> {
  *     `@DynamicMethod()`
  *     declare findOneByEmail: (email: string) => Promise<User | null>;
- * 
+ *
  *     @DynamicMethod<"User">({ injectOrdenation: { createdAt: "desc" } })
  *     declare findByAge: (email: number) => Promise<User[]>;
  * }
@@ -404,3 +410,67 @@ export type DynamicMethodConfig<M extends PrismaModelName = PrismaModelName> = {
 export declare function DynamicMethod<M extends PrismaModelName = PrismaModelName>(
     config?: DynamicMethodConfig<M>,
 ): PropertyDecorator;
+
+/**
+ * Single argument accepted by a method declared with `@QueryMethod`.
+ *
+ * `args` are injected positionally into the raw SQL statement (`$1`, `$2`, ...),
+ * exactly like Prisma's `$queryRawUnsafe`/`$executeRawUnsafe` parameters — this is
+ * what allows safe parameter injection instead of string-concatenating values into
+ * the SQL text.
+ *
+ * @template T Tuple type of the positional SQL parameters, e.g. `[email: string]`.
+ *
+ * @example
+ * ```typescript
+ * declare findByEmail: (arg: QueryMethodArg<[email: string]>) => Promise<User[]>;
+ * ```
+ */
+export type QueryMethodArg<T extends Array<any>> = {
+    /** Positional parameters injected into the SQL placeholders (`$1`, `$2`, ...). */
+    args: T;
+    /** Transaction client to run this query in, instead of the repository's default client. */
+    db?: ClientOrTransaction;
+};
+
+/**
+ * Options accepted by the `@QueryMethod` decorator.
+ */
+export type QueryMethodOptions = {
+    /**
+     * When `true`, the SQL is executed with `$executeRawUnsafe` (INSERT/UPDATE/DELETE)
+     * and the decorated method must resolve to `number` (the count of affected rows).
+     * When `false`/omitted, the SQL is executed with `$queryRawUnsafe` and the method
+     * resolves to whatever return type you declare on the field.
+     *
+     * @default false
+     */
+    modifying?: boolean;
+};
+
+/**
+ * Property decorator used to declare a **raw SQL query method** on a `DynamicRepository`
+ * subclass, bypassing name-based method parsing entirely.
+ *
+ * Applied to a `declare` class field, it executes `value` directly through Prisma
+ * (`$queryRawUnsafe` or `$executeRawUnsafe`, depending on `options.modifying`), with
+ * parameters injected positionally via `QueryMethodArg["args"]`. Since the SQL result
+ * isn't statically known, the field's own declared function type is what determines
+ * the method's return type — for `modifying: true` it must always resolve to `number`.
+ *
+ * @param value Raw SQL statement to execute. Use `$1`, `$2`, ... placeholders for the
+ * values that will be passed via `args` — never interpolate values directly into `value`.
+ * @param options Optional configuration; set `modifying: true` for `INSERT`/`UPDATE`/`DELETE` statements.
+ *
+ * @example
+ * ```typescript
+ * class UserRepository extends DynamicRepository<User, "User", string> {
+ *     @QueryMethod('SELECT * FROM "user" WHERE email = $1')
+ *     declare findByEmailRaw: (arg: QueryMethodArg<[email: string]>) => Promise<User[]>;
+ *
+ *     @QueryMethod('UPDATE "user" SET active = true WHERE id = $1', { modifying: true })
+ *     declare activateUser: (arg: QueryMethodArg<[id: string]>) => Promise<number>;
+ * }
+ * ```
+ */
+export declare function QueryMethod(value: string, options?: QueryMethodOptions): PropertyDecorator;

package/dist/DynamicRepository.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamicRepository = exports.DynamicMethod = void 0;
+exports.DynamicRepository = exports.QueryMethod = exports.DynamicMethod = void 0;
 const dynamic_methods_metadata_resolve_1 = require("./internal/resolvers/dynamic-methods-metadata.resolve");
 const build_config_validate_1 = require("./internal/validation/build-config.validate");
 const is_object_validate_1 = require("./internal/validation/is-object.validate");
@@ -8,6 +8,8 @@ const VSRepository_1 = require("./VSRepository");
 require("reflect-metadata");
 var dynamic_method_decorator_1 = require("./internal/decorators/dynamic-method.decorator");
 Object.defineProperty(exports, "DynamicMethod", { enumerable: true, get: function () { return dynamic_method_decorator_1.DynamicMethod; } });
+var query_method_decorator_1 = require("./internal/decorators/query-method.decorator");
+Object.defineProperty(exports, "QueryMethod", { enumerable: true, get: function () { return query_method_decorator_1.QueryMethod; } });
 class DynamicRepository extends VSRepository_1.VSRepository {
     constructor(prisma, config) {
         if (!(0, is_object_validate_1.isObject)(config)) {
@@ -22,33 +24,3 @@ class DynamicRepository extends VSRepository_1.VSRepository {
     }
 }
 exports.DynamicRepository = DynamicRepository;
-// export class UserRepository extends DynamicRepository {
-//     constructor() {
-//         super(
-//             { $transaction: {} },
-//             {
-//                 tableName: "user",
-//                 pkName: "id",
-//                 requiredWhere: { active: true },
-//                 softRemovekName: "createdAt",
-//                 build: { showWorking: true },
-//             },
-//         );
-//     }
-//     @DynamicMethod()
-//     declare findByAge: (age: number) => Promise<object[]>;
-//     @DynamicMethod()
-//     declare findOneByEmail: (email: number) => Promise<object[]>;
-//     @DynamicMethod()
-//     declare findByNameStartsWithInsensitive: (email: number) => Promise<object[]>;
-//     @DynamicMethod()
-//     declare findByDescriptionIsNull: (email: number) => Promise<object[]>;
-//     @DynamicMethod({ whereType: "overwrite" })
-//     declare findByNameContainsInsensitiveOrderedAndPaginated: (email: number) => Promise<object[]>;
-//     @DynamicMethod({
-//         injectOrdenation: [{ address: { state: "asc" } }, { address: { city: "asc" } }],
-//     })
-//     declare findByAddressWithCountry: (email: number) => Promise<object[]>;
-// }
-// const userRepository = new UserRepository();
-// console.log(userRepository);

package/dist/VSRepository.d.ts

@@ -408,18 +408,47 @@ type GroupByMethod<M extends PrismaModelName> = <A extends Prisma.TypeMap['model
     options?: { db?: ClientOrTransaction }
 ) => Promise<Prisma.Result<PrismaDelegate<M>, A, 'groupBy'>>;
 
+/**
+ * Function type generated for a dynamic method configured with `query` (non-modifying).
+ *
+ * The result of a raw SQL `SELECT` isn't statically known, so the method itself
+ * resolves to `any` by default, but exposes a generic parameter so the caller can
+ * infer/assert the shape of the result: `repo.myRawQuery<User[]>({ args: [...] })`.
+ *
+ * @template TReturn Return type asserted at the call site. Defaults to `any`.
+ */
+type QueryMethodFn = <TReturn = any>(
+    arg: { args: any[]; db?: ClientOrTransaction },
+) => Promise<TReturn>;
+
+/**
+ * Function type generated for a dynamic method configured with `query` and
+ * `modifying: true`.
+ *
+ * Modifying raw queries run through `$executeRawUnsafe` and always resolve to the
+ * number of affected rows, so — unlike `QueryMethodFn` — no generic return type is
+ * exposed here.
+ */
+type QueryMethodModifyingFn = (
+    arg: { args: any[]; db?: ClientOrTransaction },
+) => Promise<number>;
+
 type DynamicMethods<T, M extends PrismaModelName, Config, I> = Config extends { methods: infer Methods }
     ? {
           [K in keyof Methods as Methods[K] extends { map: true } ? K : never]: K extends string
-              ? (Methods[K] extends { proxyTo: infer P extends string } ? P : K) extends infer ResolvedKey
-                  ? ResolvedKey extends 'aggregate'
-                      ? AggregateMethod<M>
-                      : ResolvedKey extends 'groupBy'
-                      ? GroupByMethod<M>
-                      : ResolvedKey extends string
-                      ? MethodFactory<T, M, ResolvedKey, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K], ExtractIncludeModels<Config>>
+              ? Methods[K] extends { query: { modifying: true } }
+                  ? QueryMethodModifyingFn
+                  : Methods[K] extends { query: infer Q }
+                  ? QueryMethodFn
+                  : (Methods[K] extends { proxyTo: infer P extends string } ? P : K) extends infer ResolvedKey
+                      ? ResolvedKey extends 'aggregate'
+                          ? AggregateMethod<M>
+                          : ResolvedKey extends 'groupBy'
+                          ? GroupByMethod<M>
+                          : ResolvedKey extends string
+                          ? MethodFactory<T, M, ResolvedKey, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K], ExtractIncludeModels<Config>>
+                          : never
                       : never
-                  : never
               : never;
       }
     : {};
@@ -524,6 +553,53 @@ export type MethodConfig<M extends PrismaModelName, SelectModels = any> = {
     readonly injectOrdenation?: OrdenationModel<M>;
     /** Injects a fixed pagination automatically into the query. */
     readonly injectPagination?: PaginationModel<M>;
+    /**
+     * Turns this method into a **raw SQL query method**, bypassing name-based parsing
+     * entirely. The method executes the given SQL directly through Prisma, with
+     * parameters injected positionally via the `args` array passed at the call site
+     * (`$1`, `$2`, ... placeholders), so no other option in `MethodConfig` applies
+     * (`selectModels`, `requiredWhere`, `pushWhere`, etc. are all ignored).
+     *
+     * - `modifying: false` (default) runs through `$queryRawUnsafe` and the method
+     *   resolves to `TReturn` (`any` by default), inferable/assertable via a generic
+     *   at the call site.
+     * - `modifying: true` runs through `$executeRawUnsafe` and the method **always**
+     *   resolves to `number` (the count of affected rows).
+     *
+     * @example
+     * ```typescript
+     * methods: {
+     *   findActiveUsersRaw: {
+     *     map: true,
+     *     query: { value: 'SELECT * FROM "user" WHERE active = $1' },
+     *   },
+     *   deactivateUsersOlderThanRaw: {
+     *     map: true,
+     *     query: { value: 'UPDATE "user" SET active = false WHERE "createdAt" < $1', modifying: true },
+     *   },
+     * }
+     *
+     * // Uso:
+     * const users = await repo.findActiveUsersRaw<User[]>({ args: [true] });
+     * const affected = await repo.deactivateUsersOlderThanRaw({ args: [cutoffDate] });
+     * ```
+     */
+    readonly query?: {
+        /**
+         * Raw SQL statement to execute. Use positional placeholders (`$1`, `$2`, ...)
+         * for the values passed in `args`, never string-interpolate the values
+         * directly, or you'll re-introduce the SQL injection risk this API exists to avoid.
+         */
+        readonly value: string;
+        /**
+         * When `true`, executes via `$executeRawUnsafe` and the method always resolves
+         * to `number` (rows affected). When `false`/omitted, executes via
+         * `$queryRawUnsafe` and the method resolves to `TReturn` (`any` by default).
+         *
+         * @default false
+         */
+        readonly modifying?: boolean;
+    };
 };
 
 type BaseMethodConfig<TSelectKeys extends PropertyKey = string> = {
@@ -1062,7 +1138,14 @@ export type ValidateRepoConfig<T extends object, M extends PrismaModelName, Conf
      */
     methods?: {
         [K in keyof (Config extends { methods: infer Meth } ? Meth : {})]: K extends string
-            ? MethodConfig<M, Config extends { selectModels: infer SM } ? SM : any> & (K extends ValidMethodPatterns ? {} : { proxyTo: ValidMethodPatterns })
+            ? MethodConfig<M, Config extends { selectModels: infer SM } ? SM : any> &
+              (K extends ValidMethodPatterns
+                  ? {}
+                  : (Config extends { methods: infer Meth }
+                        ? (K extends keyof Meth ? Meth[K] : never)
+                        : never) extends { query: any }
+                    ? {}
+                    : { proxyTo: ValidMethodPatterns })
             : never;
     };
 };

package/dist/VSRepository.js

@@ -29,6 +29,7 @@ const pretty_wheres_resolve_1 = require("./internal/resolvers/pretty-wheres.reso
 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");
+const query_method_arg_validate_1 = require("./internal/validation/query-method-arg.validate");
 class VSRepository {
     vsrepocache;
     tableName;
@@ -82,6 +83,27 @@ class VSRepository {
                 (0, logger_util_1.logger)("Keys to map:", "build", buildInstance.tableName, methodsToMap);
             for (let methodToMap of methodsToMap) {
                 const originalKey = methodToMap;
+                if (methods[originalKey]?.query) {
+                    const modifyingQueryMethod = methods[originalKey].query.modifying;
+                    const valueQueryMethod = methods[originalKey].query.value;
+                    buildInstance[originalKey] = async (arg) => {
+                        const queryArgValidated = (0, query_method_arg_validate_1.validateQueryMethodArg)(arg, buildInstance);
+                        const db = queryArgValidated.db ?? buildInstance.prisma;
+                        const start = showWorking
+                            ? (0, logger_util_1.performanceLoggerStart)(buildInstance.tableName, `Query method: ${originalKey} (Modifying: ${modifyingQueryMethod})`, queryArgValidated.args)
+                            : undefined;
+                        try {
+                            const result = await db[modifyingQueryMethod ? "$executeRawUnsafe" : "$queryRawUnsafe"](valueQueryMethod, ...queryArgValidated.args);
+                            if (showWorking)
+                                (0, logger_util_1.performanceLoggerEnd)(buildInstance.tableName, `Query method: ${originalKey} (Modifying: ${modifyingQueryMethod})`, start);
+                            return result;
+                        }
+                        catch (err) {
+                            throw err;
+                        }
+                    };
+                    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);

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

@@ -8,7 +8,7 @@ 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, validatedConfig?.map ?? true, validatedConfig?.proxyTo, validatedConfig?.whereType, validatedConfig?.pushWhere, validatedConfig?.fbMode, validatedConfig?.injectOrdenation, validatedConfig?.injectPagination));
+        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);
     };
 }

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

@@ -0,0 +1,16 @@
+"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_method_metadata_entity_1 = require("../entities/dynamic-method-metadata.entity");
+const query_method_options_validate_1 = require("../validation/query-method-options.validate");
+function QueryMethod(value, options) {
+    const validatedConfig = 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) ?? [];
+        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);
+    };
+}

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

@@ -10,7 +10,8 @@ class DynamicMethodMetadata {
     fbMode;
     injectOrdenation;
     injectPagination;
-    constructor(propertyKey, map, proxyTo, whereType, pushWhere, fbMode, injectOrdenation, injectPagination) {
+    query;
+    constructor(propertyKey, map, proxyTo, whereType, pushWhere, fbMode, injectOrdenation, injectPagination, query) {
         this.propertyKey = propertyKey;
         this.map = map;
         this.proxyTo = proxyTo;
@@ -19,6 +20,7 @@ class DynamicMethodMetadata {
         this.fbMode = fbMode;
         this.injectOrdenation = injectOrdenation;
         this.injectPagination = injectPagination;
+        this.query = query;
     }
 }
 exports.DynamicMethodMetadata = DynamicMethodMetadata;

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

@@ -3,11 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.methodSchema = exports.booleanSchema = exports.objectSchema = exports.stringSchema = void 0;
+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(),
@@ -17,4 +21,5 @@ exports.methodSchema = zod_1.default.strictObject({
     fbMode: zod_1.default.enum(["one", "list"]).optional(),
     injectOrdenation: exports.objectSchema.or(zod_1.default.array(exports.objectSchema)).optional(),
     injectPagination: exports.objectSchema.optional(),
+    query: exports.queryOptionsSchema.optional(),
 });

package/dist/internal/validation/query-method-arg.validate.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQueryMethodArg = validateQueryMethodArg;
+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 validateQueryMethodArg(arg, instance) {
+    const queryArgSchema = zod_1.default.strictObject({
+        args: zod_1.default.array(zod_1.default.any()),
+        db: schemas_util_1.objectSchema.optional(),
+    });
+    const argParsed = queryArgSchema.safeParse(arg);
+    if (!argParsed.success) {
+        const firstIssue = argParsed.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 argParsed.data;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQueryMethodOptions = validateQueryMethodOptions;
+const zod_1 = __importDefault(require("zod"));
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+const is_object_validate_1 = require("./is-object.validate");
+const schemas_util_1 = require("../utils/schemas.util");
+function validateQueryMethodOptions(options) {
+    if (!(0, is_object_validate_1.isObject)(options)) {
+        throw new vs_repo_error_1.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) 'options' must be a valid object`);
+    }
+    const optionsParsed = zod_1.default
+        .strictObject({ modifying: schemas_util_1.booleanSchema.default(false) })
+        .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.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) ${path}: ${firstIssue?.message}`);
+    }
+    return optionsParsed.data;
+}

package/dist/internal/validation/types/query-method-arg.type.js

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "A repository pattern library for Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {

package/scripts/configure-prisma-import.mjs

@@ -179,16 +179,19 @@ export type * from './VSRepository.types';
     fileName: 'DynamicRepository.ts',
     content: `import {
   DynamicRepository as DynamicRepositoryRuntime,
-  DynamicMethod as DynamicMethodRuntime
+  DynamicMethod as DynamicMethodRuntime,
+  QueryMethod as QueryMethodRuntime,
 } from 'vsrepo/DynamicRepository';
 
 import type {
   DynamicRepository as DynamicRepositoryType,
-  DynamicMethod as DynamicMethodType
+  DynamicMethod as DynamicMethodType,
+  QueryMethod as QueryMethodType,
 } from './DynamicRepository.types';
 
 export const DynamicRepository = DynamicRepositoryRuntime as typeof DynamicRepositoryType;
 export const DynamicMethod = DynamicMethodRuntime as typeof DynamicMethodType;
+export const QueryMethod = QueryMethodRuntime as typeof QueryMethodType;
 
 export type * from './DynamicRepository.types';
 `,
@@ -210,7 +213,8 @@ export {
 
 export {
   DynamicRepository,
-  DynamicMethod
+  DynamicMethod,
+  QueryMethod,
 } from './DynamicRepository.js';
 
 export type * from './VSRepoError.types';
@@ -229,15 +233,15 @@ for (const file of tsFiles) {
 }
 
 // Copia o README.md do pacote VSRepository para o diretório de output, se existir
-const readmeSource = path.join(packageRoot, 'README.md');
-const readmeTarget = path.join(outputDir, 'README.md');
-
-if (fs.existsSync(readmeSource)) {
-  fs.copyFileSync(readmeSource, readmeTarget);
-  console.log(`Gerado: ${path.relative(workspaceRoot, readmeTarget)}`);
-} else {
-  console.warn(`README.md do VSRepository nao encontrado em: ${path.relative(workspaceRoot, readmeSource)}. Ignorando a copia.`);
-}
+// const readmeSource = path.join(packageRoot, 'README.md');
+// const readmeTarget = path.join(outputDir, 'README.md');
+
+// if (fs.existsSync(readmeSource)) {
+//   fs.copyFileSync(readmeSource, readmeTarget);
+//   console.log(`Gerado: ${path.relative(workspaceRoot, readmeTarget)}`);
+// } else {
+//   console.warn(`README.md do VSRepository nao encontrado em: ${path.relative(workspaceRoot, readmeSource)}. Ignorando a copia.`);
+// }
 
 console.log('\nVSRepository gerado com tipagem do Prisma.');
 console.log(`Output: ${path.relative(workspaceRoot, outputDir)}`);