static JSC::JSValue toJS()

in src/bun.js/bindings/SQLClient.cpp [77:227]
139 lines of code
37 McCabe index (conditional complexity)

static JSC::JSValue toJS(JSC::VM& vm, JSC::JSGlobalObject* globalObject, DataCell& cell)
{
    switch (cell.tag) {
    case DataCellTag::Null:
        return jsNull();
        break;
    case DataCellTag::String: {
        return jsString(vm, WTF::String(cell.value.string));
        break;
    }
    case DataCellTag::Double:
        return jsDoubleNumber(cell.value.number);
        break;
    case DataCellTag::Integer:
        return jsNumber(cell.value.integer);
        break;
    case DataCellTag::Bigint:
        return JSC::JSBigInt::createFrom(globalObject, cell.value.bigint);
        break;
    case DataCellTag::Boolean:
        return jsBoolean(cell.value.boolean);
        break;
    case DataCellTag::Date:
        return JSC::DateInstance::create(vm, globalObject->dateStructure(), cell.value.date);
        break;
    case DataCellTag::Bytea: {
        Zig::GlobalObject* zigGlobal = jsCast<Zig::GlobalObject*>(globalObject);
        auto* subclassStructure = zigGlobal->JSBufferSubclassStructure();
        auto* uint8Array = JSC::JSUint8Array::createUninitialized(globalObject, subclassStructure, cell.value.bytea[1]);
        if (UNLIKELY(uint8Array == nullptr)) {
            return {};
        }

        if (cell.value.bytea[1] > 0) {
            memcpy(uint8Array->vector(), reinterpret_cast<void*>(cell.value.bytea[0]), cell.value.bytea[1]);
        }
        return uint8Array;
    }
    case DataCellTag::Json: {
        auto str = WTF::String(cell.value.string);
        JSC::JSValue json = JSC::JSONParse(globalObject, str);
        return json;
        break;
    }
    case DataCellTag::Array: {
        MarkedArgumentBuffer args;
        unsigned length = cell.value.array.length;
        for (unsigned i = 0; i < length; i++) {
            JSValue result = toJS(vm, globalObject, cell.value.array.cells[i]);
            if (UNLIKELY(result.isEmpty())) {
                return {};
            }

            args.append(result);
        }

        return JSC::constructArray(globalObject, static_cast<ArrayAllocationProfile*>(nullptr), args);
    }
    case DataCellTag::TypedArray: {
        JSC::JSType type = static_cast<JSC::JSType>(cell.value.typed_array.type);
        unsigned length = cell.value.typed_array.length;
        switch (type) {
        case JSC::JSType::Int32ArrayType: {
            JSC::JSInt32Array* array = JSC::JSInt32Array::createUninitialized(globalObject, globalObject->typedArrayStructure(TypedArrayType::TypeInt32, false), length);
            if (UNLIKELY(array == nullptr)) {
                return {};
            }

            if (length > 0) {
                memcpy(array->vector(), reinterpret_cast<void*>(cell.value.typed_array.data), length * sizeof(int32_t));
            }

            return array;
        }
        case JSC::JSType::Uint32ArrayType: {
            JSC::JSUint32Array* array = JSC::JSUint32Array::createUninitialized(globalObject, globalObject->typedArrayStructure(TypedArrayType::TypeUint32, false), length);
            if (UNLIKELY(array == nullptr)) {
                return {};
            }

            if (length > 0) {
                memcpy(array->vector(), reinterpret_cast<void*>(cell.value.typed_array.data), length * sizeof(uint32_t));
            }
            return array;
        }
        case JSC::JSType::Int16ArrayType: {
            JSC::JSInt16Array* array = JSC::JSInt16Array::createUninitialized(globalObject, globalObject->typedArrayStructure(TypedArrayType::TypeInt16, false), length);
            if (UNLIKELY(array == nullptr)) {
                return {};
            }

            if (length > 0) {
                memcpy(array->vector(), reinterpret_cast<void*>(cell.value.typed_array.data), length * sizeof(int16_t));
            }

            return array;
        }
        case JSC::JSType::Uint16ArrayType: {
            JSC::JSUint16Array* array = JSC::JSUint16Array::createUninitialized(globalObject, globalObject->typedArrayStructure(TypedArrayType::TypeUint16, false), length);
            if (UNLIKELY(array == nullptr)) {
                return {};
            }

            if (length > 0) {
                memcpy(array->vector(), reinterpret_cast<void*>(cell.value.typed_array.data), length * sizeof(uint16_t));
            }
            return array;
        }
        case JSC::JSType::Float16ArrayType: {
            JSC::JSFloat16Array* array = JSC::JSFloat16Array::createUninitialized(globalObject, globalObject->typedArrayStructure(TypedArrayType::TypeFloat16, false), length);
            if (UNLIKELY(array == nullptr)) {
                return {};
            }

            if (length > 0) {
                memcpy(array->vector(), reinterpret_cast<void*>(cell.value.typed_array.data), length * 2); // sizeof(float16_t)
            }
            return array;
        }
        case JSC::JSType::Float32ArrayType: {
            JSC::JSFloat32Array* array = JSC::JSFloat32Array::createUninitialized(globalObject, globalObject->typedArrayStructure(TypedArrayType::TypeFloat32, false), length);
            if (UNLIKELY(array == nullptr)) {
                return {};
            }

            if (length > 0) {
                memcpy(array->vector(), reinterpret_cast<void*>(cell.value.typed_array.data), length * sizeof(float));
            }
            return array;
        }
        case JSC::JSType::Float64ArrayType: {
            JSC::JSFloat64Array* array = JSC::JSFloat64Array::createUninitialized(globalObject, globalObject->typedArrayStructure(TypedArrayType::TypeFloat64, false), length);
            if (UNLIKELY(array == nullptr)) {
                return {};
            }

            if (length > 0) {
                memcpy(array->vector(), reinterpret_cast<void*>(cell.value.typed_array.data), length * sizeof(double));
            }
            return array;
        }
        default: {
            RELEASE_ASSERT_NOT_REACHED_WITH_MESSAGE("TODO: implement this typed array type");
        }
        }
    }
    default: {
        RELEASE_ASSERT_NOT_REACHED();
    }
    }
}