vsrepo 1.4.2 → 2.1.0

package/dist/DynamicRepository.d.ts

@@ -1,497 +0,0 @@
-import {
-    BuildConfig,
-    ClientOrTransaction,
-    DbClient,
-    DbTransaction,
-    DistributiveOmit,
-    ExtractNestedCreateInput,
-    ExtractNestedUpdateInput,
-    IncludeModel,
-    ModelUpsertInput,
-    OrderingModel,
-    PaginationModel,
-    PaginationOptions,
-    PrismaModelInputs,
-    PrismaModelName,
-    RepositoryRelations,
-    SeeMode,
-    SelectModel,
-    WhereModel,
-} from "./VSRepository.d";
-
-/**
- * Flattens a type intersection into a single object,
- * avoiding the TypeScript "union type too complex to represent" error.
- */
-type Simplify<T> = { [K in keyof T]: T[K] } & {};
-
-/**
- * Resolves `WRelations` to a concrete relation map, falling back to `{}` when no
- * relations were flagged (mirrors `VSRepository`'s own internal fallback).
- */
-type ResolveRelations<WRelations> = WRelations extends object ? WRelations : {};
-
-/**
- * Payload accepted for a relation field mapped as `true` in `WRelations`, used to build
- * the `create`-shaped payload for `save`/`saveList`/`patch`/`patchList`.
- *
- * To-many relations (array fields) resolve to a list of Prisma's own nested `create`
- * payload. To-one relations (object fields) resolve to that same nested `create` payload,
- * but **always also accept `null`** by default — since `WRelations` only flags *which*
- * fields are relations (not their `mode`/`restriction`/`nullable` config), every to-one
- * relation here is treated as unlinkable.
- */
-type DynamicRelationCreatePayload<TField, M extends PrismaModelName, K extends PropertyKey> =
-    NonNullable<TField> extends any[]
-        ? ExtractNestedCreateInput<M, K>[]
-        : NonNullable<TField> extends object
-          ? ExtractNestedCreateInput<M, K> | null
-          : never;
-
-/**
- * Same as `DynamicRelationCreatePayload`, but built from Prisma's nested `update` payload
- * instead of `create` — used by `merge`. To-one relations still accept `null` by default.
- */
-type DynamicRelationUpdatePayload<TField, M extends PrismaModelName, K extends PropertyKey> =
-    NonNullable<TField> extends any[]
-        ? ExtractNestedUpdateInput<M, K>[]
-        : NonNullable<TField> extends object
-          ? ExtractNestedUpdateInput<M, K> | null
-          : never;
-
-/**
- * Distributes over the branches of Prisma's own upsert/create union for `UName`, replacing
- * every field flagged in `TRelations` with `DynamicRelationCreatePayload`.
- */
-type DynamicTransformCreatePayload<U, T, M extends PrismaModelName, TRelations> = Omit<
-    U,
-    keyof TRelations
-> & {
-    // Fields that are REQUIRED in this specific branch of the Prisma union
-    [K in Extract<keyof TRelations, keyof U> as {} extends Pick<U, K>
-        ? never
-        : K]: K extends keyof T ? DynamicRelationCreatePayload<T[K], M, K> : never;
-} & {
-    // Fields that are OPTIONAL in this branch or do not originally belong to it
-    [K in keyof TRelations as K extends keyof U
-        ? {} extends Pick<U, K>
-            ? K
-            : never
-        : K]?: K extends keyof T ? DynamicRelationCreatePayload<T[K], M, K> : never;
-};
-
-/**
- * Payload accepted by the `save`/`saveList` methods.
- *
- * Built directly from Prisma's own upsert/create input for `UName`, exactly like
- * `VSRepository`'s `save`: fields flagged as relations via `WRelations` are resolved
- * into their nested `create` payload shape instead of `TEntity`'s own shape (to-one
- * relations also accept `null` by default); every other field keeps Prisma's own
- * validated create input shape.
- */
-export type DynamicSaveInput<TEntity, UName extends PrismaModelName, WRelations = undefined> =
-    ModelUpsertInput<UName> extends infer U
-        ? U extends any
-            ? Simplify<
-                  DynamicTransformCreatePayload<U, TEntity, UName, ResolveRelations<WRelations>>
-              >
-            : never
-        : never;
-
-/**
- * Payload accepted by the `patch`/`patchList` methods.
- *
- * Built from Prisma's own `update` input for `UName` (so every field is already
- * optional); fields flagged as relations via `WRelations` are resolved into their
- * nested `create` payload shape, the same way as in `DynamicSaveInput` (to-one
- * relations also accept `null` by default).
- */
-export type DynamicPatchInput<
-    TEntity,
-    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>;
-    }
->;
-
-/**
- * Payload accepted by the `merge` method.
- *
- * Built from Prisma's own `update` input for `UName` (so every field is already
- * optional); fields flagged as relations via `WRelations` are resolved into their
- * nested `update` payload shape (to-one relations also accept `null` by default).
- */
-export type DynamicMergeInput<
-    TEntity,
-    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>;
-    }
->;
-
-/**
- * Base options accepted by most `DynamicRepository` methods.
- */
-export type DynamicMethodOptions<TName extends PrismaModelName = PrismaModelName> = {
-    /** Database client or transaction to use for this operation. */
-    db?: ClientOrTransaction;
-
-    /**
-     * Controls visibility of soft-deleted records.
-     * Only takes effect if `softRemovekName` is configured.
-     */
-    see?: SeeMode;
-
-    /** Raw Prisma `include`. Cannot be used together with `select`. */
-    include?: IncludeModel<TName>;
-
-    /** Raw Prisma `select`. Cannot be used together with `include`. */
-    select?: SelectModel<TName>;
-};
-
-/**
- * Configuration for an individual base method exposed by `DynamicRepository`.
- *
- * Unlike `VSRepository`'s `BuildConfig`, this configuration does not accept
- * `active` (base methods are always available) nor `defaultSelect`
- * (`DynamicRepository` has no select models).
- */
-type StrippedBaseMethods<TSelectKeys extends PropertyKey = string> = {
-    [K in keyof NonNullable<BuildConfig<TSelectKeys>["baseMethods"]>]: Omit<
-        NonNullable<NonNullable<BuildConfig<TSelectKeys>["baseMethods"]>[K]>,
-        "active" | "defaultSelect"
-    >;
-};
-
-/**
- * Configuration applied during the construction of a `DynamicRepository`.
- *
- * Equivalent to `VSRepository`'s `BuildConfig`, but without `freeze`
- * (no longer configurable) and without `active`/`defaultSelect` on each
- * base method (base methods are always active and there are no select models).
- */
-export type DynamicRepositoryBuildConfig = Omit<BuildConfig, "freeze" | "baseMethods"> & {
-    /** Customizes the behavior of the automatic base methods. */
-    baseMethods?: StrippedBaseMethods;
-};
-
-/**
- * Configuration used to construct a `DynamicRepository`.
- *
- * @template T Type of the entity managed by the repository.
- * @template U Prisma model name.
- */
-export interface DynamicRepositoryConstructorConfig<T, U extends PrismaModelName> {
-    /**
-     * Name of the table mapped by Prisma (usually uncapitalized).
-     */
-    tableName: Uncapitalize<U>;
-
-    /**
-     * Name of the field that represents the entity's primary key (Primary Key).
-     */
-    pkName: keyof T;
-
-    /**
-     * Name of the `DateTime` field used for soft-delete.
-     *
-     * When configured, enables the `softRemove`, `softRemoveList`, `restore`, and `restoreList` methods.
-     * The field **must** be of type `DateTime` in the Prisma schema — VSRepository validates this during `build`.
-     */
-    softRemovekName?: keyof T;
-
-    /**
-     * Defines global filters that will be automatically applied to all repository queries.
-     * Useful for tenant isolation (multi-tenancy) or base restrictions (e.g., `isActive: true`).
-     */
-    requiredWhere?: WhereModel<U>;
-
-    /**
-     * 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.
-     */
-    defaultOrdering?: OrderingModel<U>;
-
-    /**
-     * 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?: OrderingModel<U>;
-
-    /**
-     * Configures automatic relation management.
-     * When configured, allows the `save`, `saveList`, `patch`, and `patchList` methods
-     * to automatically handle linking, creation, or cascading deletion of related records.
-     */
-    relations?: RepositoryRelations<T>;
-
-    /**
-     * Customizes the behavior of the automatic base methods when the repository is built.
-     */
-    build?: DynamicRepositoryBuildConfig;
-}
-
-/**
- * Base repository built from a fixed configuration, exposing a complete set of
- * ready-to-use CRUD and soft-delete methods around a Prisma model.
- *
- * @template TEntity Type of the entity managed by the repository.
- * @template UName Prisma model name.
- * @template VPKType Type of the entity's primary key value.
- * @template WRelations Keys of `TEntity` configured as relations (flags only, `true`
- * per relation field). The actual relation behavior (`mode`, `restriction`, `nullable`)
- * still comes from `relations` in the constructor config; `WRelations` here only tells
- * `DynamicSaveInput`/`DynamicPatchInput`/`DynamicMergeInput` which fields to resolve
- * into their nested Prisma create/update payload shape instead of `TEntity`'s own shape.
- */
-export declare abstract class DynamicRepository<
-    TEntity extends object,
-    UName extends PrismaModelName,
-    VPKType,
-    WRelations extends Partial<Record<keyof TEntity, true>> | undefined = undefined,
-> {
-    /**
-     * Creates a configured instance of `DynamicRepository`.
-     */
-    constructor(prisma: DbClient, config: DynamicRepositoryConstructorConfig<TEntity, UName>);
-
-    /**
-     * The Prisma Client instance passed to constructor.
-     */
-    readonly prisma: DbClient;
-
-    /** Fetches a record by its primary key (PK). */
-    get(pk: VPKType, options?: DynamicMethodOptions<UName>): Promise<TEntity | null>;
-
-    /** Fetches a record by PK and throws `VSRepoRuntimeError` if not found. */
-    getOrThrow(pk: VPKType, options?: DynamicMethodOptions<UName>): Promise<TEntity>;
-
-    /** Fetches multiple records by a list of primary keys (PKs). */
-    getList(pks: VPKType[], options?: DynamicMethodOptions<UName>): Promise<TEntity[]>;
-
-    /** Deletes a record identified by its primary key (PK). */
-    remove(pk: VPKType, options?: DynamicMethodOptions<UName>): Promise<TEntity>;
-
-    /** Inserts or updates (upsert) a record. */
-    save(
-        obj: DynamicSaveInput<TEntity, UName, WRelations>,
-        options?: DynamicMethodOptions<UName>,
-    ): Promise<TEntity>;
-
-    /** Saves an array of objects in a single automatic transaction. */
-    saveList(
-        objs: DynamicSaveInput<TEntity, UName, WRelations>[],
-        options?: Omit<DynamicMethodOptions<UName>, "include" | "select"> & {
-            /** Transaction client to use for this operation. */
-            db?: DbTransaction;
-        },
-    ): Promise<TEntity[]>;
-
-    /** Partially updates (patch) an existing record by its primary key (PK). */
-    patch(
-        pk: VPKType,
-        obj: DynamicPatchInput<TEntity, UName, WRelations>,
-        options?: DynamicMethodOptions<UName>,
-    ): Promise<TEntity>;
-
-    /** 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" | "select"> & {
-            /** Transaction client to use for this operation. */
-            db?: DbTransaction;
-        },
-    ): Promise<TEntity[]>;
-
-    /** Fetches a record by PK and deep-merges it with the provided object **in memory**. */
-    merge(
-        pk: VPKType,
-        obj: DynamicMergeInput<TEntity, UName, WRelations>,
-        options?: DynamicMethodOptions<UName>,
-    ): Promise<TEntity | null>;
-
-    /** Deletes multiple records by their primary keys. */
-    removeList(
-        pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "include" | "select">,
-    ): Promise<{ count: number }>;
-
-    /** Fetches all records (respects `requiredWhere` when set). */
-    getAll(
-        options?: DynamicMethodOptions<UName> & {
-            /** Pagination options for the query. */
-            pagination?: PaginationOptions;
-            /**
-             * Ordering to apply to the query.
-             * When omitted and `defaultOrdering` is configured on the repository,
-             * the default ordering is applied automatically.
-             */
-            order?: OrderingModel<UName>;
-        },
-    ): Promise<TEntity[]>;
-
-    /** Returns the total number of records. */
-    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" | "select">): Promise<boolean>;
-
-    /** Marks a record as deleted (soft-delete). */
-    softRemove(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "see">): Promise<TEntity>;
-
-    /** Marks multiple records as deleted (soft-delete) in batch. */
-    softRemoveList(
-        pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "see" | "include" | "select">,
-    ): Promise<{ count: number }>;
-
-    /** Restores a record previously marked as deleted (soft-delete). */
-    restore(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "see">): Promise<TEntity>;
-
-    /** Restores multiple records previously marked as deleted (soft-delete) in batch. */
-    restoreList(
-        pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "see" | "include" | "select">,
-    ): Promise<{ count: number }>;
-}
-
-export type DynamicMethodConfig<M extends PrismaModelName = PrismaModelName> = {
-    /** Redirects the logic to another valid method pattern. */
-    proxyTo?: string;
-
-    /** Controls whether the method combines (`extending`) or overwrites (`overwrite`) the `requiredWhere`. */
-    whereType?: "overwrite" | "extending";
-
-    /** Adds an extra `where` on top of `requiredWhere`. */
-    pushWhere?: WhereModel<M>;
-
-    /**
-     * Defines whether the method returns a single item (`one`) or a list (`list`).
-     * @deprecated Use `findOneBy` if you want to return a single result.
-     */
-    fbMode?: "one" | "list";
-
-    /** Injects a fixed ordering automatically into the query. */
-    injectOrdering?: OrderingModel<M>;
-
-    /**
-     * Injects a fixed ordering automatically into the query.
-     * @deprecated Use `injectOrdering` instead.
-     */
-    injectOrdenation?: OrderingModel<M>;
-
-    /** Injects a fixed pagination automatically into the query. */
-    injectPagination?: PaginationModel<M>;
-};
-
-/**
- * Property decorator used to declare a dynamic method on a `DynamicRepository` subclass.
- *
- * Applied to a `declare` class field whose name follows one of the supported method
- * patterns (e.g. `findByEmail`, `findManyByStatusPaginated`); the method's behavior and
- * return type are inferred from the field name, optionally adjusted via `config`.
- *
- * @template M Prisma model name the decorated method operates on.
- *
- * @example
- * ```typescript
- * class UserRepository extends DynamicRepository<User, "User", string> {
- *     `@DynamicMethod()`
- *     declare findOneByEmail: (email: string) => Promise<User | null>;
- *
- *     @DynamicMethod<"User">({ injectOrdering: { createdAt: "desc" } })
- *     declare findByAge: (email: number) => Promise<User[]>;
- * }
- * ```
- */
-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,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-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)) {
-            throw new VSRepository_1.VSRepoConfigError(`[VSRepository] (unknown: config) 'config' must be a valid object`);
-        }
-        const { build: buildConfig = {}, ...constructorConfig } = config;
-        super(constructorConfig);
-        const dynamicMethodsMetadata = (0, dynamic_methods_metadata_resolve_1.resolveDynamicMethodsMetadata)(this.constructor.prototype);
-        this.methods = dynamicMethodsMetadata;
-        const buildConfigValidated = (0, build_config_validate_1.validateBuildConfig)(buildConfig, this);
-        this.build(prisma, { ...buildConfigValidated, freeze: false }, this);
-    }
-}
-exports.DynamicRepository = DynamicRepository;

