@adaptic/backend-legacy 0.0.70 → 0.0.72

package/middleware/soft-delete.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Soft Delete Utilities
+ *
+ * Provides utilities for soft-delete behavior on critical models.
+ * Instead of removing records from the database, a `deletedAt` timestamp
+ * is set, and query helpers filter out soft-deleted records by default.
+ *
+ * Models with soft delete support: User, BrokerageAccount, Trade, Action
+ *
+ * Usage patterns:
+ * 1. Use `softDeleteFilter()` in where clauses to exclude deleted records
+ * 2. Use `softDeleteRecord()` to soft-delete a record (set deletedAt)
+ * 3. Use `hardDelete()` for permanent administrative deletion
+ * 4. Pass `includeDeleted: true` to admin queries to see all records
+ *
+ * Note: Prisma 6 removed the $use() middleware API. Soft delete behavior
+ * is implemented via utility functions called from resolvers and services.
+ */
+/**
+ * Models that support soft deletion via the deletedAt field.
+ * Only these models have the deletedAt column in the database.
+ */
+declare const SOFT_DELETE_MODELS: Set<string>;
+/**
+ * Returns a where clause filter that excludes soft-deleted records.
+ * Can be spread into any Prisma where clause for soft-delete-aware queries.
+ *
+ * @param includeDeleted - When true, returns an empty filter (includes deleted records)
+ * @returns An object to spread into a Prisma where clause
+ *
+ * @example
+ * ```typescript
+ * // Exclude soft-deleted users (default)
+ * const users = await prisma.user.findMany({
+ *   where: { role: 'USER', ...softDeleteFilter() },
+ * });
+ *
+ * // Include soft-deleted users (admin query)
+ * const allUsers = await prisma.user.findMany({
+ *   where: { role: 'USER', ...softDeleteFilter(true) },
+ * });
+ * ```
+ */
+declare function softDeleteFilter(includeDeleted?: boolean): {
+    deletedAt?: null;
+};
+/**
+ * Returns a where clause filter for finding only soft-deleted records.
+ * Useful for admin interfaces that need to list deleted records for restoration.
+ *
+ * @returns An object to spread into a Prisma where clause
+ *
+ * @example
+ * ```typescript
+ * // Find only soft-deleted users
+ * const deletedUsers = await prisma.user.findMany({
+ *   where: { ...deletedOnlyFilter() },
+ * });
+ * ```
+ */
+declare function deletedOnlyFilter(): {
+    deletedAt: {
+        not: null;
+    };
+};
+/**
+ * Checks whether a given model supports soft deletion.
+ *
+ * @param modelName - The Prisma model name (PascalCase)
+ * @returns True if the model has a deletedAt field
+ */
+declare function isSoftDeleteModel(modelName: string): boolean;
+/** Minimal Prisma delegate interface for soft-delete operations */
+interface PrismaModelDelegate {
+    update: (args: {
+        where: {
+            id: string;
+        };
+        data: {
+            deletedAt: Date;
+        };
+    }) => Promise<unknown>;
+}
+/**
+ * Soft-deletes a record by setting its deletedAt timestamp.
+ * This is the recommended way to "delete" records in soft-delete-enabled models.
+ *
+ * @param delegate - The Prisma model delegate (e.g., prisma.user)
+ * @param id - The record ID to soft-delete
+ * @param modelName - The model name for logging purposes
+ * @returns The updated record
+ *
+ * @example
+ * ```typescript
+ * // Soft-delete a user
+ * await softDeleteRecord(prisma.user, 'user-123', 'User');
+ * ```
+ */
+declare function softDeleteRecord(delegate: PrismaModelDelegate, id: string, modelName: string): Promise<unknown>;
+/** Minimal Prisma delegate interface for restore operations */
+interface PrismaRestoreDelegate {
+    update: (args: {
+        where: {
+            id: string;
+        };
+        data: {
+            deletedAt: null;
+        };
+    }) => Promise<unknown>;
+}
+/**
+ * Restores a soft-deleted record by clearing its deletedAt timestamp.
+ *
+ * @param delegate - The Prisma model delegate (e.g., prisma.user)
+ * @param id - The record ID to restore
+ * @param modelName - The model name for logging purposes
+ * @returns The updated record
+ *
+ * @example
+ * ```typescript
+ * // Restore a soft-deleted user
+ * await restoreRecord(prisma.user, 'user-123', 'User');
+ * ```
+ */
+declare function restoreRecord(delegate: PrismaRestoreDelegate, id: string, modelName: string): Promise<unknown>;
+/**
+ * Permanently deletes a record from the database.
+ * This bypasses soft delete and removes the row entirely.
+ * Should only be used for administrative cleanup operations.
+ *
+ * @param prisma - The Prisma client instance (with $executeRawUnsafe)
+ * @param model - The model name (PascalCase)
+ * @param id - The record ID to permanently delete
+ * @returns The number of rows deleted
+ *
+ * @example
+ * ```typescript
+ * // Permanently delete a soft-deleted user
+ * const deleted = await hardDelete(prisma, 'User', 'user-123');
+ * ```
+ */
+declare function hardDelete(prisma: {
+    $executeRawUnsafe: (query: string, ...values: unknown[]) => Promise<number>;
+}, model: string, id: string): Promise<number>;
+export { SOFT_DELETE_MODELS, softDeleteFilter, deletedOnlyFilter, isSoftDeleteModel, softDeleteRecord, restoreRecord, hardDelete, };
+//# sourceMappingURL=soft-delete.d.ts.map

