bind.h

Go to the documentation of this file.

 
#ifndef __CWIST_VALIDATION_BIND_H__
#define __CWIST_VALIDATION_BIND_H__
 
#include <cwist/net/http/http.h>
#include <cwist/core/sstring/sstring.h>
#include <cwist/core/utils/json_builder.h>
#include <cjson/cJSON.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <regex.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* -------------------------------------------------------------------------
 * Validation rule descriptors
 * ---------------------------------------------------------------------- */
 
typedef enum cwist_bind_rule_type {
    CWIST_BIND_RULE_REQUIRED,   
    CWIST_BIND_RULE_MIN_LEN,    
    CWIST_BIND_RULE_MAX_LEN,    
    CWIST_BIND_RULE_MIN_VAL,    
    CWIST_BIND_RULE_MAX_VAL,    
    CWIST_BIND_RULE_REGEX,      
    CWIST_BIND_RULE_EMAIL,      
    CWIST_BIND_RULE_CUSTOM,     
} cwist_bind_rule_type_t;
 
typedef struct cwist_bind_rule {
    cwist_bind_rule_type_t type;
    union {
        size_t min_len;    
        size_t max_len;    
        long double min_val;    
        long double max_val;    
        const char *pattern;    
        struct {
            bool (*fn)(const char *value, size_t len, void *ctx);
            void *ctx;
        } custom;               
    } u;
    const char *error_message;  
} cwist_bind_rule_t;
 
typedef enum cwist_bind_field_type {
    CWIST_BIND_BOOL,
    CWIST_BIND_INT,
    CWIST_BIND_UINT,
    CWIST_BIND_FLOAT,
    CWIST_BIND_DOUBLE,
    CWIST_BIND_STRING,      
    CWIST_BIND_SSTRING,     
    CWIST_BIND_JSON_OBJECT, 
} cwist_bind_field_type_t;
 
typedef struct cwist_bind_field {
    const char *json_key;      
    cwist_bind_field_type_t target_type;   
    size_t target_offset; 
    size_t target_size;   
    const cwist_bind_rule_t *rules;         
    size_t rule_count;    
} cwist_bind_field_t;
 
typedef struct cwist_bind_schema {
    const cwist_bind_field_t *fields;
    size_t field_count;
    size_t struct_size;  
} cwist_bind_schema_t;
 
/* -------------------------------------------------------------------------
 * Result types
 * ---------------------------------------------------------------------- */
 
#define CWIST_BIND_MAX_ERRORS 32
#define CWIST_BIND_MSG_MAX 256
#define CWIST_BIND_KEY_MAX 64
 
typedef struct cwist_bind_error {
    char key[CWIST_BIND_KEY_MAX];
    char message[CWIST_BIND_MSG_MAX];
} cwist_bind_error_t;
 
typedef struct cwist_bind_result {
    bool ok;
    cwist_bind_error_t errors[CWIST_BIND_MAX_ERRORS];
    size_t error_count;
} cwist_bind_result_t;
 
/* -------------------------------------------------------------------------
 * Public API
 * ---------------------------------------------------------------------- */
 
bool cwist_app_req_bind_json(cwist_http_request *req, const cwist_bind_schema_t *schema, void *out,
                             cwist_bind_result_t *result);
 
bool cwist_app_req_bind_form(cwist_http_request *req, const cwist_bind_schema_t *schema, void *out,
                             cwist_bind_result_t *result);
 
void cwist_bind_write_error_response(cwist_http_response *res, const cwist_bind_result_t *result);
 
bool cwist_app_req_bind_json_or_400(cwist_http_request *req, cwist_http_response *res,
                                    const cwist_bind_schema_t *schema, void *out);
 
/* -------------------------------------------------------------------------
 * _Generic type-safe dispatch macros
 * ---------------------------------------------------------------------- */
 
