@cosmneo/onion-lasagna 0.3.0 → 0.4.0

package/dist/graphql/index.cjs

@@ -0,0 +1,1148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/presentation/graphql/index.ts
+var graphql_exports = {};
+__export(graphql_exports, {
+  collectFields: () => collectFields,
+  defineGraphQLSchema: () => defineGraphQLSchema,
+  defineMutation: () => defineMutation,
+  defineQuery: () => defineQuery,
+  defineSubscription: () => defineSubscription,
+  generateFieldId: () => generateFieldId,
+  generateGraphQLSDL: () => generateGraphQLSDL,
+  getGraphQLErrorCode: () => getGraphQLErrorCode,
+  graphqlRoutes: () => graphqlRoutes,
+  isFieldDefinition: () => isFieldDefinition,
+  isSchemaDefinition: () => isSchemaDefinition,
+  isSimpleGraphQLHandlerConfig: () => isSimpleGraphQLHandlerConfig,
+  mapErrorToGraphQLError: () => mapErrorToGraphQLError,
+  mergeGraphQLSchemas: () => mergeGraphQLSchemas,
+  shouldMaskGraphQLError: () => shouldMaskGraphQLError
+});
+module.exports = __toCommonJS(graphql_exports);
+
+// src/presentation/graphql/field/define-field.ts
+function createFieldDefinition(operation, input) {
+  const definition = {
+    operation,
+    input: input.input ?? void 0,
+    output: input.output ?? void 0,
+    context: input.context ?? void 0,
+    docs: {
+      summary: input.docs?.summary,
+      description: input.docs?.description,
+      tags: input.docs?.tags,
+      deprecated: input.docs?.deprecated ?? false,
+      deprecationReason: input.docs?.deprecationReason
+    },
+    _isGraphQLField: true,
+    _types: void 0
+  };
+  return Object.freeze(definition);
+}
+function defineQuery(config = {}) {
+  return createFieldDefinition("query", config);
+}
+function defineMutation(config = {}) {
+  return createFieldDefinition("mutation", config);
+}
+function defineSubscription(config = {}) {
+  return createFieldDefinition("subscription", config);
+}
+
+// src/presentation/graphql/field/types/schema-definition.type.ts
+function isFieldDefinition(value) {
+  return typeof value === "object" && value !== null && "_isGraphQLField" in value && value._isGraphQLField === true;
+}
+function isSchemaDefinition(value) {
+  return typeof value === "object" && value !== null && "_isGraphQLSchema" in value && value._isGraphQLSchema === true;
+}
+function collectFields(config, basePath = "") {
+  const fields = [];
+  for (const [key, value] of Object.entries(config)) {
+    const fullKey = basePath ? `${basePath}.${key}` : key;
+    if (isFieldDefinition(value)) {
+      fields.push({ key: fullKey, field: value });
+    } else if (isSchemaDefinition(value)) {
+      fields.push(...collectFields(value.fields, fullKey));
+    } else if (typeof value === "object" && value !== null) {
+      fields.push(...collectFields(value, fullKey));
+    }
+  }
+  return fields;
+}
+
+// src/presentation/graphql/field/define-schema.ts
+function defineGraphQLSchema(fields, options) {
+  const defaults = options?.defaults;
+  const processedFields = defaults?.context || defaults?.tags ? applySchemaDefaults(fields, defaults) : fields;
+  const definition = {
+    fields: processedFields,
+    defaults,
+    _isGraphQLSchema: true
+  };
+  return deepFreeze(definition);
+}
+function applySchemaDefaults(config, defaults) {
+  const result = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (isFieldDefinition(value)) {
+      result[key] = applyDefaultsToField(value, defaults);
+    } else if (isSchemaDefinition(value)) {
+      result[key] = {
+        ...value,
+        fields: applySchemaDefaults(value.fields, defaults)
+      };
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = applySchemaDefaults(value, defaults);
+    }
+  }
+  return result;
+}
+function applyDefaultsToField(field, defaults) {
+  const needsContext = defaults.context && !field.context;
+  const needsTags = defaults.tags && defaults.tags.length > 0;
+  if (!needsContext && !needsTags) return field;
+  return Object.freeze({
+    ...field,
+    context: field.context ?? defaults.context ?? void 0,
+    docs: {
+      ...field.docs,
+      tags: mergeTags(defaults.tags, field.docs.tags)
+    }
+  });
+}
+function mergeTags(schemaTags, fieldTags) {
+  if (!schemaTags || schemaTags.length === 0) return fieldTags;
+  if (!fieldTags || fieldTags.length === 0) return schemaTags;
+  const merged = [...schemaTags];
+  for (const tag of fieldTags) {
+    if (!merged.includes(tag)) {
+      merged.push(tag);
+    }
+  }
+  return merged;
+}
+function deepFreeze(obj) {
+  const propNames = Object.getOwnPropertyNames(obj);
+  for (const name of propNames) {
+    const value = obj[name];
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return Object.freeze(obj);
+}
+function extractFields(input) {
+  return isSchemaDefinition(input) ? input.fields : input;
+}
+function isSubGroup(value) {
+  return typeof value === "object" && value !== null && !isFieldDefinition(value) && !isSchemaDefinition(value);
+}
+function deepMergeConfigs(a, b) {
+  const result = { ...a };
+  for (const key of Object.keys(b)) {
+    const aVal = result[key];
+    const bVal = b[key];
+    if (isSubGroup(aVal) && isSubGroup(bVal)) {
+      result[key] = deepMergeConfigs(aVal, bVal);
+    } else {
+      result[key] = bVal;
+    }
+  }
+  return result;
+}
+function mergeGraphQLSchemas(...schemas) {
+  const merged = schemas.map(extractFields).reduce(deepMergeConfigs);
+  return defineGraphQLSchema(merged);
+}
+
+// src/presentation/graphql/field/utils.ts
+function generateFieldId(key) {
+  return key.split(".").map(
+    (segment, index) => index === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1)
+  ).join("");
+}
+
+// src/global/exceptions/coded-error.error.ts
+var CodedError = class extends Error {
+  /** Machine-readable error code for programmatic handling. */
+  code;
+  /**
+   * Creates a new CodedError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error message
+   * @param options.code - Machine-readable error code from ErrorCodes registry or custom string
+   * @param options.cause - Optional underlying error that caused this error
+   */
+  constructor({
+    message,
+    code,
+    cause
+  }) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    if (cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: cause,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+    }
+  }
+  /**
+   * Factory method to create a typed error from a caught error.
+   *
+   * Subclasses should override this to provide proper error transformation.
+   * Designed for use with {@link wrapErrorAsync} and {@link wrapError}.
+   *
+   * @param _cause - The original caught error
+   * @returns A new CodedError instance
+   * @throws {Error} If not overridden by subclass
+   *
+   * @example
+   * ```typescript
+   * class NotFoundError extends UseCaseError {
+   *   static override fromError(cause: unknown): NotFoundError {
+   *     return new NotFoundError({
+   *       message: 'Resource not found',
+   *       cause,
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  static fromError(_cause) {
+    throw new Error(`${this.name}.fromError() must be implemented by subclass`);
+  }
+};
+
+// src/global/exceptions/error-codes.const.ts
+var ErrorCodes = {
+  /**
+   * Domain layer error codes.
+   * Used for business rule violations and invariant failures.
+   */
+  Domain: {
+    /** Generic domain error */
+    DOMAIN_ERROR: "DOMAIN_ERROR",
+    /** Business invariant was violated */
+    INVARIANT_VIOLATION: "INVARIANT_VIOLATION",
+    /** Aggregate was partially loaded (missing required relations) */
+    PARTIAL_LOAD: "PARTIAL_LOAD"
+  },
+  /**
+   * Application layer (use case) error codes.
+   * Used for orchestration failures and business operation errors.
+   */
+  App: {
+    /** Generic use case error */
+    USE_CASE_ERROR: "USE_CASE_ERROR",
+    /** Requested resource was not found */
+    NOT_FOUND: "NOT_FOUND",
+    /** Resource state conflict (e.g., duplicate, already exists) */
+    CONFLICT: "CONFLICT",
+    /** Request is valid but cannot be processed due to business rules */
+    UNPROCESSABLE: "UNPROCESSABLE",
+    /** Authorization denied - user lacks permission for this operation */
+    FORBIDDEN: "FORBIDDEN",
+    /** Authentication required or invalid - user is not authenticated */
+    UNAUTHORIZED: "UNAUTHORIZED"
+  },
+  /**
+   * Infrastructure layer error codes.
+   * Used for data access, external services, and I/O failures.
+   */
+  Infra: {
+    /** Generic infrastructure error */
+    INFRA_ERROR: "INFRA_ERROR",
+    /** Database operation failed */
+    DB_ERROR: "DB_ERROR",
+    /** Network connectivity or communication error */
+    NETWORK_ERROR: "NETWORK_ERROR",
+    /** Operation timed out */
+    TIMEOUT_ERROR: "TIMEOUT_ERROR",
+    /** External/third-party service error */
+    EXTERNAL_SERVICE_ERROR: "EXTERNAL_SERVICE_ERROR"
+  },
+  /**
+   * Presentation layer error codes.
+   * Used for controller, request handling, and authorization errors.
+   */
+  Presentation: {
+    /** Generic controller error */
+    CONTROLLER_ERROR: "CONTROLLER_ERROR",
+    /** Request denied due to authorization failure */
+    ACCESS_DENIED: "ACCESS_DENIED",
+    /** Request validation failed (malformed input) */
+    INVALID_REQUEST: "INVALID_REQUEST"
+  },
+  /**
+   * Global/cross-cutting error codes.
+   * Used for validation and other cross-layer concerns.
+   */
+  Global: {
+    /** Object/schema validation failed */
+    OBJECT_VALIDATION_ERROR: "OBJECT_VALIDATION_ERROR"
+  }
+};
+
+// src/global/exceptions/object-validation.error.ts
+var ObjectValidationError = class _ObjectValidationError extends CodedError {
+  /**
+   * Array of field-level validation errors.
+   *
+   * Each entry contains:
+   * - `field`: Dot-notation path to the invalid field (e.g., 'user.email')
+   * - `message`: Human-readable validation failure message
+   */
+  validationErrors;
+  /**
+   * Creates a new ObjectValidationError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable summary message
+   * @param options.code - Machine-readable error code (default: 'OBJECT_VALIDATION_ERROR')
+   * @param options.cause - Optional underlying error from validation library
+   * @param options.validationErrors - Array of field-level validation errors
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Global.OBJECT_VALIDATION_ERROR,
+    cause,
+    validationErrors
+  }) {
+    super({ message, code, cause });
+    this.validationErrors = validationErrors;
+  }
+  /**
+   * Creates an ObjectValidationError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ObjectValidationError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ObjectValidationError({
+      message: cause instanceof Error ? cause.message : "Validation failed",
+      cause,
+      validationErrors: []
+    });
+  }
+};
+
+// src/domain/exceptions/domain.error.ts
+var DomainError = class _DomainError extends CodedError {
+  /**
+   * Creates a new DomainError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'DOMAIN_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Domain.DOMAIN_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a DomainError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new DomainError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _DomainError({
+      message: cause instanceof Error ? cause.message : "Domain error",
+      cause
+    });
+  }
+};
+
+// src/app/exceptions/use-case.error.ts
+var UseCaseError = class _UseCaseError extends CodedError {
+  /**
+   * Creates a new UseCaseError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'USE_CASE_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.USE_CASE_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a UseCaseError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new UseCaseError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _UseCaseError({
+      message: cause instanceof Error ? cause.message : "Use case error",
+      cause
+    });
+  }
+};
+
+// src/app/exceptions/not-found.error.ts
+var NotFoundError = class _NotFoundError extends UseCaseError {
+  /**
+   * Creates a new NotFoundError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of what was not found
+   * @param options.code - Machine-readable error code (default: 'NOT_FOUND')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.NOT_FOUND,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a NotFoundError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new NotFoundError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _NotFoundError({
+      message: cause instanceof Error ? cause.message : "Resource not found",
+      cause
+    });
+  }
+};
+
+// src/app/exceptions/conflict.error.ts
+var ConflictError = class _ConflictError extends UseCaseError {
+  /**
+   * Creates a new ConflictError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of the conflict
+   * @param options.code - Machine-readable error code (default: 'CONFLICT')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.CONFLICT,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a ConflictError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ConflictError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ConflictError({
+      message: cause instanceof Error ? cause.message : "Conflict error",
+      cause
+    });
+  }
+};
+
+// src/app/exceptions/unprocessable.error.ts
+var UnprocessableError = class _UnprocessableError extends UseCaseError {
+  /**
+   * Creates a new UnprocessableError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why the request cannot be processed
+   * @param options.code - Machine-readable error code (default: 'UNPROCESSABLE')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.UNPROCESSABLE,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an UnprocessableError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new UnprocessableError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _UnprocessableError({
+      message: cause instanceof Error ? cause.message : "Unprocessable request",
+      cause
+    });
+  }
+};
+
+// src/app/exceptions/forbidden.error.ts
+var ForbiddenError = class _ForbiddenError extends UseCaseError {
+  /**
+   * Creates a new ForbiddenError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why authorization was denied
+   * @param options.code - Machine-readable error code (default: 'FORBIDDEN')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.FORBIDDEN,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a ForbiddenError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ForbiddenError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ForbiddenError({
+      message: cause instanceof Error ? cause.message : "Operation forbidden",
+      cause
+    });
+  }
+};
+
+// src/app/exceptions/unauthorized.error.ts
+var UnauthorizedError = class _UnauthorizedError extends UseCaseError {
+  /**
+   * Creates a new UnauthorizedError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why authentication failed
+   * @param options.code - Machine-readable error code (default: 'UNAUTHORIZED')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.UNAUTHORIZED,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an UnauthorizedError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new UnauthorizedError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _UnauthorizedError({
+      message: cause instanceof Error ? cause.message : "Authentication required",
+      cause
+    });
+  }
+};
+
+// src/infra/exceptions/infra.error.ts
+var InfraError = class _InfraError extends CodedError {
+  /**
+   * Creates a new InfraError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'INFRA_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Infra.INFRA_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an InfraError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new InfraError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _InfraError({
+      message: cause instanceof Error ? cause.message : "Infrastructure error",
+      cause
+    });
+  }
+};
+
+// src/presentation/exceptions/access-denied.error.ts
+var AccessDeniedError = class _AccessDeniedError extends CodedError {
+  /**
+   * Creates a new AccessDeniedError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why access was denied
+   * @param options.code - Machine-readable error code (default: 'ACCESS_DENIED')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Presentation.ACCESS_DENIED,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an AccessDeniedError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new AccessDeniedError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _AccessDeniedError({
+      message: cause instanceof Error ? cause.message : "Access denied",
+      cause
+    });
+  }
+};
+
+// src/presentation/http/shared/error-mapping.ts
+function isErrorType(error, typeName) {
+  if (!error || typeof error !== "object") return false;
+  const constructor = Object.prototype.hasOwnProperty.call(error, "constructor") ? error.constructor : Object.getPrototypeOf(error)?.constructor;
+  if (!constructor) return false;
+  const name = constructor.name;
+  return name === typeName || name === `_${typeName}`;
+}
+function hasValidationErrors(error) {
+  if (!error || typeof error !== "object") return false;
+  return "validationErrors" in error && Array.isArray(error.validationErrors);
+}
+
+// src/presentation/graphql/shared/error-mapping.ts
+var MASKED_ERROR = {
+  message: "An unexpected error occurred",
+  extensions: { code: "INTERNAL_ERROR" }
+};
+var INTERNAL_ERROR_TYPES = [
+  "DomainError",
+  "InfraError",
+  "ControllerError",
+  "NetworkError",
+  "PersistenceError",
+  "ExternalServiceError",
+  "InvariantViolationError"
+];
+function getGraphQLErrorCode(error) {
+  if (error instanceof ObjectValidationError) return "VALIDATION_ERROR";
+  if (error instanceof UnauthorizedError) return "FORBIDDEN";
+  if (error instanceof ForbiddenError) return "FORBIDDEN";
+  if (error instanceof AccessDeniedError) return "FORBIDDEN";
+  if (error instanceof NotFoundError) return "NOT_FOUND";
+  if (error instanceof ConflictError) return "CONFLICT";
+  if (error instanceof UnprocessableError) return "UNPROCESSABLE";
+  if (error instanceof UseCaseError) return "BAD_REQUEST";
+  if (isErrorType(error, "ObjectValidationError")) return "VALIDATION_ERROR";
+  if (isErrorType(error, "UnauthorizedError")) return "FORBIDDEN";
+  if (isErrorType(error, "ForbiddenError")) return "FORBIDDEN";
+  if (isErrorType(error, "AccessDeniedError")) return "FORBIDDEN";
+  if (isErrorType(error, "NotFoundError")) return "NOT_FOUND";
+  if (isErrorType(error, "ConflictError")) return "CONFLICT";
+  if (isErrorType(error, "UnprocessableError")) return "UNPROCESSABLE";
+  if (isErrorType(error, "UseCaseError")) return "BAD_REQUEST";
+  return "INTERNAL_ERROR";
+}
+function shouldMaskGraphQLError(error) {
+  if (error instanceof DomainError || error instanceof InfraError) {
+    return true;
+  }
+  for (const errorType of INTERNAL_ERROR_TYPES) {
+    if (isErrorType(error, errorType)) {
+      return true;
+    }
+  }
+  return false;
+}
+function mapErrorToGraphQLError(error) {
+  if (shouldMaskGraphQLError(error)) {
+    return MASKED_ERROR;
+  }
+  const code = getGraphQLErrorCode(error);
+  if (error instanceof ObjectValidationError) {
+    return buildValidationError(error.message, code, error.code, error.validationErrors);
+  }
+  if (isErrorType(error, "ObjectValidationError") && hasValidationErrors(error)) {
+    return buildValidationError(error.message, code, error.code, error.validationErrors);
+  }
+  if (error instanceof CodedError) {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  if (isErrorType(error, "CodedError")) {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  if (error && typeof error === "object" && "message" in error && "code" in error && typeof error.message === "string" && typeof error.code === "string") {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  return MASKED_ERROR;
+}
+function buildValidationError(message, code, originalCode, validationErrors) {
+  return {
+    message,
+    extensions: {
+      code,
+      originalCode,
+      validationErrors: validationErrors.map(
+        (e) => ({
+          field: e.field,
+          message: e.message
+        })
+      )
+    }
+  };
+}
+
+// src/presentation/graphql/server/types.ts
+function isSimpleGraphQLHandlerConfig(config) {
+  return "handler" in config && typeof config.handler === "function";
+}
+
+// src/presentation/graphql/server/create-graphql-routes.ts
+function createGraphQLRoutesInternal(schema, handlers, options) {
+  const config = isSchemaDefinition(schema) ? schema.fields : schema;
+  const collectedFields = collectFields(config);
+  const result = [];
+  const resolvedOptions = {
+    ...options,
+    validateInput: options?.validateInput ?? true,
+    validateOutput: options?.validateOutput ?? true,
+    allowPartial: options?.allowPartial ?? false
+  };
+  for (const { key, field } of collectedFields) {
+    const handlerConfig = handlers[key];
+    if (!handlerConfig) {
+      if (resolvedOptions.allowPartial) {
+        continue;
+      }
+      throw new Error(
+        `Missing handler for field "${key}". All fields must have a handler configuration.`
+      );
+    }
+    result.push(createFieldHandler(key, field, handlerConfig, resolvedOptions));
+  }
+  return result;
+}
+function createFieldHandler(key, field, config, options) {
+  const middleware = config.middleware ?? [];
+  const globalMiddleware = options?.middleware ?? [];
+  const allMiddleware = [...globalMiddleware, ...middleware];
+  const shouldValidateInput = options.validateInput ?? true;
+  const shouldValidateOutput = options.validateOutput ?? true;
+  return {
+    key,
+    operation: field.operation,
+    metadata: {
+      fieldId: generateFieldId(key),
+      description: field.docs.description,
+      tags: field.docs.tags,
+      deprecated: field.docs.deprecated,
+      deprecationReason: field.docs.deprecationReason
+    },
+    handler: async (rawArgs, rawContext) => {
+      const context = options?.createContext ? options.createContext(rawContext) : rawContext ?? { requestId: generateRequestId() };
+      let validatedContext = context;
+      if (field.context) {
+        const contextResult = validateContextData(field, context);
+        if (!contextResult.success) {
+          throw new UnauthorizedError({
+            message: "Authentication required"
+          });
+        }
+        validatedContext = contextResult.data;
+      }
+      let validatedInput = rawArgs;
+      if (shouldValidateInput && field.input) {
+        const inputResult = validateInputData(field, rawArgs);
+        if (!inputResult.success) {
+          const errors = inputResult.errors ?? [];
+          throw new ObjectValidationError({
+            message: "Input validation failed",
+            validationErrors: errors.map((e) => ({
+              field: e.path.join("."),
+              message: e.message
+            }))
+          });
+        }
+        validatedInput = inputResult.data;
+      }
+      const validatedArgs = {
+        input: validatedInput,
+        raw: rawArgs
+      };
+      const executePipeline = async () => {
+        if (isSimpleGraphQLHandlerConfig(config)) {
+          return config.handler(
+            validatedArgs,
+            validatedContext
+          );
+        } else {
+          const { argsMapper, useCase, responseMapper } = config;
+          const input = argsMapper(
+            validatedArgs,
+            validatedContext
+          );
+          const output = await useCase.execute(input);
+          return responseMapper(output);
+        }
+      };
+      let result;
+      if (allMiddleware.length === 0) {
+        result = await executePipeline();
+      } else {
+        let index = 0;
+        let called = false;
+        const next = async () => {
+          if (index >= allMiddleware.length) {
+            if (called) throw new Error("next() called after pipeline already executed");
+            called = true;
+            return executePipeline();
+          }
+          const currentIndex = index++;
+          const mw = allMiddleware[currentIndex];
+          return mw(rawArgs, context, next);
+        };
+        result = await next();
+      }
+      if (shouldValidateOutput && field.output) {
+        const outputResult = validateOutputData(field, result);
+        if (!outputResult.success) {
+          const details = outputResult.errors?.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+          throw new ObjectValidationError({
+            message: `Output validation failed for field "${key}": ${details}`,
+            validationErrors: (outputResult.errors ?? []).map((e) => ({
+              field: e.path.join("."),
+              message: e.message
+            }))
+          });
+        }
+      }
+      return result;
+    }
+  };
+}
+function validateInputData(field, args) {
+  const schema = field.input;
+  if (!schema) return { success: true, data: args };
+  const result = schema.validate(args);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["input", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+function validateOutputData(field, data) {
+  const schema = field.output;
+  if (!schema) return { success: true, data };
+  const result = schema.validate(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["output", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+function validateContextData(field, context) {
+  const schema = field.context;
+  if (!schema) return { success: true, data: context };
+  const result = schema.validate(context);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.issues.map((issue) => ({
+    ...issue,
+    path: ["context", ...issue.path]
+  }));
+  return { success: false, errors };
+}
+function generateRequestId() {
+  return `gql_${crypto.randomUUID()}`;
+}
+
+// src/presentation/graphql/server/graphql-routes-builder.ts
+var GraphQLRoutesBuilderImpl = class _GraphQLRoutesBuilderImpl {
+  schema;
+  handlers;
+  constructor(schema, handlers) {
+    this.schema = schema;
+    this.handlers = handlers ?? /* @__PURE__ */ new Map();
+  }
+  handle(key, handlerOrConfig) {
+    const config = typeof handlerOrConfig === "function" ? { handler: handlerOrConfig } : handlerOrConfig;
+    const newHandlers = new Map(this.handlers);
+    newHandlers.set(key, config);
+    return new _GraphQLRoutesBuilderImpl(
+      this.schema,
+      newHandlers
+    );
+  }
+  handleWithUseCase(key, config) {
+    const newHandlers = new Map(this.handlers);
+    newHandlers.set(
+      key,
+      config
+    );
+    return new _GraphQLRoutesBuilderImpl(
+      this.schema,
+      newHandlers
+    );
+  }
+  build(options) {
+    return createGraphQLRoutesInternal(this.schema, Object.fromEntries(this.handlers), options);
+  }
+  buildPartial(options) {
+    return createGraphQLRoutesInternal(this.schema, Object.fromEntries(this.handlers), {
+      ...options,
+      allowPartial: true
+    });
+  }
+};
+function graphqlRoutes(schema) {
+  return new GraphQLRoutesBuilderImpl(schema);
+}
+
+// src/presentation/graphql/sdl/generate.ts
+function generateGraphQLSDL(schema, config) {
+  const fields = isSchemaDefinition(schema) ? schema.fields : schema;
+  const collectedFields = collectFields(fields);
+  const includeDescriptions = config?.includeDescriptions ?? true;
+  const includeDeprecations = config?.includeDeprecations ?? true;
+  const queries = [];
+  const mutations = [];
+  const subscriptions = [];
+  for (const { key, field } of collectedFields) {
+    const fieldId = generateFieldId(key);
+    if (field.operation === "query") {
+      queries.push({ fieldId, field });
+    } else if (field.operation === "mutation") {
+      mutations.push({ fieldId, field });
+    } else if (field.operation === "subscription") {
+      subscriptions.push({ fieldId, field });
+    }
+  }
+  const namedTypes = /* @__PURE__ */ new Map();
+  const lines = [];
+  if (config?.preamble) {
+    lines.push(config.preamble);
+    lines.push("");
+  }
+  if (queries.length > 0) {
+    lines.push("type Query {");
+    for (const { fieldId, field } of queries) {
+      const fieldLine = buildFieldLine(
+        fieldId,
+        field,
+        namedTypes,
+        includeDescriptions,
+        includeDeprecations
+      );
+      lines.push(fieldLine);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  if (mutations.length > 0) {
+    lines.push("type Mutation {");
+    for (const { fieldId, field } of mutations) {
+      const fieldLine = buildFieldLine(
+        fieldId,
+        field,
+        namedTypes,
+        includeDescriptions,
+        includeDeprecations
+      );
+      lines.push(fieldLine);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  if (subscriptions.length > 0) {
+    lines.push("type Subscription {");
+    for (const { fieldId, field } of subscriptions) {
+      const fieldLine = buildFieldLine(
+        fieldId,
+        field,
+        namedTypes,
+        includeDescriptions,
+        includeDeprecations
+      );
+      lines.push(fieldLine);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  for (const [, typeBody] of namedTypes) {
+    lines.push(typeBody);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function buildFieldLine(fieldId, field, namedTypes, includeDescriptions, includeDeprecations) {
+  const parts = [];
+  if (includeDescriptions && field.docs.description) {
+    const escaped = field.docs.description.replace(/"""/g, '\\"""');
+    parts.push(`  """${escaped}"""`);
+  }
+  const inputTypeName = field.input ? `${capitalize(fieldId)}Input` : void 0;
+  const outputTypeName = field.output ? `${capitalize(fieldId)}Output` : void 0;
+  if (field.input && inputTypeName) {
+    const jsonSchema = field.input.toJsonSchema();
+    namedTypes.set(inputTypeName, buildInputType(inputTypeName, jsonSchema));
+  }
+  if (field.output && outputTypeName) {
+    const jsonSchema = field.output.toJsonSchema();
+    namedTypes.set(outputTypeName, buildOutputType(outputTypeName, jsonSchema));
+  }
+  let signature = `  ${fieldId}`;
+  if (inputTypeName) {
+    signature += `(input: ${inputTypeName}!)`;
+  }
+  signature += ": ";
+  signature += outputTypeName ?? "JSON";
+  if (includeDeprecations && field.docs.deprecated) {
+    const reason = field.docs.deprecationReason;
+    signature += reason ? ` @deprecated(reason: "${escapeSDLString(reason)}")` : " @deprecated";
+  }
+  if (parts.length > 0) {
+    return parts.join("\n") + "\n" + signature;
+  }
+  return signature;
+}
+function buildInputType(typeName, jsonSchema) {
+  const lines = [`input ${typeName} {`];
+  if (jsonSchema.properties && typeof jsonSchema.properties === "object") {
+    const required = new Set(
+      Array.isArray(jsonSchema.required) ? jsonSchema.required : []
+    );
+    for (const [propName, propSchema] of Object.entries(
+      jsonSchema.properties
+    )) {
+      const graphqlType = jsonSchemaToGraphQLType(propSchema);
+      const isRequired = required.has(propName);
+      lines.push(`  ${propName}: ${graphqlType}${isRequired ? "!" : ""}`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function buildOutputType(typeName, jsonSchema) {
+  const lines = [`type ${typeName} {`];
+  if (jsonSchema.properties && typeof jsonSchema.properties === "object") {
+    const required = new Set(
+      Array.isArray(jsonSchema.required) ? jsonSchema.required : []
+    );
+    for (const [propName, propSchema] of Object.entries(
+      jsonSchema.properties
+    )) {
+      const graphqlType = jsonSchemaToGraphQLType(propSchema);
+      const isRequired = required.has(propName);
+      lines.push(`  ${propName}: ${graphqlType}${isRequired ? "!" : ""}`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function jsonSchemaToGraphQLType(schema) {
+  if (!schema || typeof schema !== "object") return "JSON";
+  if (schema.enum && Array.isArray(schema.enum)) {
+    return "String";
+  }
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      return "String";
+    case "integer":
+      return "Int";
+    case "number":
+      return "Float";
+    case "boolean":
+      return "Boolean";
+    case "array": {
+      const items = schema.items;
+      if (items) {
+        return `[${jsonSchemaToGraphQLType(items)}]`;
+      }
+      return "[JSON]";
+    }
+    case "object":
+      return "JSON";
+    default:
+      if (schema.oneOf || schema.anyOf || schema.allOf) {
+        return "JSON";
+      }
+      if (schema.properties) {
+        return "JSON";
+      }
+      return "JSON";
+  }
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function escapeSDLString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectFields,
+  defineGraphQLSchema,
+  defineMutation,
+  defineQuery,
+  defineSubscription,
+  generateFieldId,
+  generateGraphQLSDL,
+  getGraphQLErrorCode,
+  graphqlRoutes,
+  isFieldDefinition,
+  isSchemaDefinition,
+  isSimpleGraphQLHandlerConfig,
+  mapErrorToGraphQLError,
+  mergeGraphQLSchemas,
+  shouldMaskGraphQLError
+});
+//# sourceMappingURL=index.cjs.map