package/middleware/soft-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../../src/middleware/soft-delete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH;;;GAGG;AACH,QAAA,MAAM,kBAAkB,aAKtB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iBAAS,gBAAgB,CAAC,cAAc,UAAQ,GAAG;IAAE,SAAS,CAAC,EAAE,IAAI,CAAA;CAAE,CAKtE;AAED;;;;;;;;;;;;;GAaG;AACH,iBAAS,iBAAiB,IAAI;IAAE,SAAS,EAAE;QAAE,GAAG,EAAE,IAAI,CAAA;KAAE,CAAA;CAAE,CAEzD;AAED;;;;;GAKG;AACH,iBAAS,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,mEAAmE;AACnE,UAAU,mBAAmB;IAC3B,MAAM,EAAE,CAAC,IAAI,EAAE;QACb,KAAK,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC;QACtB,IAAI,EAAE;YAAE,SAAS,EAAE,IAAI,CAAA;SAAE,CAAC;KAC3B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxB;AAED;;;;;;;;;;;;;;GAcG;AACH,iBAAe,gBAAgB,CAC7B,QAAQ,EAAE,mBAAmB,EAC7B,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CASlB;AAED,+DAA+D;AAC/D,UAAU,qBAAqB;IAC7B,MAAM,EAAE,CAAC,IAAI,EAAE;QACb,KAAK,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC;QACtB,IAAI,EAAE;YAAE,SAAS,EAAE,IAAI,CAAA;SAAE,CAAC;KAC3B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,iBAAe,aAAa,CAC1B,QAAQ,EAAE,qBAAqB,EAC/B,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CASlB;AAaD;;;;;;;;;;;;;;;GAeG;AACH,iBAAe,UAAU,CACvB,MAAM,EAAE;IACN,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7E,EACD,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,MAAM,CAAC,CAWjB;AAED,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,UAAU,GACX,CAAC"}

