WayrApp Backend & Ecosystem Documentation - v1.0.0
    Preparing search index...

    Variable ProgressQuerySchemaConst

    ProgressQuerySchema: ZodEffects<
        ZodObject<
            {
                page: ZodEffects<ZodOptional<ZodString>, number, undefined | string>;
                limit: ZodEffects<ZodOptional<ZodString>, number, undefined | string>;
                sortBy: ZodOptional<ZodString>;
                sortOrder: ZodDefault<ZodOptional<ZodEnum<["asc", "desc"]>>>;
                from_date: ZodOptional<ZodString>;
                to_date: ZodOptional<ZodString>;
                min_score: ZodEffects<
                    ZodOptional<ZodString>,
                    undefined | number,
                    undefined | string,
                >;
                max_score: ZodEffects<
                    ZodOptional<ZodString>,
                    undefined | number,
                    undefined | string,
                >;
            },
            "strip",
            ZodTypeAny,
            {
                page: number;
                limit: number;
                sortBy?: string;
                sortOrder: "asc"
                | "desc";
                from_date?: string;
                to_date?: string;
                min_score?: number;
                max_score?: number;
            },
            {
                page?: string;
                limit?: string;
                sortBy?: string;
                sortOrder?: "asc"
                | "desc";
                from_date?: string;
                to_date?: string;
                min_score?: string;
                max_score?: string;
            },
        >,
        {
            page: number;
            limit: number;
            sortBy?: string;
            sortOrder: "asc"
            | "desc";
            from_date?: string;
            to_date?: string;
            min_score?: number;
            max_score?: number;
        },
        {
            page?: string;
            limit?: string;
            sortBy?: string;
            sortOrder?: "asc"
            | "desc";
            from_date?: string;
            to_date?: string;
            min_score?: string;
            max_score?: string;
        },
    > = ...

    Progress query parameters validation schema for analytics and reporting

    Comprehensive validation schema for query parameters used in progress analytics, learning reports, and educational effectiveness analysis across the language learning platform. This schema combines standard pagination functionality with progress-specific filtering options including temporal ranges, performance thresholds, and sorting capabilities for comprehensive learning analytics.

    The query schema supports educational research through temporal filtering for learning pattern analysis, performance-based filtering for achievement analytics, flexible sorting for various reporting needs, and pagination for efficient data processing in large-scale learning analytics operations.

    Analytics capabilities include learning progress visualization through date-range filtering, performance analysis through score-based queries, engagement measurement through activity pattern analysis, and educational effectiveness assessment through comprehensive progress data aggregation and filtering.

    The schema ensures efficient database operations through proper pagination limits, supports various reporting timeframes through flexible date filtering, enables performance benchmarking through score range queries, and maintains query performance through optimized parameter validation and transformation.

    // Comprehensive progress analytics query
    const analyticsQuery = {
    page: '1',
    limit: '50',
    sortBy: 'completed_at',
    sortOrder: 'desc',
    from_date: '2024-01-01T00:00:00Z',
    to_date: '2024-01-31T23:59:59Z',
    min_score: '70',
    max_score: '100'
    };

    const validatedQuery = ProgressQuerySchema.parse(analyticsQuery);
    // Result: { page: 1, limit: 50, sortBy: 'completed_at', sortOrder: 'desc',
    // from_date: '2024-01-01T00:00:00Z', to_date: '2024-01-31T23:59:59Z',
    // min_score: 70, max_score: 100 }
    // Progress analytics endpoint with comprehensive filtering
    router.get('/progress/analytics',
    validate({ query: ProgressQuerySchema }),
    async (req, res) => {
    const {
    page,
    limit,
    sortBy,
    sortOrder,
    from_date,
    to_date,
    min_score,
    max_score
    } = req.query;

    const analyticsOptions = {
    skip: (page - 1) * limit,
    take: limit,
    where: {
    ...(from_date && { completed_at: { gte: new Date(from_date) } }),
    ...(to_date && { completed_at: { lte: new Date(to_date) } }),
    ...(min_score !== undefined && { score: { gte: min_score } }),
    ...(max_score !== undefined && { score: { lte: max_score } })
    },
    orderBy: sortBy ? { [sortBy]: sortOrder } : { completed_at: 'desc' }
    };

    const progressData = await progressService.getAnalytics(analyticsOptions);
    res.json({ data: progressData, pagination: { page, limit, sortBy, sortOrder } });
    }
    );
    // Learning effectiveness analysis
    const effectivenessQuery = {
    from_date: '2024-01-01T00:00:00Z',
    to_date: '2024-01-31T23:59:59Z',
    min_score: '80', // High-performing learners
    sortBy: 'score',
    sortOrder: 'desc',
    limit: '100'
    };
    // Student progress dashboard queries
    const studentDashboard = {
    page: '1',
    limit: '20',
    sortBy: 'completed_at',
    sortOrder: 'desc',
    from_date: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString() // Last 30 days
    };
    // Performance benchmarking queries
    const benchmarkingQueries = [
    {
    // Top performers
    min_score: '90',
    sortBy: 'score',
    sortOrder: 'desc',
    limit: '50'
    },
    {
    // Struggling learners
    max_score: '60',
    sortBy: 'completed_at',
    sortOrder: 'desc',
    limit: '100'
    }
    ];
    // Mobile app progress history
    const mobileProgressQuery = {
    page: '1',
    limit: '10', // Smaller batches for mobile
    sortBy: 'completed_at',
    sortOrder: 'desc',
    from_date: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString() // Last week
    };
    // Learning analytics dashboard with real-time filtering
    const buildAnalyticsQuery = (filters: any) => {
    const query: any = {
    page: filters.page || '1',
    limit: filters.limit || '25',
    sortBy: filters.sortBy || 'completed_at',
    sortOrder: filters.sortOrder || 'desc'
    };

    if (filters.dateRange) {
    query.from_date = filters.dateRange.start;
    query.to_date = filters.dateRange.end;
    }

    if (filters.performanceRange) {
    query.min_score = filters.performanceRange.min?.toString();
    query.max_score = filters.performanceRange.max?.toString();
    }

    const validation = ProgressQuerySchema.safeParse(query);
    return validation.success ? validation.data : null;
    };