package/dist/VSRepoError.d.ts

@@ -1,83 +0,0 @@
-/**
- * Literal types representing the internal error codes of the library.
- */
-export type VSRepoErrorType = 
-    | 'VSREPO_CONFIG'
-    | 'VSREPO_BUILD'
-    | 'VSREPO_EXTEND'
-    | '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.
- */
-export declare abstract class VSRepoError extends Error {
-    /** Internal code used to identify the error category. */
-    abstract readonly type: VSRepoErrorType;
-    
-    constructor(message: string, type: VSRepoErrorType);
-}
-
-/**
- * Thrown when an invalid configuration or a configuration inconsistency
- * is detected before or during repository initialization.
- */
-export declare class VSRepoConfigError extends VSRepoError {
-    readonly type: 'VSREPO_CONFIG';
-    constructor(message: string);
-}
-
-/**
- * Thrown when the Prisma instance injection fails or when the
- * build configuration is incorrect in the `.build()`.
- */
-export declare class VSRepoBuildError extends VSRepoError {
-    readonly type: 'VSREPO_BUILD';
-    constructor(message: string);
-}
-
-/**
- * Thrown when an error occurs while injecting new methods into the repository
- * via `.extend()`.
- */
-export declare class VSRepoExtendError extends VSRepoError {
-    readonly type: 'VSREPO_EXTEND';
-    constructor(message: string);
-}
-
-/**
- * Thrown when invalid arguments are passed to a decorator.
- */
-export declare class VSRepoDecoratorError extends VSRepoError {
-    readonly type: 'VSREPO_DECORATOR';
-    constructor(message: string);
-}
-
-/**
- * Thrown when dynamic operations fail at runtime, such as
- * when invalid arguments are passed to methods.
- */
-export declare class VSRepoRuntimeError extends VSRepoError {
-    readonly type: 'VSREPO_RUNTIME';
-    /** Internal code identifying the category of runtime failure. See {@link VSRepoRuntimeErrorCode}. */
-    readonly code: VSRepoRuntimeErrorCode;
-    constructor(message: string, code: VSRepoRuntimeErrorCode);
-}

package/dist/VSRepoError.js

@@ -1,17 +0,0 @@
-"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("./internal/errors/vs-repo.error"), exports);

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

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamicMethod = DynamicMethod;
-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(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,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryMethod = QueryMethod;
-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");
-function QueryMethod(value, options) {
-    if (typeof value !== "string") {
-        throw new vs_repo_error_1.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) 'value' must be a valid string`);
-    }
-    const validatedConfig = options
-        ? (0, query_method_options_validate_1.validateQueryMethodOptions)(options)
-        : { modifying: false };
-    return (target, propertyKey) => {
-        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(dynamic_methods_key_constant_1.DYNAMIC_METHODS_KEY, methods, target);
-    };
-}