package/middleware/soft-delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"soft-delete.js","sourceRoot":"","sources":["../../src/middleware/soft-delete.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAiMD,4CAAgB;AAChB,8CAAiB;AACjB,8CAAiB;AACjB,4CAAgB;AAChB,sCAAa;AACb,gCAAU;AApMZ,4CAAyC;AAEzC;;;GAGG;AACH,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,MAAM;IACN,kBAAkB;IAClB,OAAO;IACP,QAAQ;CACT,CAAC,CAAC;AAmLD,gDAAkB;AAjLpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAS,gBAAgB,CAAC,cAAc,GAAG,KAAK;IAC9C,IAAI,cAAc,EAAE,CAAC;QACnB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,iBAAiB;IACxB,OAAO,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC;AACtC,CAAC;AAED;;;;;GAKG;AACH,SAAS,iBAAiB,CAAC,SAAiB;IAC1C,OAAO,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAC3C,CAAC;AAUD;;;;;;;;;;;;;;GAcG;AACH,KAAK,UAAU,gBAAgB,CAC7B,QAA6B,EAC7B,EAAU,EACV,SAAiB;IAEjB,eAAM,CAAC,IAAI,CAAC,0CAA0C,EAAE;QACtD,KAAK,EAAE,SAAS;QAChB,EAAE;KACH,CAAC,CAAC;IACH,OAAO,QAAQ,CAAC,MAAM,CAAC;QACrB,KAAK,EAAE,EAAE,EAAE,EAAE;QACb,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE;KAChC,CAAC,CAAC;AACL,CAAC;AAUD;;;;;;;;;;;;;GAaG;AACH,KAAK,UAAU,aAAa,CAC1B,QAA+B,EAC/B,EAAU,EACV,SAAiB;IAEjB,eAAM,CAAC,IAAI,CAAC,oDAAoD,EAAE;QAChE,KAAK,EAAE,SAAS;QAChB,EAAE;KACH,CAAC,CAAC;IACH,OAAO,QAAQ,CAAC,MAAM,CAAC;QACrB,KAAK,EAAE,EAAE,EAAE,EAAE;QACb,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE;KAC1B,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,cAAc,GAA2B;IAC7C,IAAI,EAAE,OAAO;IACb,gBAAgB,EAAE,oBAAoB;IACtC,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,SAAS;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,KAAK,UAAU,UAAU,CACvB,MAEC,EACD,KAAa,EACb,EAAU;IAEV,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACxC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,gCAAgC,CAAC,CAAC;IACnE,CAAC;IAED,eAAM,CAAC,IAAI,CAAC,0CAA0C,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;IACvE,OAAO,MAAM,CAAC,iBAAiB,CAC7B,gBAAgB,SAAS,mBAAmB,EAC5C,EAAE,CACH,CAAC;AACJ,CAAC"}

package/middleware/types.cjs

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Type definitions for validation middleware
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidationError = isValidationError;
+const graphql_1 = require("graphql");
+/**
+ * Type guard to check if an error is a ValidationError
+ */
+function isValidationError(error) {
+    var _a;
+    return (error instanceof graphql_1.GraphQLError &&
+        ((_a = error.extensions) === null || _a === void 0 ? void 0 : _a.code) === 'BAD_USER_INPUT' &&
+        'validationErrors' in (error.extensions || {}));
+}
+//# sourceMappingURL=types.js.map

