@natlibfi/melinda-record-matching 4.4.0-alpha.1 → 5.0.0-alpha.2

package/src/candidate-search/{index.spec.js → index.test.js}

@@ -1,37 +1,10 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of melinda-record-matching-js
-*
-* melinda-record-matching-js program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
-*
-* melinda-record-matching-js is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Affero General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* @licend  The above is the entire license notice
-* for the JavaScript code in this file.
-*
-*/
-
-import {expect} from 'chai';
+import assert from 'node:assert';
+import {describe} from 'node:test';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen-http-client';
 import {MarcRecord} from '@natlibfi/marc-record';
 import {Error as MatchingError} from '@natlibfi/melinda-commons';
-import createSearchInterface, {CandidateSearchError} from '.';
+import createSearchInterface, {CandidateSearchError} from './index.js';
 import createDebugLogger from 'debug';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:test');
@@ -39,13 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-sea
 describe('candidate-search', () => {
   generateTests({
     callback,
-    path: [__dirname, '..', '..', 'test-fixtures', 'candidate-search', 'index'],
+    path: [import.meta.dirname, '..', '..', 'test-fixtures', 'candidate-search', 'index'],
     recurse: false,
     fixura: {
       reader: READERS.JSON
     }
   });
 
+  // eslint-disable-next-line max-statements
   async function callback({getFixture, factoryOptions, searchOptions, expectedFactoryError = false, expectedSearchError = false, enabled = true}) {
     const url = 'http://foo.bar';
 
@@ -54,16 +28,31 @@ describe('candidate-search', () => {
     }
 
     if (expectedFactoryError) {
+      debug(`We're expecting an error`);
       if (expectedFactoryError.isCandidateSearchError) {
-        expect(() => createSearchInterface({...formatFactoryOptions(), url})).to.throw(CandidateSearchError, new RegExp(expectedFactoryError, 'u'));
-        return;
+        try {
+          const result = await createSearchInterface({...formatFactoryOptions(), url});
+          debug(result);
+        } catch (err) {
+          assert.equal(err instanceof CandidateSearchError, true);
+          assert.match(err.message, new RegExp(expectedFactoryError.message));
+        } finally {
+          return;
+        }
       }
 
-      expect(() => createSearchInterface({...formatFactoryOptions(), url})).to.throw(new RegExp(expectedFactoryError, 'u'));
-      return;
+      try {
+        const result = await createSearchInterface({...formatFactoryOptions(), url});
+        debug(result);
+      } catch (err) {
+        assert.equal(err instanceof Error, true);
+        assert.match(err.message, new RegExp(expectedFactoryError.message));
+      } finally {
+        return;
+      }
     }
 
-    const search = createSearchInterface({...formatFactoryOptions(), url});
+    const {search} = await createSearchInterface({...formatFactoryOptions(), url});
     await iterate({searchOptions, expectedSearchError});
 
     function formatFactoryOptions() {
@@ -79,30 +68,29 @@ describe('candidate-search', () => {
     async function iterate({searchOptions, expectedSearchError, expectedErrorStatus, count = 1}) {
       const expectedResults = getFixture(`expectedResults${count}.json`);
 
-      if (expectedSearchError) { // eslint-disable-line functional/no-conditional-statements
+      if (expectedSearchError) {
         try {
           await search(searchOptions);
           throw new Error('Expected an error');
         } catch (err) {
           debug(`Got an error: ${err}`);
-          expect(err).to.be.an('error');
+          assert(err instanceof Error);
           const errorMessage = err instanceof MatchingError ? err.payload.message : err.message;
           const errorStatus = err instanceof MatchingError ? err.status : undefined;
           debug(`errorMessage: ${errorMessage}, errorStatus: ${errorStatus}`);
-          expect(errorMessage).to.match(new RegExp(expectedSearchError, 'u'));
+          assert.match(errorMessage, new RegExp(expectedSearchError, 'u'));
 
           if (expectedErrorStatus) {
-            expect(errorStatus).to.be(expectedErrorStatus);
+            assert.equal(errorStatus, expectedErrorStatus);
             return;
           }
           return;
         }
       }
 
-      // eslint-disable-next-line functional/no-conditional-statements
       if (!expectedSearchError) {
         const results = await search(searchOptions);
-        expect(formatResults(results)).to.eql(expectedResults);
+        assert.deepStrictEqual(formatResults(results), expectedResults);
       }
 
       function formatResults(results) {
@@ -112,7 +100,6 @@ describe('candidate-search', () => {
           records: results.records.map(({record, id}) => ({id, record: record.toObject()}))
         };
       }
-
     }
   }
 });

package/src/candidate-search/query-list/bib.js

@@ -1,34 +1,6 @@
-
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of melinda-record-matching-js
-*
-* melinda-record-matching-js program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
-*
-* melinda-record-matching-js is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Affero General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* @licend  The above is the entire license notice
-* for the JavaScript code in this file.
-*
-*/
 import createDebugLogger from 'debug';
-import {toQueries} from '../candidate-search-utils';
-import {getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues, testStringOrNumber} from '../../matching-utils';
+import {toQueries} from '../candidate-search-utils.js';
+import {getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues, testStringOrNumber} from '../../matching-utils.js';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query');
 
@@ -151,7 +123,13 @@ export function bibMelindaIds(record) {
 // bibHostComponents returns host id from the first subfield $w of first field f773, see test-fixtures 04 and 05
 // bibHostComponents should search all 773 $ws for possible host id, but what should it do in case of multiple host ids?
 export function bibHostComponents(record) {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibHostComponents');
+  const debugData = debug.extend('data');
+  debug(`Creating queries for hostIds`);
+
   const id = getHostId();
+  debugData(`Found id: ${JSON.stringify(id)}`);
+
   return testStringOrNumber(id) ? [`melinda.partsofhost=${id}`] : [];
 
   function getHostId() {
@@ -195,18 +173,25 @@ export function bibTitleAuthor(record) {
 }
 
 export function bibTitleAuthorYear(record) {
-  debug('bibTitleAuthorYear');
+  debug('bibTitleAuthorYearAlternates');
   // We use onlyTitleLength that is longer than our formatted length to
   // get an author or an publisher always
 
   return bibTitleAuthorPublisher({record, onlyTitleLength: 100, addYear: true});
 }
 
-export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = false}) {
-  debug('bibTitleAuthorPublisher');
-  const title = getTitle();
-  const booleanStartWords = ['and', 'or', 'nor', 'not'];
+export function bibTitleAuthorYearAlternates(record) {
+  debug('bibTitleAuthorYearAlternates');
+  // We use onlyTitleLength that is longer than our formatted length to
+  // get an author or an publisher always
+  const origQueryList = bibTitleAuthorPublisher({record, onlyTitleLength: 100, addYear: true, alternates: true, alternateQueries: []});
+  debug(`${JSON.stringify(origQueryList)}`);
+  return {queryList: Array.from(origQueryList).reverse(), queryListType: 'alternates'};
+}
 
+export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = false, alternates = false, alternateQueries = []}) {
+  debug(`bibTitleAuthorPublisher, onlyTitleLength: ${onlyTitleLength}, addYear: ${addYear}, alternates: ${alternates}`);
+  const title = getTitle();
   if (testStringOrNumber(title)) {
     const formatted = String(title)
       .replace(/[^\w\s\p{Alphabetic}]/gu, '')
@@ -217,10 +202,10 @@ export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = fals
       .trim();
 
     // use word search for titles starting with a boolean
-    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+    const useWordSearch = checkUseWordSearch(formatted);
     // Prevent too many matches / SRU crashing by having a minimum length
     // Note that currently this fails matching if there are no matches from previous matchers
-    if (formatted.length >= onlyTitleLength) {
+    if (formatted.length >= onlyTitleLength && !alternates) {
       return [`dc.title="${useWordSearch ? '' : '^'}${formatted}*"`];
     }
     const queryIsOkAlone = formatted.length >= 5;
@@ -228,45 +213,50 @@ export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = fals
     // use word search without ending * also in combination searches to avoid SRU-server crashes [MRA-189]
     const query = `dc.title="${useWordSearch || !queryIsOkAlone ? '' : '^'}${formatted}${queryIsOkAlone ? '*' : ''}"`;
     debug(`query: ${query}`);
-    return addAuthorsToSearch({query, queryIsOkAlone, addYear});
+    const newAlternateQueries = alternates ? [...alternateQueries, query] : alternateQueries;
+
+    return addAuthorsToSearch({query, queryIsOkAlone, addYear, alternates, alternateQueries: newAlternateQueries});
   }
 
   return [];
 
-  function addAuthorsToSearch({query, queryIsOkAlone = false, addYear = false}) {
+  function addAuthorsToSearch({query, queryIsOkAlone = false, addYear = false, alternates = false, alternateQueries = []}) {
     debug('addAuthorsToSearch');
     const [authorQuery] = bibAuthors(record);
     if (authorQuery !== undefined) {
       if (addYear) {
-        return addYearToSearch({query: `${authorQuery} AND ${query}`, queryIsOkAlone: true});
+        const newAlternateQueries = alternates ? [...alternateQueries, `${authorQuery} AND ${query}`] : alternateQueries;
+        return addYearToSearch({query: `${authorQuery} AND ${query}`, queryIsOkAlone: true, alternates, alternateQueries: newAlternateQueries});
       }
-      return [`${authorQuery} AND ${query}`];
+      return alternates ? alternateQueries : [`${authorQuery} AND ${query}`];
     }
-    return addPublisherToSearch({query, queryIsOkAlone, addYear});
+    return addPublisherToSearch({query, queryIsOkAlone, addYear, alternates, alternateQueries});
     //return [];
   }
 
-  function addPublisherToSearch({query, queryIsOkAlone = false, addYear = false}) {
+  function addPublisherToSearch({query, queryIsOkAlone = false, addYear = false, alternates = false, alternateQueries = []}) {
     const [publisherQuery] = bibPublishers(record);
     if (publisherQuery !== undefined) {
       if (addYear) {
-        return addYearToSearch({query: `${publisherQuery} AND ${query}`, queryIsOkAlone: true});
+        const newAlternateQueries = alternates ? [...alternateQueries, `${publisherQuery} AND ${query}`] : alternateQueries;
+        return addYearToSearch({query: `${publisherQuery} AND ${query}`, queryIsOkAlone: true, alternates, alternateQueries: newAlternateQueries});
       }
-      return [`${publisherQuery} AND ${query}`];
+      return alternates ? alternateQueries : [`${publisherQuery} AND ${query}`];
     }
     if (queryIsOkAlone && !addYear) {
-      return [`${query}`];
+      return alternates ? alternateQueries : [`${query}`];
     }
-    return addYearToSearch({query, queryIsOkAlone});
+    return addYearToSearch({query, queryIsOkAlone, alternates, alternateQueries});
   }
 
-  function addYearToSearch({query, queryIsOkAlone = false}) {
+  function addYearToSearch({query, queryIsOkAlone = false, alternates = false, alternateQueries = []}) {
     const [yearQuery] = bibYear(record);
     if (yearQuery !== undefined) {
-      return [`${yearQuery} AND ${query}`];
+      const newAlternateQueries = alternates ? [...alternateQueries, `${yearQuery} AND ${query}`] : alternateQueries;
+      return alternates ? newAlternateQueries : [`${yearQuery} AND ${query}`];
     }
     if (queryIsOkAlone) {
-      return [`${query}`];
+      return alternates ? alternateQueries : [`${query}`];
     }
     return [];
   }
@@ -296,8 +286,6 @@ export function bibAuthors(record) {
   //debugData(record);
 
   const author = getAuthor(record);
-  const booleanStartWords = ['and', 'or', 'nor', 'not'];
-
 
   if (testStringOrNumber(author)) {
     const formatted = String(author)
@@ -309,7 +297,7 @@ export function bibAuthors(record) {
       .trim();
 
     // use word search for authors starting with a boolean
-    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+    const useWordSearch = checkUseWordSearch(formatted);
     // Prevent too many matches by having a minimum length
     debugData(`Author string: ${formatted}`);
     if (formatted.length >= 5) {
@@ -384,7 +372,6 @@ export function bibYear(record) {
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibYear');
   const debugData = debug.extend('data');
   debug(`Creating query for the publishing year`);
-  debugData(record);
 
   const year = getYear(record);
   if (year) {
@@ -393,11 +380,23 @@ export function bibYear(record) {
   return [];
 
   function getYear(record) {
-    const value = record.get(/^008$/u)?.[0]?.value || undefined;
+    const [f008] = record.get(/^008$/u);
+    if (f008 === undefined) {
+      debug('f008 missing');
+      return false;
+    }
+
+    debugData(`f008: ${JSON.stringify(f008)}`);
+    const {value} = f008;
     return testStringOrNumber(value) ? String(value).slice(7, 11) : undefined;
   }
 }
 
+export function checkUseWordSearch(formatted) {
+  // Note: add a space to startWords to catch just actual boolean words
+  const booleanStartWords = ['and ', 'or ', 'nor ', 'not '];
+  return booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+}
 
 export function bibStandardIdentifiers(record) {
 

package/src/candidate-search/query-list/bib.test.js

@@ -0,0 +1,38 @@
+import assert from 'node:assert';
+import {describe} from 'node:test';
+import createDebugLogger from 'debug';
+import generateTests from '@natlibfi/fixugen';
+import {READERS} from '@natlibfi/fixura';
+import {MarcRecord} from '@natlibfi/marc-record';
+import * as generators from './bib.js';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibHostComponents:test');
+const debugData = debug.extend('data');
+
+describe('candidate-search/query-list/bib/', () => {
+  generateTests({
+    path: [import.meta.dirname, '..', '..', '..', 'test-fixtures', 'candidate-search', 'query-list', 'bib'],
+    useMetadataFile: true,
+    fixura: {
+      reader: READERS.JSON
+    },
+    callback: ({type, inputRecord, expectedQuery, expectedQueryListType, enabled = true}) => {
+      const generate = generators[type];
+      const record = new MarcRecord(inputRecord, {subfieldValues: false});
+
+      if (!enabled) {
+        return;
+      }
+
+      const result = generate(record);
+      debugData(`Result: ${JSON.stringify(result)}`);
+
+      if (result.queryListType) {
+        assert.deepStrictEqual(result.queryList, expectedQuery);
+        assert.equal(result.queryListType, expectedQueryListType);
+        return;
+      }
+      assert.deepStrictEqual(result, expectedQuery);
+    }
+  });
+});

package/src/candidate-search/query-list/component.js

@@ -0,0 +1,127 @@
+import createDebugLogger from 'debug';
+import {promisify} from 'util';
+import {toQueries} from '../candidate-search-utils.js';
+import {getSubfieldValues, testStringOrNumber, toMelindaIds} from '../../matching-utils.js';
+
+const setTimeoutPromise = promisify(setTimeout); // eslint-disable-line
+
+export function hostIdMelinda(record) {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:hostIdMelinda');
+  const debugData = debug.extend('data'); // eslint-disable-line
+  debug(`Creating query for the Melinda Id host`);
+
+  const ids = hostId(record);
+  if (ids.length > 0) {
+    return toQueries(ids, 'melinda.partsofhost');
+  }
+
+  debug(`No valid Melinda Id host found`);
+  return [];
+
+  function hostId(record) {
+    // Multi 773 handling
+    const f773s = record.get(/^773$/u)
+      .filter(f773 => f773.subfields.some(sub => sub.code === 'w' && (/\(FI-MELINDA\).*/ui).test(sub.value)));
+
+    if (f773s.length === 0) {
+      return false;
+    }
+
+    // Multi $w handling
+    // $w (prefix)<id> handling
+    // $w <id> & $w (prefix)<id> Match
+    const melindaIds = f773s.map(f773 => toMelindaIds(f773, ['w'])).flat()
+      .filter(value => testStringOrNumber(value)) // drop invalid values
+      .filter((value, index, array) => array.indexOf(value) === index); // unique values;
+    return melindaIds;
+  }
+}
+
+export async function hostIdOtherSource(record, client) {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:hostIdOtherSource');
+  const debugData = debug.extend('data'); // eslint-disable-line
+  debug(`Creating query for the Other source Id host`);
+
+  const ids = getHostIds(record);
+  const otherSources = getOtherSources(record);
+  if (ids.length > 0 && otherSources.length > 0) {
+    const otherSourceIds = ids.map(id => otherSources.map(source => `${id}${source}`)).flat();
+    const melindaHostQueries = await handleSruCalls(otherSourceIds);
+    debug(JSON.stringify(melindaHostQueries));
+
+    return melindaHostQueries;
+  }
+
+  debug(`No valid other source hosts found`);
+  return [];
+
+
+  function getHostIds(record) {
+    const f773s = record.get(/^773$/u)
+      .filter(f773 => f773.subfields.some(sub => sub.code === 'w' && !(/\(FI-MELINDA\).*/ui).test(sub.value)));
+    if (f773s.length === 0) {
+      return false;
+    }
+
+    // Multi 773 handling
+    const subfieldWs = f773s
+      .map(f773 => {
+        debugData(`f773: ${JSON.stringify(f773)}`);
+        return getSubfieldValues(f773, 'w').flat();
+      }).flat();
+
+    // Multi $w handling
+    // $w (prefix)<id> handling
+    // $w <id> & $w (prefix)<id> Match
+    const ids = subfieldWs.map(value => `${value}`.replace(/\(FI-.*\)/ui, '')) // remove prefixes
+      .filter(value => testStringOrNumber(value)) // drop invalid values
+      .filter((value, index, array) => array.indexOf(value) === index); // unique values
+
+    return ids;
+  }
+
+  function getOtherSources(record) {
+    const fSids = record.get('SID');
+    return fSids.map(field => getSubfieldValues(field, 'b'));
+  }
+
+  async function handleSruCalls(otherSourceIds, ids = []) {
+    const [otherSourceId, ...rest] = otherSourceIds;
+
+    if (otherSourceId === undefined) {
+      debug(`host ids: ${ids}`);
+      const validIds = ids.filter(id => id);
+      return toQueries(validIds, 'melinda.partsofhost');
+    }
+
+    const otherSourceHostQuery = await toQueries([otherSourceId], 'melinda.sourceid');
+    const id = await new Promise((resolve, reject) => {
+      debug(`Searching for hosts with query: ${otherSourceHostQuery}`);
+      let recordId;
+
+      client.searchRetrieve(otherSourceHostQuery)
+        .on('error', err => {
+          debug(`SRU error for query: ${otherSourceHostQuery}: ${err}`);
+          reject(err);
+        })
+        .on('end', async () => {
+          try {
+            debug(`Searching for hosts: done`);
+            await setTimeoutPromise(10);
+            resolve(recordId);
+          } catch (err) {
+            debug(`Error caught on END`);
+            reject(err);
+          }
+        })
+        .on('record', record => {
+          const [field] = record.get(/^001$/u);
+          debug(field);
+          recordId = field.value ? field.value : '';
+        });
+    });
+
+    return handleSruCalls(rest, [...ids, id]);
+  }
+}
+

package/src/candidate-search/query-list/index.js

@@ -1,32 +1,9 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of melinda-record-matching-js
-*
-* melinda-record-matching-js program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
-*
-* melinda-record-matching-js is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Affero General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* @licend  The above is the entire license notice
-* for the JavaScript code in this file.
-*
-*/
-
-import * as bib from './bib';
+import * as bib from './bib.js';
+import * as component from './component.js';
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:index');
+const debugData = debug.extend('data');
 
 export const searchTypes = {
   bib: {
@@ -35,22 +12,41 @@ export const searchTypes = {
     title: 'bibTitle', // title ( + first author + first publisher if needed)
     titleAuthor: 'bibTitleAuthor', // title + first author (or first publisher if no author)
     titleAuthorYear: 'bibTitleAuthorYear', // title + first author (or first publisher if no author), publishing year
+    titleAuthorYearAlternates: 'bibTitleAuthorYearAlternates', // title + first author (or first publisher if no author), publishing year
     melindaId: 'bibMelindaIds',
     sourceIds: 'bibSourceIds'
     //DEVELOP: bibContent: 'bibContent'
+  },
+  component: {
+    hostIdMelinda: 'hostIdMelinda', // 773 $w (FI-MELINDA)
+    hostIdOtherSource: 'hostIdOtherSource', // 773 $w !(FI-MELINDA)
+    hostIsbn: 'hostIsbn' // 773 $z
   }
 };
 
-export default (record, searchSpec) => {
-  const extractors = {...bib};
+export default async (record, searchSpec, client) => {
+  const extractors = {...bib, ...component};
+  debugData(`extractors: ${JSON.stringify(extractors)}`);
+  debugData(`searchSpec: ${JSON.stringify(searchSpec)}`);
+
+  const qExtractors = searchSpec.map(generateQueryExtractor);
+  const results = await handleQextractors(qExtractors);
+  return results;
+
+  async function handleQextractors(qExtractors, results = []) {
+    const [qExtractor, ...rest] = qExtractors;
 
-  return searchSpec
-    .map(generateQueryExtractor)
-    .map(cb => cb(record))
-    .flat();
+    if (qExtractor === undefined) {
+      return results.flat();
+    }
+
+    const result = await qExtractor(record, client);
+    return handleQextractors(rest, [...results, result]);
+  }
 
   function generateQueryExtractor(type) {
     if (extractors[type]) {
+      //debugData(`${JSON.stringify(extractors[type])}`);
       return extractors[type];
     }