Function transformRecordStream

js/botasaurus-server-js/src/views.ts:338–397

(targetFields: (Field | CustomField | ExpandDictField | ExpandListField)[], record: any)

}

function* transformRecordStream(targetFields: (Field | CustomField | ExpandDictField | ExpandListField)[], record: any): Generator<any> {
    let expandedRecords: any[] = [{}]

    for (let i = 0; i < targetFields.length; i++) {
        const field = targetFields[i]

        if (field instanceof Field) {
            const value = record[field.key]
            const result = field.map ? field.map(value, record) : value
            for (const expandedRecord of expandedRecords) {
                expandedRecord[field.outputKey] = result
            }
        } else if (field instanceof CustomField) {
            const result = field.map(record)
            for (const expandedRecord of expandedRecords) {
                expandedRecord[field.outputKey] = result
            }
        } else if (field instanceof ExpandDictField) {
            const nestedFieldValues = createNestedFieldValues(record, field)
            for (const expandedRecord of expandedRecords) {
                Object.assign(expandedRecord, nestedFieldValues)
            }
        } else if (field instanceof ExpandListField) {
            const nestedList = record[field.key] || []
            const remainingFields = targetFields.slice(i + 1)

            for (const item of nestedList) {
                for (const baseExpandedRecord of expandedRecords) {
                    const newRecord = { ...baseExpandedRecord }
                    for (const nestedField of field.fields) {
                        if (nestedField instanceof Field) {
                            const value = item[nestedField.key]
                            newRecord[nestedField.outputKey] = nestedField.map ? nestedField.map(value, item, record) : value
                        } else if (nestedField instanceof CustomField) {
                            newRecord[nestedField.outputKey] = nestedField.map(item, record)
                        } else if (nestedField instanceof ExpandDictField) {
                            Object.assign(newRecord, createNestedFieldValuesListed(item, nestedField, record))
                        }
                    }
                    for (const rf of remainingFields) {
                        if (rf instanceof Field) {
                            const value = record[rf.key]
                            newRecord[rf.outputKey] = rf.map ? rf.map(value, record) : value
                        } else if (rf instanceof CustomField) {
                            newRecord[rf.outputKey] = rf.map(record)
                        } else if (rf instanceof ExpandDictField) {
                            Object.assign(newRecord, createNestedFieldValues(record, rf))
                        }
                    }
                    yield newRecord
                }
            }
            return
        }
    }

    for (const r of expandedRecords) {
        yield r