#define CWIST_BIND_TYPEOF(x)                 \
    _Generic((x),                            \
        bool: CWIST_BIND_BOOL,               \
        char *: CWIST_BIND_STRING,           \
        const char *: CWIST_BIND_STRING,     \
        int: CWIST_BIND_INT,                 \
        unsigned int: CWIST_BIND_UINT,       \
        long: CWIST_BIND_INT,                \
        unsigned long: CWIST_BIND_UINT,      \
        long long: CWIST_BIND_INT,           \
        unsigned long long: CWIST_BIND_UINT, \
        float: CWIST_BIND_FLOAT,             \
        double: CWIST_BIND_DOUBLE,           \
        long double: CWIST_BIND_DOUBLE,      \
        cwist_sstring *: CWIST_BIND_SSTRING, \
        cJSON *: CWIST_BIND_JSON_OBJECT,     \
        default: CWIST_BIND_STRING)
 
#define CWIST_BIND_OFFSET(st, m) offsetof(st, m)
 
#define CWIST_BIND_SIZEOF(st, m) sizeof(((st *)0)->m)
 
#define CWIST_BIND_RULES(name, ...) \
    static const cwist_bind_rule_t name[] = {__VA_ARGS__, {-1, {0}, NULL}}
 
#define CWIST_BIND_FIELD(StructType, MemberName, JsonKey, RulesArray) \
    {.json_key = (JsonKey),                                           \
     .target_type = CWIST_BIND_TYPEOF(((StructType *)0)->MemberName), \
     .target_offset = CWIST_BIND_OFFSET(StructType, MemberName),      \
     .target_size = CWIST_BIND_SIZEOF(StructType, MemberName),        \
     .rules = (RulesArray)}
 
#define CWIST_BIND_SCHEMA(StructType, FieldArray)                                            \
    (cwist_bind_schema_t) {                                                                  \
        .fields = (FieldArray), .field_count = sizeof(FieldArray) / sizeof((FieldArray)[0]), \
        .struct_size = sizeof(StructType)                                                    \
    }
 
/* -------------------------------------------------------------------------
 * Rule construction helpers
 * ---------------------------------------------------------------------- */
 
#define CWIST_RULE_REQUIRED()               \
    (cwist_bind_rule_t) {                   \
        CWIST_BIND_RULE_REQUIRED, {0}, NULL \
    }
 
#define CWIST_RULE_MIN_LEN(n)                           \
    (cwist_bind_rule_t) {                               \
        CWIST_BIND_RULE_MIN_LEN, {.min_len = (n)}, NULL \
    }
 
#define CWIST_RULE_MAX_LEN(n)                           \
    (cwist_bind_rule_t) {                               \
        CWIST_BIND_RULE_MAX_LEN, {.max_len = (n)}, NULL \
    }
 
#define CWIST_RULE_MIN_VAL(v)                           \
    (cwist_bind_rule_t) {                               \
        CWIST_BIND_RULE_MIN_VAL, {.min_val = (v)}, NULL \
    }
 
#define CWIST_RULE_MAX_VAL(v)                           \
    (cwist_bind_rule_t) {                               \
        CWIST_BIND_RULE_MAX_VAL, {.max_val = (v)}, NULL \
    }
 
#define CWIST_RULE_REGEX(pat)                           \
    (cwist_bind_rule_t) {                               \
        CWIST_BIND_RULE_REGEX, {.pattern = (pat)}, NULL \
    }
 
#define CWIST_RULE_EMAIL()               \
    (cwist_bind_rule_t) {                \
        CWIST_BIND_RULE_EMAIL, {0}, NULL \
    }
 
#define CWIST_RULE_CUSTOM(fn_ptr, ctx_ptr)                                           \
    (cwist_bind_rule_t) {                                                            \
        CWIST_BIND_RULE_CUSTOM, {.custom = {.fn = (fn_ptr), .ctx = (ctx_ptr)}}, NULL \
    }
 
#ifdef __cplusplus
}
#endif
 
#endif /* __CWIST_VALIDATION_BIND_H__ */