@natlibfi/marc-record-validators-melinda 3.2.0 → 3.3.14-alpha.2

package/src/subfield6Utils.js

@@ -0,0 +1,485 @@
+// import createDebugLogger from 'debug';
+// const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield6Utils');
+
+import {add8s, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, isValidSubfield8} from './subfield8Utils';
+import {fieldHasSubfield, fieldToString, fieldsToString, nvdebug, subfieldToString} from './utils';
+
+// NB! Subfield 6 is non-repeatable and it should always comes first!
+// NB! Index size should always be 2 (preceding 0 required for 01..09) However, support for 100+ was added on 2023-02-27.
+// NB! Index value '00' are left as they are (is not paired/indexed/whatever.
+const sf6Regexp = /^[0-9][0-9][0-9]-(?:[0-9][0-9]|[1-9][0-9]+)(?:[^0-9].*)?$/u;
+
+export function isValidSubfield6(subfield) {
+  if (subfield.code !== '6') {
+    return false;
+  }
+  return subfield.value.match(sf6Regexp);
+}
+
+function subfield6GetTag(subfield) {
+  if (isValidSubfield6(subfield)) {
+    return subfield.value.substring(0, 3);
+  }
+  return undefined;
+}
+
+export function subfield6GetOccurrenceNumber(subfield) {
+  if (isValidSubfield6(subfield)) {
+    // Skip "TAG-" prefix. 2023-02-20: removed 2-digit requirement from here...
+    return subfield.value.substring(4).replace(/\D.*$/u, '');
+  }
+  return undefined;
+}
+
+export function subfield6GetOccurrenceNumberAsInteger(subfield) {
+  const index = subfield6GetOccurrenceNumber(subfield);
+  if (index === undefined || index === '00') {
+    return 0;
+  }
+  const result = parseInt(index, 10);
+  //nvdebug(`SF6: ${subfield.value} => ${index} => ${result}`, debug);
+  return result;
+}
+
+export function subfield6ResetOccurrenceNumber(subfield, occurrenceNumber) {
+  if (!isValidSubfield6(subfield)) {
+    return;
+  }
+  const occurrenceNumberAsString = typeof occurrenceNumber === 'number' ? intToOccurrenceNumberString(occurrenceNumber) : occurrenceNumber;
+
+  const newValue = subfield.value.substring(0, 4) + occurrenceNumberAsString + subfield6GetTail(subfield); // eslint-disable-line functional/immutable-data
+  //nvdebug(`Set subfield $6 value from ${subfieldToString(subfield)} to ${newValue}`);
+  subfield.value = newValue; // eslint-disable-line functional/immutable-data
+}
+
+
+function subfield6GetTail(subfield) {
+  if (isValidSubfield6(subfield)) {
+    // Skip "TAG-" prefix. 2023-02-20: removed 2-digit requirement from here...
+    return subfield.value.replace(/^\d+-\d+/u, '');
+  }
+  return '';
+}
+
+export function subfield6HasWantedTagAndOccurrenceNumber(subfield, tagAndOccurrenceNumber) {
+  if (subfield.code !== '6') {
+    return false;
+  }
+  // We could also use generic code and go getTag()+'-'+getIndex() instead of regexp...
+  const key = subfield.value.replace(/^([0-9][0-9][0-9]-[0-9][0-9]+).*$/u, '$1'); // eslint-disable-line prefer-named-capture-group
+  nvdebug(` Compare '${key}' vs '${tagAndOccurrenceNumber}'`);
+  return key === tagAndOccurrenceNumber;
+}
+
+// <= SUBFIELD, FIELD =>
+
+export function fieldGetUnambiguousTag(field) {
+  const tags = field.subfields.filter(sf => subfield6GetTag(sf));
+  if (tags.length === 1) {
+    nvdebug(`   GOT ${tags.length} tag(s): ${subfieldToString(tags[0])}`);
+    return subfield6GetTag(tags[0]);
+  }
+  return undefined;
+}
+
+export function fieldGetUnambiguousOccurrenceNumber(field) {
+  const occurrenceNumbers = field.subfields.filter(sf => subfield6GetOccurrenceNumber(sf));
+  if (occurrenceNumbers.length === 1) {
+    return subfield6GetOccurrenceNumber(occurrenceNumbers[0]);
+  }
+  return undefined;
+}
+
+export function fieldHasOccurrenceNumber(field, occurrenceNumber) {
+  //nvdebug(`${occurrenceNumber} vs ${fieldToString(field)}`);
+  return field.subfields && field.subfields.some(sf => subfield6GetOccurrenceNumber(sf) === occurrenceNumber);
+}
+
+export function fieldResetOccurrenceNumber(field, newOccurrenceNumber, oldOccurrenceNumber = undefined) {
+  field.subfields.forEach(subfield => innerReset(subfield));
+
+  function innerReset(subfield) {
+    // (Optional) Check that this is really the occurrence number we wan't to reseot
+    if (oldOccurrenceNumber !== undefined) {
+      const currOccurrenceNumber = subfield6GetOccurrenceNumber(subfield);
+      if (currOccurrenceNumber !== oldOccurrenceNumber) {
+        return;
+      }
+    }
+    subfield6ResetOccurrenceNumber(subfield, newOccurrenceNumber);
+  }
+}
+
+export function intToOccurrenceNumberString(i) {
+  return i < 10 ? `0${i}` : `${i}`;
+}
+
+export function fieldGetMaxSubfield6OccurrenceNumberAsInteger(field) {
+  // used by reducer!
+  //nvdebug(`Checking subfields $6 from ${JSON.stringify(field)}`);
+  const sf6s = field.subfields ? field.subfields.filter(subfield => isValidSubfield6(subfield)) : [];
+  if (sf6s.length === 0) {
+    return 0;
+  }
+  // There should always be one, but here we check every subfield.
+  //nvdebug(`Got ${field.subfields} $6-subfield(s) from ${JSON.stringify(field)}`, debug);
+  const vals = sf6s.map(sf => subfield6GetOccurrenceNumberAsInteger(sf));
+  return Math.max(...vals);
+}
+
+
+export function fieldHasWantedTagAndOccurrenceNumber(field, tagAndOccurrenceNumber) {
+  return field.subfields && field.subfields.some(sf => subfield6HasWantedTagAndOccurrenceNumber(sf, tagAndOccurrenceNumber));
+}
+
+
+/*
+export function getFieldsWithGivenOccurrenceNumberSubfield6(record, occurrenceNumberAsString) {
+  const record.fields.filter(field => field
+
+  function fieldHasIndex(field, index) {
+    if (!field.subfields) {
+      return false;
+    }
+    return field.subfields.find(sf => isValidSubfield6(sf) && subfieldGetOccurrenceNumber6(sf) === index);
+  }
+}
+*/
+
+
+export function fieldHasValidSubfield6(field) {
+  return field.subfields && field.subfields.some(sf => isValidSubfield6(sf));
+}
+
+
+function isSubfield6Pair(field, otherField) {
+  // No need to log this:
+  //nvdebug(`LOOK for $6-pair:\n ${fieldToString(field)}\n ${fieldToString(otherField)}`);
+  if (!fieldHasValidSubfield6(field) || !fieldHasValidSubfield6(otherField)) {
+    return false;
+  }
+
+  if (!tagsArePairable6(field.tag, otherField.tag)) {
+    //nvdebug(` FAILED. REASON: TAGS NOT PAIRABLE!`);
+    return false;
+  }
+
+
+  const fieldIndex = fieldGetUnambiguousOccurrenceNumber(field);
+  if (fieldIndex === undefined || fieldIndex === '00') {
+    //nvdebug(` FAILED. REASON: NO INDEX FOUND`);
+    return false;
+  }
+
+  const otherFieldIndex = fieldGetUnambiguousOccurrenceNumber(otherField);
+
+
+  if (fieldIndex !== otherFieldIndex) {
+    //nvdebug(` FAILURE: INDEXES: ${fieldIndex} vs ${otherFieldIndex}`);
+    return false;
+  }
+
+  if (fieldGetUnambiguousTag(field) !== otherField.tag || field.tag !== fieldGetUnambiguousTag(otherField)) {
+    //nvdebug(` FAILURE: TAG vs $6 TAG`);
+    return false;
+  }
+  return true;
+
+  function tagsArePairable6(tag1, tag2) {
+    // How to do XOR operation in one line? Well, this is probably more readable...
+    if (tag1 === '880' && tag2 === '880') {
+      return false;
+    }
+    if (tag1 !== '880' && tag2 !== '880') {
+      return false;
+    }
+    return true;
+  }
+}
+
+
+function subfieldSevenToOneOccurrenceNumber(subfield) {
+  if (subfield.code !== '6' || subfield.value.substring(0, 1) !== '7') {
+    return;
+  }
+  subfield.value = `1${subfield.value.substring(1)}`; // eslint-disable-line functional/immutable-data
+}
+
+export function fieldSevenToOneOccurrenceNumber(field) {
+  if (field.tag !== '880') {
+    return;
+  }
+  field.subfields.forEach(sf => subfieldSevenToOneOccurrenceNumber(sf));
+}
+
+
+export function fieldGetOccurrenceNumberPairs(field, candFields) {
+  // NB! TAG!=880 returns 880 fields, TAG==880 returns non-880 field
+  //nvdebug(`  Trying to finds pair for ${fieldToString(field)} in ${candFields.length} fields`);
+  const pairs = candFields.filter(otherField => isSubfield6Pair(field, otherField));
+  if (pairs.length === 0) {
+    nvdebug(`NO PAIRS FOUND FOR '${fieldToString(field)}'`);
+    return pairs;
+  }
+  nvdebug(`${pairs.length} PAIR(S) FOUND FOR '${fieldToString(field)}'`);
+  pairs.forEach(pairedField => nvdebug(`  '${fieldToString(pairedField)}'`));
+  return pairs;
+}
+
+export function fieldGetOccurrenceNumbers(field) {
+  /* eslint-disable */
+  let occurrenceNumbers = [];
+  field.subfields?.forEach(sf => subfieldExtractOccurrenceNumber(sf));
+
+  function subfieldExtractOccurrenceNumber(sf) {
+    if (!isValidSubfield6(sf)) {
+      return;
+    }
+    const occurrenceNumber = subfield6GetOccurrenceNumber(sf);
+    if (occurrenceNumber === '00' || occurrenceNumbers.includes(occurrenceNumber)) {
+      return;
+    }
+    occurrenceNumbers.push(occurrenceNumber);
+  }
+  /* eslint-enable */
+  return occurrenceNumbers;
+}
+
+export function fieldsGetOccurrenceNumbers(fields) {
+  /* eslint-disable */
+  let occurrenceNumbers = [];
+
+  fields.forEach(f => fieldProcessOccurrenceNumbers(f));
+
+  function fieldProcessOccurrenceNumbers(f) {
+    const newOccurrenceNumbers = fieldGetOccurrenceNumbers(f);
+    newOccurrenceNumbers.forEach(occurrenceNumber => {
+      if (!occurrenceNumbers.includes(occurrenceNumber)) {
+        occurrenceNumbers.push(occurrenceNumber);
+      }
+
+    });
+  }
+  /* eslint-enable */
+  return occurrenceNumbers;
+}
+
+/*
+export function fieldGetSubfield6Pair(field, record) {
+  const pairedFields = record.fields.filter(otherField => isSubfield6Pair(field, otherField));
+  if (pairedFields.length !== 1) {
+    return undefined;
+  }
+  // NB! It is theoretically possible to have multiple pairable 880 fields (one for each encoding)
+  nvdebug(`fieldGetSubfield6Pair(): ${fieldToString(field)} => ${fieldToString(pairedFields[0])}`);
+  return pairedFields[0];
+}
+*/
+
+/*
+export function pairAndStringify6(field, record) {
+  const pair6 = fieldGetSubfield6Pair(field, record);
+  if (!pair6) {
+    return fieldToNormalizedString(field);
+  }
+  return fieldsToNormalizedString([field, pair6]);
+}
+*/
+
+// Frequencly list for $6 subfields in 1XX/7XX fields:
+// 231115 100
+// 183832 700
+//  28773 710
+//   2047 711
+//    661 110
+//    341 111
+//    284 130
+//     63 730
+// Thus there's a real risk of ending up with, say, identical 100 vs 700 chains.
+// Semi-hackily support 1XX/7XX-version: 7XX can be deleted if corresponding 1XX exists:
+
+export function is7XX(tag) {
+  return ['700', '710', '711', '730'].includes(tag);
+}
+
+
+function normalizeEntryTag(tag) {
+  if (tag.match(/^[17](?:00|10|11|30)$/u)) {
+    return `X${tag.substring(1)}`;
+  }
+  return tag;
+}
+
+function subfieldToNormalizedString(sf, tag, targetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTagBoolean = false) {
+  // targetLinkingNumber refers to $8.
+  // normalizeEntryTagBoolean refers to 1XX/7XX tag values in subfield $6 value.
+  if (isValidSubfield6(sf)) { // && targetLinkingNumber === 0) {
+    // 1XX/7XX (entry tag) normalization:
+    const tag2 = normalizeEntryTagBoolean ? normalizeEntryTag(tag) : tag;
+
+    const occurrenceNumber = normalizeOccurrenceNumber ? 'XX' : subfield6GetOccurrenceNumber(sf);
+    // If we are normalizing a $8 chain, don't normalize $6 occurrence number!
+    // Replace $6 occurrence number with XX:
+    return ` ‡${sf.code} ${tag2}-${occurrenceNumber}${subfield6GetTail(sf)}`;
+  }
+
+  if (isValidSubfield8(sf)) {
+    const currLinkingNumber = getSubfield8LinkingNumber(sf); //getSubfield8Index(sf);
+    if (targetLinkingNumber > 0 && currLinkingNumber === targetLinkingNumber) {
+      // For $8 we should only XX the index we are looking at...
+      const normVal = sf.value.replace(/^[0-9]+/u, 'XX');
+      return ` ‡${sf.code} ${normVal}`;
+    }
+    return ''; // Other $8 subfields are meaningless in this context
+  }
+  return ` ${subfieldToString(sf)}`; // `‡${sf.code} ${sf.value}`;
+}
+
+export function fieldToNormalizedString(field, targetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTagBoolean = false) {
+  if ('subfields' in field) {
+    const tag2 = normalizeEntryTagBoolean ? normalizeEntryTag(field.tag) : field.tag;
+    return `${tag2} ${field.ind1}${field.ind2}${formatAndNormalizeSubfields(field)}`;
+  }
+  return `${field.tag}    ${field.value}`;
+
+  function formatAndNormalizeSubfields(field) {
+    return field.subfields.map(sf => subfieldToNormalizedString(sf, field.tag, targetLinkingNumber, normalizeOccurrenceNumber, normalizeEntryTagBoolean)).join('');
+  }
+
+}
+
+
+function guessTargetLinkingNumber(fields, defaultTargetLinkingNumber) {
+  if (defaultTargetLinkingNumber !== 0) {
+    return defaultTargetLinkingNumber;
+  }
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
+  return linkingNumbers.length === 1 ? linkingNumbers[0] : 0; // eslint-disable-line no-param-reassign
+}
+
+export function fieldsToNormalizedString(fields, defaultTargetLinkingNumber = 0, normalizeOccurrenceNumber = false, normalizeEntryTag = false) {
+  const targetLinkingNumber = guessTargetLinkingNumber(fields, defaultTargetLinkingNumber);
+
+  nvdebug(`fieldsToNormalizedString: OCC: ${normalizeOccurrenceNumber}`);
+  const strings = fields.map(field => fieldToNormalizedString(field, targetLinkingNumber, normalizeOccurrenceNumber, normalizeEntryTag));
+  strings.sort(); // eslint-disable-line functional/immutable-data
+  return strings.join('\t__SEPARATOR__\t');
+}
+
+
+/*
+
+export function removeField6IfNeeded(field, record, fieldsAsString) {
+  const pairField = fieldGetSubfield6Pair(field, record);
+  const asString = pairField ? fieldsToNormalizedString([field, pairField]) : fieldToNormalizedString(field);
+  nvdebug(`SOURCE: ${asString} -- REALITY: ${fieldToString(field)}`);
+  const tmp = pairField ? fieldToString(pairField) : 'HUTI';
+  nvdebug(`PAIR: ${tmp}`);
+  nvdebug(`BASE:\n ${fieldsAsString.join('\n ')}`);
+  if (!fieldsAsString.includes(asString)) {
+    return;
+  }
+  nvdebug(`Duplicate $6 removal: ${fieldToString(field)}`);
+  record.removeField(field);
+
+  if (pairField === undefined) {
+    return;
+  }
+  nvdebug(`Duplicate $6 removal (pair): ${fieldToString(pairField)}`);
+  record.removeField(pairField);
+}
+*/
+
+function getFirstField(record, fields) {
+  const fieldsAsStrings = fields.map(field => fieldToString(field));
+  //record.fields.forEach((field, i) => nvdebug(`${i}:\t${fieldToString(field)}`));
+  //nvdebug(`getFirstField: ${fieldsAsStrings.join('\t')}`);
+  const i = record.fields.findIndex(field => fieldsAsStrings.includes(fieldToString(field)));
+  if (i > -1) {
+    const field = record.fields[i];
+    //nvdebug(`1st F: ${i + 1}/${record.fields.length} ${fieldToString(field)}`);
+    return field;
+  }
+  return undefined;
+}
+
+function isRelevantSubfield6Chain(fields) {
+  if (fields.length < 2) { // 1 non-880-field and 1+ 880 fields
+    return false;
+  }
+  const non880 = fields.filter(f => f.tag !== '880');
+  if (non880.length !== 1) {
+    return false;
+  }
+
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
+  if (linkingNumbers.length !== 0) {
+    return false;
+  }
+
+  return fields.every(f => fieldHasSubfield(f, '6'));
+}
+
+export function fieldIsFirstFieldInChain(field, chain, record) {
+  // Interpretation of first: position of field in record (however, we might have a duplicate field. See tests...)
+  const firstField = getFirstField(record, chain);
+  if (firstField) {
+    return fieldToString(field) === fieldToString(firstField);
+  }
+  return false;
+
+}
+
+
+export function getAllLinkedSubfield6Fields(field, record) {
+  const fields = get6s(field, record);
+  const moreFields = add8s(fields, record);
+
+  // Currently we don't handle fields with more than one $6 and/or $8 subfield.
+  if (moreFields.length > fields.length) {
+    return []; // Don't fix!
+  }
+  return moreFields;
+}
+
+export function isFirstLinkedSubfield6Field(field, record) {
+  if (!field.subfields) { // Is not a datafield
+    return false;
+  }
+  const chain = getAllLinkedSubfield6Fields(field, record);
+  if (!isRelevantSubfield6Chain(chain)) {
+    nvdebug(`Rejected 6: ${fieldsToString(chain)}`);
+    return false;
+  }
+
+  return fieldIsFirstFieldInChain(field, chain, record);
+}
+
+export function recordGetSubfield6ChainHeads(record) {
+  return record.fields.filter(field => isFirstLinkedSubfield6Field(field, record));
+}
+
+export function recordGetMaxSubfield6OccurrenceNumberAsInteger(record) {
+  // Should we cache the value here?
+  const vals = record.fields.map((field) => fieldGetMaxSubfield6OccurrenceNumberAsInteger(field));
+  return Math.max(...vals);
+}
+
+
+export function get6s(field, candidateFields) { // NB! Convert field to fields!!!
+  // Get all fields with given occurence number
+  const sixes = field.subfields.filter(sf => isValidSubfield6(sf));
+
+  if (sixes.length === 0) {
+    return [field];
+  }
+  nvdebug(`SIXES: ${sixes.length}`);
+  const occurrenceNumbers = sixes.map(sf => subfield6GetOccurrenceNumber(sf)).filter(value => value !== undefined && value !== '00');
+  nvdebug(occurrenceNumbers.join(' -- '));
+
+  const relevantFields = candidateFields.filter(f => occurrenceNumbers.some(o => fieldHasOccurrenceNumber(f, o)));
+  nvdebug(`${fieldToString(field)}: $6-RELFIELDS FOUND: ${relevantFields.length}...`);
+  relevantFields.forEach(f => nvdebug(fieldToString(f)));
+  return relevantFields;
+}
+

