ragatanga-mcp-sdk/dist/validators/index.mjs

SDK for integrating with the Ragatanga Management Control Plane (MCP) with Next.js 15, React 19, WebSocket and Arrow IPC support

import { z } from 'zod';

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var timestampSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/);
var uuidSchema = z.string().uuid();
var ontologySummarySchema = z.object({
  id: uuidSchema,
  name: z.string().min(1),
  createdAt: timestampSchema,
  format: z.string().optional()
});
var ontologyMetadataSchema = ontologySummarySchema.extend({
  size: z.number().nonnegative().optional(),
  updatedAt: timestampSchema.optional(),
  entityCount: z.number().nonnegative().optional(),
  owner: z.string().optional()
});
var authSchema = z.object({
  token: z.string(),
  refreshToken: z.string().optional(),
  expiresAt: timestampSchema.optional(),
  userId: z.string().optional(),
  permissions: z.array(z.string()).optional()
});
var contextSpecSchema = z.object({
  id: z.string(),
  parameters: z.record(z.unknown())
});
var contextRequestSchema = z.object({
  request_id: z.string(),
  current_query: z.string(),
  context_specs: z.array(contextSpecSchema)
});
var contextResponseSchema = z.object({
  responses: z.array(
    z.object({
      id: z.string(),
      content: z.object({
        type: z.string(),
        value: z.string()
      }),
      metadata: z.object({
        confidence: z.number(),
        source: z.string(),
        timestamp: timestampSchema
      }).catchall(z.unknown())
    })
  )
});
var errorResponseSchema = z.object({
  error: z.string(),
  message: z.string(),
  statusCode: z.number().optional(),
  code: z.string().optional()
});
var paginationSchema = z.object({
  total: z.number().nonnegative(),
  page: z.number().nonnegative(),
  pageSize: z.number().positive(),
  totalPages: z.number().nonnegative(),
  hasMore: z.boolean()
});
function createPaginatedSchema(itemSchema) {
  return z.object({
    data: z.array(itemSchema),
    pagination: paginationSchema
  });
}
__name(createPaginatedSchema, "createPaginatedSchema");
var apiLimitsSchema = z.object({
  limit: z.number().positive(),
  remaining: z.number().nonnegative(),
  reset: timestampSchema
});

// src/errors/index.ts
var _MCPError = class _MCPError extends Error {
  constructor(message, options) {
    super(message);
    this.name = "MCPError";
    this.status = options?.status;
    this.code = options?.code;
    this.cause = options?.cause;
    Object.setPrototypeOf(this, _MCPError.prototype);
  }
  /**
   * Creates a formatted error message with all available details
   */
  toFormattedString() {
    const parts = [
      `[${this.name}] ${this.message}`,
      this.code ? `Code: ${this.code}` : null,
      this.status ? `Status: ${this.status}` : null,
      this.cause ? `Cause: ${this.cause instanceof Error ? this.cause.message : String(this.cause)}` : null
    ].filter(Boolean);
    return parts.join(" | ");
  }
};
__name(_MCPError, "MCPError");
var MCPError = _MCPError;
var _ValidationError = class _ValidationError extends MCPError {
  constructor(message, options) {
    super(message, {
      code: options?.code || "VALIDATION_ERROR",
      cause: options?.cause
    });
    this.name = "ValidationError";
    this.errors = options?.errors;
    Object.setPrototypeOf(this, _ValidationError.prototype);
  }
};
__name(_ValidationError, "ValidationError");
var ValidationError = _ValidationError;

// src/validators/validation.ts
function validate(schema, data) {
  try {
    return schema.parse(data);
  } catch (error) {
    if (error instanceof z.ZodError) {
      throw new ValidationError(
        `Validation failed: ${error.errors.map((e) => e.message).join(", ")}`,
        { errors: error.format() }
      );
    }
    throw error;
  }
}
__name(validate, "validate");
function validateSafe(schema, data) {
  try {
    return {
      success: true,
      data: schema.parse(data)
    };
  } catch (error) {
    if (error instanceof z.ZodError) {
      return {
        success: false,
        error: new ValidationError(
          `Validation failed: ${error.errors.map((e) => e.message).join(", ")}`,
          { errors: error.format() }
        )
      };
    }
    if (error instanceof Error) {
      return {
        success: false,
        error: new ValidationError(error.message, { cause: error })
      };
    }
    return {
      success: false,
      error: new ValidationError(`Unknown validation error: ${String(error)}`)
    };
  }
}
__name(validateSafe, "validateSafe");
function createValidator(schema) {
  return (data) => validate(schema, data);
}
__name(createValidator, "createValidator");
function createSafeValidator(schema) {
  return (data) => validateSafe(schema, data);
}
__name(createSafeValidator, "createSafeValidator");
function validateArray(schema, data) {
  const arraySchema = z.array(schema);
  return validate(arraySchema, data);
}
__name(validateArray, "validateArray");
function validateResponse(schema, data) {
  const baseSchema = z.object({}).required();
  baseSchema.parse(data);
  return validate(schema, data);
}
__name(validateResponse, "validateResponse");

export { apiLimitsSchema, authSchema, contextRequestSchema, contextResponseSchema, contextSpecSchema, createPaginatedSchema, createSafeValidator, createValidator, errorResponseSchema, ontologyMetadataSchema, ontologySummarySchema, paginationSchema, timestampSchema, uuidSchema, validate, validateArray, validateResponse, validateSafe };
//# sourceMappingURL=index.mjs.map
//# sourceMappingURL=index.mjs.map