package/middleware/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Type definitions for validation middleware
+ */
+import { GraphQLError } from 'graphql';
+import { ValidationErrorDetail } from './input-validator';
+/**
+ * Configuration options for the validation plugin
+ */
+export interface ValidationPluginOptions {
+    /**
+     * Whether to skip validation for specific operations
+     */
+    skipOperations?: string[];
+    /**
+     * Custom validation rules to add to the default set
+     */
+    customRules?: FieldValidationRule[];
+    /**
+     * Whether to log validation errors for debugging
+     */
+    debug?: boolean;
+}
+/**
+ * Field validation rule definition
+ */
+export interface FieldValidationRule {
+    /**
+     * Regular expression pattern to match field names
+     */
+    pattern: RegExp;
+    /**
+     * Validation function to apply to matching fields
+     * @param value - The field value to validate
+     * @param fieldName - The name of the field being validated
+     */
+    validator: (value: unknown, fieldName: string) => void;
+    /**
+     * Human-readable description of what this rule validates
+     */
+    description: string;
+}
+/**
+ * GraphQL operation context with validation information
+ */
+export interface ValidationContext {
+    /**
+     * The GraphQL operation being executed
+     */
+    operation: {
+        operation: 'query' | 'mutation' | 'subscription';
+        name?: {
+            value: string;
+        };
+    };
+    /**
+     * The request variables
+     */
+    request: {
+        variables?: Record<string, unknown>;
+    };
+}
+/**
+ * Result of a validation check
+ */
+export interface ValidationResult {
+    /**
+     * Whether validation passed
+     */
+    valid: boolean;
+    /**
+     * Array of validation errors (empty if valid)
+     */
+    errors: ValidationErrorDetail[];
+}
+/**
+ * Type guard to check if an error is a ValidationError
+ */
+export declare function isValidationError(error: unknown): error is GraphQLError;
+/**
+ * Type-safe validator function signature
+ */
+export type Validator<T> = (value: T, fieldName: string) => void;
+/**
+ * Validation constraint types
+ */
+export type ValidationConstraint = 'isNumber' | 'isString' | 'range' | 'positive' | 'negative' | 'notEmpty' | 'email' | 'url' | 'minimum' | 'maximum' | 'sum' | 'comparison' | 'userLimit' | 'maxLength' | 'custom';
+//# sourceMappingURL=types.d.ts.map

package/middleware/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/middleware/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAE1B;;OAEG;IACH,WAAW,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAEpC;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAEvD;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,SAAS,EAAE;QACT,SAAS,EAAE,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;QACjD,IAAI,CAAC,EAAE;YACL,KAAK,EAAE,MAAM,CAAC;SACf,CAAC;KACH,CAAC;IAEF;;OAEG;IACH,OAAO,EAAE;QACP,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACrC,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAMvE;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B,UAAU,GACV,UAAU,GACV,OAAO,GACP,UAAU,GACV,UAAU,GACV,UAAU,GACV,OAAO,GACP,KAAK,GACL,SAAS,GACT,SAAS,GACT,KAAK,GACL,YAAY,GACZ,WAAW,GACX,WAAW,GACX,QAAQ,CAAC"}

package/middleware/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/middleware/types.ts"],"names":[],"mappings":";AAAA;;GAEG;;AAuFH,8CAMC;AA3FD,qCAAuC;AAkFvC;;GAEG;AACH,SAAgB,iBAAiB,CAAC,KAAc;;IAC9C,OAAO,CACL,KAAK,YAAY,sBAAY;QAC7B,CAAA,MAAA,KAAK,CAAC,UAAU,0CAAE,IAAI,MAAK,gBAAgB;QAC3C,kBAAkB,IAAI,CAAC,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC,CAC/C,CAAC;AACJ,CAAC"}

package/middleware/validation-examples.cjs

