Method makeFilterValue

packages/server/src/api/rest/index.ts:2519–2583

(fieldDef: FieldDef, value: string, op: FilterOperationType)

    }

    private makeFilterValue(fieldDef: FieldDef, value: string, op: FilterOperationType): any {
        // TODO: inequality filters?
        if (fieldDef.relation) {
            // relation filter is converted to an ID filter
            const info = this.getModelInfo(fieldDef.type)!;
            if (fieldDef.array) {
                // filtering a to-many relation, imply 'some' operator
                const values = value.split(',').filter((i) => i);
                const filterValue =
                    values.length > 1
                        ? { OR: values.map((v) => this.makeIdFilter(info.idFields, v, false)) }
                        : this.makeIdFilter(info.idFields, value, false);
                return { some: filterValue };
            } else {
                const values = value.split(',').filter((i) => i);
                if (values.length > 1) {
                    return { OR: values.map((v) => this.makeIdFilter(info.idFields, v, false)) };
                } else {
                    return { is: this.makeIdFilter(info.idFields, value, false) };
                }
            }
        } else {
            if (op === 'between') {
                const parts = value.split(',').map((v) => this.coerce(fieldDef, v));
                if (parts.length !== 2) {
                    throw new InvalidValueError(`"between" expects exactly 2 comma-separated values`);
                }
                return { between: [parts[0]!, parts[1]!] };
            }
            const coerced = this.coerce(fieldDef, value);
            switch (op) {
                case 'icontains':
                    return { contains: coerced, mode: 'insensitive' };
                case 'hasSome':
                case 'hasEvery': {
                    const values = value
                        .split(',')
                        .filter((i) => i)
                        .map((v) => this.coerce(fieldDef, v));
                    return { [op]: values };
                }
                case 'isEmpty':
                    if (value !== 'true' && value !== 'false') {
                        throw new InvalidValueError(`Not a boolean: ${value}`);
                    }
                    return { isEmpty: value === 'true' ? true : false };
                default:
                    if (op === undefined) {
                        if (fieldDef.attributes?.some((attr) => attr.name === '@json')) {
                            // handle JSON value equality filter
                            return { equals: coerced };
                        }

                        // regular filter, split value by comma
                        const values = value
                            .split(',')
                            .filter((i) => i)
                            .map((v) => this.coerce(fieldDef, v));