vsrepo 1.3.3 → 1.3.5

package/dist/DynamicRepository.d.ts

@@ -15,6 +15,7 @@ import {
     PrismaModelName,
     RepositoryRelations,
     SeeMode,
+    SelectModel,
     WhereModel,
 } from "./VSRepository.d";
 
@@ -91,7 +92,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 +111,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 +134,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>;
     }
 >;
 
@@ -151,8 +158,11 @@ export type DynamicMethodOptions<TName extends PrismaModelName = PrismaModelName
      */
     see?: SeeMode;
 
-    /** Raw Prisma `include`. */
+    /** Raw Prisma `include`. Cannot be used together with `select`. */
     include?: IncludeModel<TName>;
+
+    /** Raw Prisma `select`. Cannot be used together with `include`. */
+    select?: SelectModel<TName>;
 };
 
 /**
@@ -284,7 +294,7 @@ export declare abstract class DynamicRepository<
     /** Saves an array of objects in a single automatic transaction. */
     saveList(
         objs: DynamicSaveInput<TEntity, UName, WRelations>[],
-        options?: Omit<DynamicMethodOptions<UName>, "include"> & {
+        options?: Omit<DynamicMethodOptions<UName>, "include" | "select"> & {
             /** Transaction client to use for this operation. */
             db?: DbTransaction;
         },
@@ -300,7 +310,7 @@ export declare abstract class DynamicRepository<
     /** Partially updates multiple records via `[pk, obj]` tuples in an automatic transaction. */
     patchList(
         tuples: [pk: VPKType, obj: DynamicPatchInput<TEntity, UName, WRelations>][],
-        options?: Omit<DynamicMethodOptions<UName>, "include"> & {
+        options?: Omit<DynamicMethodOptions<UName>, "include" | "select"> & {
             /** Transaction client to use for this operation. */
             db?: DbTransaction;
         },
@@ -316,7 +326,7 @@ export declare abstract class DynamicRepository<
     /** Deletes multiple records by their primary keys. */
     removeList(
         pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "include">,
+        options?: Omit<DynamicMethodOptions<UName>, "include" | "select">,
     ): Promise<{ count: number }>;
 
     /** Fetches all records (respects `requiredWhere` when set). */
@@ -334,10 +344,10 @@ export declare abstract class DynamicRepository<
     ): Promise<TEntity[]>;
 
     /** Returns the total number of records. */
-    total(options?: Omit<DynamicMethodOptions<UName>, "include">): Promise<number>;
+    total(options?: Omit<DynamicMethodOptions<UName>, "include" | "select">): Promise<number>;
 
     /** Checks whether a record exists by its primary key (PK). */
-    has(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "include">): Promise<boolean>;
+    has(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "include" | "select">): Promise<boolean>;
 
     /** Marks a record as deleted (soft-delete). */
     softRemove(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "see">): Promise<TEntity>;
@@ -345,7 +355,7 @@ export declare abstract class DynamicRepository<
     /** Marks multiple records as deleted (soft-delete) in batch. */
     softRemoveList(
         pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "see" | "include">,
+        options?: Omit<DynamicMethodOptions<UName>, "see" | "include" | "select">,
     ): Promise<{ count: number }>;
 
     /** Restores a record previously marked as deleted (soft-delete). */
@@ -354,7 +364,7 @@ export declare abstract class DynamicRepository<
     /** Restores multiple records previously marked as deleted (soft-delete) in batch. */
     restoreList(
         pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "see" | "include">,
+        options?: Omit<DynamicMethodOptions<UName>, "see" | "include" | "select">,
     ): Promise<{ count: number }>;
 }
 
@@ -395,7 +405,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 +414,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);