@@ -0,0 +1,403 @@
+"use strict";
+/**
+ * Example usage of validation functions in custom resolvers
+ *
+ * This file demonstrates how to use the validation utilities
+ * in custom resolver implementations.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomValidators = exports.ValidationExamplesResolver = void 0;
+const TypeGraphQL = __importStar(require("type-graphql"));
+const input_validator_1 = require("./input-validator.cjs");
+/**
+ * Example: Portfolio allocation input with validation
+ */
+let PortfolioAllocationInput = class PortfolioAllocationInput {
+};
+__decorate([
+    TypeGraphQL.Field(() => TypeGraphQL.Float),
+    __metadata("design:type", Number)
+], PortfolioAllocationInput.prototype, "equitiesPct", void 0);
+__decorate([
+    TypeGraphQL.Field(() => TypeGraphQL.Float),
+    __metadata("design:type", Number)
+], PortfolioAllocationInput.prototype, "optionsPct", void 0);
+__decorate([
+    TypeGraphQL.Field(() => TypeGraphQL.Float),
+    __metadata("design:type", Number)
+], PortfolioAllocationInput.prototype, "cryptoPct", void 0);
+__decorate([
+    TypeGraphQL.Field(() => String),
+    __metadata("design:type", String)
+], PortfolioAllocationInput.prototype, "portfolioName", void 0);
+PortfolioAllocationInput = __decorate([
+    TypeGraphQL.InputType()
+], PortfolioAllocationInput);
+/**
+ * Example: Trade configuration input with validation
+ */
+let TradeConfigurationInput = class TradeConfigurationInput {
+};
+__decorate([
+    TypeGraphQL.Field(() => TypeGraphQL.Float),
+    __metadata("design:type", Number)
+], TradeConfigurationInput.prototype, "tradeAllocationPct", void 0);
+__decorate([
+    TypeGraphQL.Field(() => TypeGraphQL.Float),
+    __metadata("design:type", Number)
+], TradeConfigurationInput.prototype, "minPercentageChange", void 0);
+__decorate([
+    TypeGraphQL.Field(() => TypeGraphQL.Float),
+    __metadata("design:type", Number)
+], TradeConfigurationInput.prototype, "volumeThreshold", void 0);
+__decorate([
+    TypeGraphQL.Field(() => TypeGraphQL.Int),
+    __metadata("design:type", Number)
+], TradeConfigurationInput.prototype, "quantity", void 0);
+TradeConfigurationInput = __decorate([
+    TypeGraphQL.InputType()
+], TradeConfigurationInput);
+/**
+ * Example resolver demonstrating manual validation in custom resolvers
+ *
+ * Note: With the validation plugin enabled, these validations happen
+ * automatically. This example shows how to add ADDITIONAL custom validation
+ * logic beyond the automatic pattern-based validation.
+ */
+let ValidationExamplesResolver = class ValidationExamplesResolver {
+    /**
+     * Example 1: Basic field validation in a mutation
+     */
+    async updatePortfolioAllocation(input) {
+        // The validation plugin will automatically validate:
+        // - equitiesPct (0-100)
+        // - optionsPct (0-100)
+        // - cryptoPct (0-100)
+        // - portfolioName (non-empty)
+        // Add custom business logic validation
+        const totalAllocation = input.equitiesPct + input.optionsPct + input.cryptoPct;
+        if (totalAllocation !== 100) {
+            throw new input_validator_1.ValidationError('Total allocation must equal 100%', [
+                {
+                    field: 'totalAllocation',
+                    value: totalAllocation,
+                    message: 'Sum of equitiesPct, optionsPct, and cryptoPct must equal 100',
+                    constraint: 'sum',
+                },
+            ]);
+        }
+        // Resolver implementation...
+        return true;
+    }
+    /**
+     * Example 2: Batch validation using validateFields
+     */
+    async updateTradeConfiguration(input) {
+        // The validation plugin handles basic validation automatically.
+        // Use validateFields for additional custom validations.
+        try {
+            (0, input_validator_1.validateFields)([
+                // Custom validation: minPercentageChange should be less than tradeAllocationPct
+                () => {
+                    if (input.minPercentageChange >= input.tradeAllocationPct) {
+                        throw new input_validator_1.ValidationError('Invalid configuration', [
+                            {
+                                field: 'minPercentageChange',
+                                value: input.minPercentageChange,
+                                message: 'Must be less than tradeAllocationPct',
+                                constraint: 'comparison',
+                            },
+                        ]);
+                    }
+                },
+            ]);
+        }
+        catch (error) {
+            // ValidationError is automatically formatted by Apollo Server
+            throw error;
+        }
+        // Resolver implementation...
+        return true;
+    }
+    /**
+     * Example 3: Conditional validation based on business logic
+     */
+    async createTrade(quantity, isPremiumUser) {
+        // Basic validation happens automatically via plugin
+        // Add conditional validation based on user type
+        if (!isPremiumUser && quantity > 1000) {
+            throw new input_validator_1.ValidationError('Quantity limit exceeded', [
+                {
+                    field: 'quantity',
+                    value: quantity,
+                    message: 'Non-premium users are limited to 1000 units per trade',
+                    constraint: 'userLimit',
+                },
+            ]);
+        }
+        // Resolver implementation...
+        return true;
+    }
+    /**
+     * Example 4: Validating related fields together
+     */
+    async setTradingThresholds(minPrice, maxPrice, targetPrice) {
+        // Automatic validation ensures all are positive numbers
+        // Custom validation for related fields
+        if (minPrice >= maxPrice) {
+            throw new input_validator_1.ValidationError('Invalid price range', [
+                {
+                    field: 'minPrice',
+                    value: minPrice,
+                    message: 'minPrice must be less than maxPrice',
+                    constraint: 'range',
+                },
+            ]);
+        }
+        if (targetPrice < minPrice || targetPrice > maxPrice) {
+            throw new input_validator_1.ValidationError('Invalid target price', [
+                {
+                    field: 'targetPrice',
+                    value: targetPrice,
+                    message: 'targetPrice must be between minPrice and maxPrice',
+                    constraint: 'range',
+                },
+            ]);
+        }
+        // Resolver implementation...
+        return true;
+    }
+    /**
+     * Example 5: Using manual validation for non-standard field names
+     */
+    async updateCustomSettings(customAllocation, customQuantity) {
+        // These field names don't match the automatic validation patterns,
+        // so we validate manually
+        (0, input_validator_1.validatePercentage)(customAllocation, 'customAllocation');
+        (0, input_validator_1.validatePositiveNumber)(customQuantity, 'customQuantity');
+        // Resolver implementation...
+        return true;
+    }
+    /**
+     * Example 6: Accumulating multiple validation errors
+     */
+    async bulkUpdateAllocations(allocations) {
+        // Validate each allocation
+        // The plugin validates each item's fields automatically
+        // Add custom cross-item validation
+        const totalItems = allocations.length;
+        if (totalItems === 0) {
+            throw new input_validator_1.ValidationError('Empty allocations array', [
+                {
+                    field: 'allocations',
+                    value: totalItems,
+                    message: 'Must provide at least one allocation',
+                    constraint: 'notEmpty',
+                },
+            ]);
+        }
+        if (totalItems > 100) {
+            throw new input_validator_1.ValidationError('Too many allocations', [
+                {
+                    field: 'allocations',
+                    value: totalItems,
+                    message: 'Maximum 100 allocations per request',
+                    constraint: 'maxLength',
+                },
+            ]);
+        }
+        // Resolver implementation...
+        return true;
+    }
+};
+exports.ValidationExamplesResolver = ValidationExamplesResolver;
+__decorate([
+    TypeGraphQL.Mutation(() => Boolean),
+    __param(0, TypeGraphQL.Arg('input')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PortfolioAllocationInput]),
+    __metadata("design:returntype", Promise)
+], ValidationExamplesResolver.prototype, "updatePortfolioAllocation", null);
+__decorate([
+    TypeGraphQL.Mutation(() => Boolean),
+    __param(0, TypeGraphQL.Arg('input')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [TradeConfigurationInput]),
+    __metadata("design:returntype", Promise)
+], ValidationExamplesResolver.prototype, "updateTradeConfiguration", null);
+__decorate([
+    TypeGraphQL.Mutation(() => Boolean),
+    __param(0, TypeGraphQL.Arg('quantity')),
+    __param(1, TypeGraphQL.Arg('isPremiumUser')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Boolean]),
+    __metadata("design:returntype", Promise)
+], ValidationExamplesResolver.prototype, "createTrade", null);
+__decorate([
+    TypeGraphQL.Mutation(() => Boolean),
+    __param(0, TypeGraphQL.Arg('minPrice')),
+    __param(1, TypeGraphQL.Arg('maxPrice')),
+    __param(2, TypeGraphQL.Arg('targetPrice')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number, Number]),
+    __metadata("design:returntype", Promise)
+], ValidationExamplesResolver.prototype, "setTradingThresholds", null);
+__decorate([
+    TypeGraphQL.Mutation(() => Boolean),
+    __param(0, TypeGraphQL.Arg('customAllocation')),
+    __param(1, TypeGraphQL.Arg('customQuantity')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", Promise)
+], ValidationExamplesResolver.prototype, "updateCustomSettings", null);
+__decorate([
+    TypeGraphQL.Mutation(() => Boolean),
+    __param(0, TypeGraphQL.Arg('allocations', () => [PortfolioAllocationInput])),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], ValidationExamplesResolver.prototype, "bulkUpdateAllocations", null);
+exports.ValidationExamplesResolver = ValidationExamplesResolver = __decorate([
+    TypeGraphQL.Resolver()
+], ValidationExamplesResolver);
+/**
+ * Example: Reusable validation functions for complex business rules
+ */
+class CustomValidators {
+    /**
+     * Validates that portfolio allocations sum to 100%
+     */
+    static validatePortfolioAllocationSum(equities, options, crypto) {
+        const total = equities + options + crypto;
+        if (Math.abs(total - 100) > 0.01) {
+            // Allow small floating point errors
+            throw new input_validator_1.ValidationError('Invalid portfolio allocation', [
+                {
+                    field: 'totalAllocation',
+                    value: total,
+                    message: 'Total allocation must equal 100%',
+                    constraint: 'sum',
+                },
+            ]);
+        }
+    }
+    /**
+     * Validates that a price is within acceptable market bounds
+     */
+    static validateMarketPrice(price, fieldName) {
+        (0, input_validator_1.validatePositiveNumber)(price, fieldName);
+        // Additional market-specific validation
+        if (price > 1000000) {
+            throw new input_validator_1.ValidationError('Price exceeds maximum', [
+                {
+                    field: fieldName,
+                    value: price,
+                    message: 'Price cannot exceed $1,000,000',
+                    constraint: 'maximum',
+                },
+            ]);
+        }
+    }
+    /**
+     * Validates Greeks values are within expected ranges
+     */
+    static validateGreeks(delta, gamma, theta, vega) {
+        (0, input_validator_1.validateFields)([
+            () => {
+                if (delta < -1 || delta > 1) {
+                    throw new input_validator_1.ValidationError('Invalid delta', [
+                        {
+                            field: 'delta',
+                            value: delta,
+                            message: 'Delta must be between -1 and 1',
+                            constraint: 'range',
+                        },
+                    ]);
+                }
+            },
+            () => {
+                if (gamma < 0) {
+                    throw new input_validator_1.ValidationError('Invalid gamma', [
+                        {
+                            field: 'gamma',
+                            value: gamma,
+                            message: 'Gamma must be non-negative',
+                            constraint: 'minimum',
+                        },
+                    ]);
+                }
+            },
+            () => {
+                if (theta > 0) {
+                    throw new input_validator_1.ValidationError('Invalid theta', [
+                        {
+                            field: 'theta',
+                            value: theta,
+                            message: 'Theta must be negative or zero',
+                            constraint: 'maximum',
+                        },
+                    ]);
+                }
+            },
+            () => {
+                if (vega < 0) {
+                    throw new input_validator_1.ValidationError('Invalid vega', [
+                        {
+                            field: 'vega',
+                            value: vega,
+                            message: 'Vega must be non-negative',
+                            constraint: 'minimum',
+                        },
+                    ]);
+                }
+            },
+        ]);
+    }
+}
+exports.CustomValidators = CustomValidators;
+//# sourceMappingURL=validation-examples.js.map