package/src/subfield8Utils.js

@@ -0,0 +1,102 @@
+// import createDebugLogger from 'debug';
+// const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield8Utils');
+
+import {fieldToString, nvdebug} from './utils';
+
+const sf8Regexp = /^([1-9][0-9]*)(?:\.[0-9]+)?(?:\\[acprux])?$/u; // eslint-disable-line prefer-named-capture-group
+
+export function isValidSubfield8(subfield) {
+  if (subfield.code !== '8') {
+    return false;
+  }
+
+  //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}'`);
+  const match = subfield.value.match(sf8Regexp);
+  //nvdebug(`   IS VALID $8? '${subfieldToString(subfield)}' vs ${match.length}}`);
+  return match && match.length > 0;
+}
+
+function getSubfield8Value(subfield) {
+  if (!isValidSubfield8(subfield)) {
+    return undefined;
+  }
+  return subfield.value;
+}
+
+export function getSubfield8LinkingNumber(subfield) {
+  const value = getSubfield8Value(subfield);
+  if (value === undefined) {
+    return 0;
+  }
+  return parseInt(value, 10);
+}
+
+
+export function fieldHasLinkingNumber(field, linkingNumber) {
+  if (!field.subfields) {
+    return false;
+  }
+  return field.subfields.some(sf => getSubfield8LinkingNumber(sf) === linkingNumber);
+}
+
+export function recordGetFieldsWithSubfield8LinkingNumber(record, linkingNumber) {
+  if (linkingNumber < 1) {
+    return;
+  }
+  return record.fields.filter(field => fieldHasLinkingNumber(field, linkingNumber));
+}
+
+
+export function fieldsGetAllSubfield8LinkingNumbers(fields) {
+  /* eslint-disable */
+  let subfield8LinkingNumbers = [];
+  fields.forEach(field => {
+    if (!field.subfields) {
+      return;
+    }
+    field.subfields.forEach(sf => {
+      const linkingNumber = getSubfield8LinkingNumber(sf);
+      if (linkingNumber > 0 && !subfield8LinkingNumbers.includes(linkingNumber)) {
+        nvdebug(` LINK8: Add subfield \$8 ${linkingNumber} to seen values list`);
+        subfield8LinkingNumbers.push(linkingNumber);
+      }
+    });
+  });
+
+  return subfield8LinkingNumbers;
+  /* eslint-enable */
+
+}
+
+export function recordGetAllSubfield8LinkingNumbers(record) {
+  return fieldsGetAllSubfield8LinkingNumbers(record.fields);
+}
+
+
+export function add8s(fields, record) {
+  const linkingNumbers = fieldsGetAllSubfield8LinkingNumbers(fields);
+  if (linkingNumbers.length === 0) {
+    return fields;
+  }
+
+  nvdebug(`Linking number(s): ${linkingNumbers.join(', ')}`);
+  linkingNumbers.forEach(number => collectLinkingNumberFields(number));
+
+  fields.forEach(f => nvdebug(`AFTER ADDING 8s: '${fieldToString(f)}'`));
+
+  return fields;
+
+  function collectLinkingNumberFields(linkingNumber) {
+    // Remove existing hits (to avoid field repetition):
+    fields = fields.filter(f => !fieldHasLinkingNumber(f, linkingNumber)); // eslint-disable-line functional/immutable-data, no-param-reassign
+    // Add them and their "sisters" back:
+    const addableFields = record.fields.filter(f => fieldHasLinkingNumber(f, linkingNumber));
+    addableFields.forEach(f => nvdebug(`(RE-?)ADD ${fieldToString(f)}`));
+    fields = fields.concat(addableFields); // eslint-disable-line functional/immutable-data, no-param-reassign
+
+  }
+}
+
+export function fieldHasValidSubfield8(field) {
+  return field.subfields && field.subfields.some(sf => isValidSubfield8(sf));
+}

