@mcabreradev/filter/build/validation/schemas/schemas.js

A powerful, SQL-like array filtering library for TypeScript and JavaScript with advanced pattern matching, MongoDB-style operators, deep object comparison, and zero dependencies

import { z } from 'zod';
export const primitiveSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
export const predicateFunctionSchema = z.function();
export const comparisonOperatorSchema = z
    .object({
    $gt: z.union([z.number(), z.date()]).optional(),
    $gte: z.union([z.number(), z.date()]).optional(),
    $lt: z.union([z.number(), z.date()]).optional(),
    $lte: z.union([z.number(), z.date()]).optional(),
    $eq: z.any().optional(),
    $ne: z.any().optional(),
})
    .strict();
export const arrayOperatorSchema = z
    .object({
    $in: z.array(z.any()).optional(),
    $nin: z.array(z.any()).optional(),
    $contains: z.any().optional(),
    $size: z.number().optional(),
})
    .strict();
export const stringOperatorSchema = z
    .object({
    $startsWith: z.string().optional(),
    $endsWith: z.string().optional(),
    $contains: z.string().optional(),
    $regex: z.union([z.string(), z.instanceof(RegExp)]).optional(),
    $match: z.union([z.string(), z.instanceof(RegExp)]).optional(),
})
    .strict();
const baseExpressionSchema = z.lazy(() => z.union([
    primitiveSchema,
    predicateFunctionSchema,
    z.record(z.string(), z.any()),
    baseOperatorExpressionSchema,
]));
const baseOperatorExpressionSchema = z.union([
    comparisonOperatorSchema,
    arrayOperatorSchema,
    stringOperatorSchema,
    comparisonOperatorSchema.merge(arrayOperatorSchema).merge(stringOperatorSchema),
]);
export const logicalOperatorSchema = z
    .object({
    $and: z.array(baseExpressionSchema).min(1).optional(),
    $or: z.array(baseExpressionSchema).min(1).optional(),
    $not: baseExpressionSchema.optional(),
})
    .strict();
export const operatorExpressionSchema = z.union([
    baseOperatorExpressionSchema,
    logicalOperatorSchema,
]);
export const objectExpressionSchema = z.record(z.string(), z.any());
export const expressionSchema = z.union([
    primitiveSchema,
    predicateFunctionSchema,
    objectExpressionSchema,
    operatorExpressionSchema,
]);
export const sortDirectionSchema = z.enum(['asc', 'desc']);
export const orderByFieldSchema = z.object({
    field: z.string(),
    direction: sortDirectionSchema,
});
export const orderBySchema = z.union([
    z.string(),
    orderByFieldSchema,
    z.array(z.union([z.string(), orderByFieldSchema])),
]);
export const filterOptionsSchema = z
    .object({
    caseSensitive: z.boolean().optional(),
    maxDepth: z.number().min(1).max(10).optional(),
    customComparator: z.function().optional(),
    enableCache: z.boolean().optional(),
    orderBy: orderBySchema.optional(),
    limit: z.number().int().positive().optional(),
    debug: z.boolean().optional(),
    verbose: z.boolean().optional(),
    showTimings: z.boolean().optional(),
    colorize: z.boolean().optional(),
    enablePerformanceMonitoring: z.boolean().optional(),
})
    .optional();