package/src/typeOfDate-008.js

@@ -0,0 +1,40 @@
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/typeOfDate-008');  // eslint-disable-line
+
+export default function () {
+  return {
+    description: 'Validates 008 06',
+    validate,
+    fix
+  };
+
+  function validate(record) {
+    const [f008] = record.get(/008/u);
+    const c06 = f008.value.substring(6, 7);
+    const c1114 = f008.value.substring(11, 15);
+    // if 008 06 = s, and 11-14 = #### (not year/digits)
+    if (c06 === 't' && !(/[0-9u]{4}/u).test(c1114)) {
+      debug('is t and not valid 1114');
+      return {valid: false, message: 'Invalid 008 06'};
+    }
+
+    return {valid: true};
+  }
+
+  function fix(record) {
+    //  LDR/06=t ja 11-14=####, niin LDR/06 muutetaan s:ksi
+    const [f008] = record.pop(/008/u); // eslint-disable-line functional/immutable-data
+    const c06 = f008.value.substring(6, 7);
+    const c1114 = f008.value.substring(11, 15);
+    // if 008 06 = s, and 11-14 = #### (not year/digits)
+    if (c06 === 't' && !(/[0-9u]{4}/u).test(c1114)) {
+      f008.value = `${f008.value.substring(0, 6)}s${f008.value.substring(7)}`; // eslint-disable-line functional/immutable-data
+      record.insertField(f008);
+      return true;
+    }
+
+    record.insertField(f008);
+    return true;
+  }
+}

package/src/typeOfDate-008.spec.js

@@ -0,0 +1,47 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './typeOfDate-008';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+import createDebugLogger from 'debug';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'typeOfDate-008'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/typeOfDate-008:test');  // eslint-disable-line
+
+async function testValidatorFactory() {
+  const validator = await validatorFactory();
+
+  expect(validator)
+    .to.be.an('object')
+    .that.has.any.keys('description', 'validate');
+
+  expect(validator.description).to.be.a('string');
+  expect(validator.validate).to.be.a('function');
+}
+
+async function callback({getFixture, fix = false}) {
+  const validator = await validatorFactory();
+  const record = new MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    expect(result).to.eql(expectedResult);
+    return;
+  }
+
+  await validator.fix(record);
+  expect(record).to.eql(expectedResult);
+}