proskomma-core 0.9.10 → 0.9.13

package/src/graph/mutations/tags.cjs

@@ -0,0 +1,120 @@
+const utils = require('../../util/index.cjs');
+
+const tagMutationsSchemaString = `
+  """Add one or more tags to a docSet, if they are not already present"""
+  addDocSetTags(
+    """The id of the docSet to which the tags will be added"""
+    docSetId: String!
+    """A list of tags to be added"""
+    tags: [String]!
+  ): [String!]!
+  """Add one or more tags to a document, if they are not already present"""
+  addDocumentTags(
+    """The id of the docSet containing the document to which the tags will be added"""
+    docSetId: String!
+    """The id of the document to which the tags will be added"""
+    documentId: String!
+    """A list of tags to be added"""
+    tags: [String]!
+  ): [String!]
+  """Add one or more tags to a sequence, if they are not already present"""
+  addSequenceTags(
+    """The id of the docSet containing the document containing the sequence to which the tags will be added"""
+    docSetId: String!
+    """The id of the document containing the sequence to which the tags will be added"""
+    documentId: String!
+    """The id of the sequence to which the tags will be added"""
+    sequenceId: String!
+    """A list of tags to be added"""
+    tags: [String]!
+  ) : [String!]
+  """Remove one or more tags from a docSet, if they are present"""
+  removeDocSetTags(
+    """The id of the docSet from which the tags will be removed"""
+    docSetId: String!
+    """A list of tags to be removed"""
+    tags: [String]!
+  ): [String!]
+  """Remove one or more tags from a document, if they are present"""
+  removeDocumentTags(
+    """The id of the docSet containing the document from which the tags will be removed"""
+    docSetId: String!
+    """The id of the document from which the tags will be removed"""
+    documentId: String!
+    """A list of tags to be removed"""
+    tags: [String]!
+  ): [String!]
+  """Remove one or more tags from a sequence, if they are present"""
+  removeSequenceTags(
+    """The id of the docSet containing the document containing the sequence from which the tags will be removed"""
+    docSetId: String!
+    """The id of the document containing the sequence from which the tags will be removed"""
+    documentId: String!
+    """The id of the sequence from which the tags will be removed"""
+    sequenceId: String!
+    """A list of tags to be removed"""
+    tags: [String]!
+  ) : [String!]
+`;
+
+const tagMutationsResolvers = {
+  addDocSetTags: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+
+    for (const tag of args.tags) {
+      docSet.addTag(tag);
+    }
+    return Array.from(docSet.tags);
+  },
+  addDocumentTags: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+    const document = docSet.processor.documents[args.documentId];
+
+    for (const tag of args.tags) {
+      document.addTag(tag);
+    }
+    return Array.from(document.tags);
+  },
+  addSequenceTags: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+    const document = docSet.processor.documents[args.documentId];
+    const sequence = document.sequences[args.sequenceId];
+
+    for (const tag of args.tags) {
+      utils.tags.addTag(sequence.tags, tag);
+    }
+    return Array.from(sequence.tags);
+  },
+  removeDocSetTags: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+
+    for (const tag of args.tags) {
+      docSet.removeTag(tag);
+    }
+    return Array.from(docSet.tags);
+  },
+  removeDocumentTags: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+    const document = docSet.processor.documents[args.documentId];
+
+    for (const tag of args.tags) {
+      document.removeTag(tag);
+    }
+    return Array.from(document.tags);
+  },
+  removeSequenceTags: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+    const document = docSet.processor.documents[args.documentId];
+    const sequence = document.sequences[args.sequenceId];
+
+    for (const tag of args.tags) {
+      utils.tags.removeTag(sequence.tags, tag);
+    }
+    return Array.from(sequence.tags);
+  },
+};
+
+module.exports = {
+  tagMutationsSchemaString,
+  tagMutationsResolvers,
+};

package/src/graph/mutations/update.cjs

@@ -0,0 +1,210 @@
+const { PipelineHandler } = require('proskomma-json-tools');
+const { remakeBlocks } = require('../lib/remake_blocks.cjs');
+const pipelines = require('../../pipelines/perf2x/index.cjs');
+const customTransforms = require('../../transforms/index.cjs');
+
+const updateMutationsSchemaString = `
+  """Replaces the items of a block with a new set of items"""
+  updateItems(
+    """The id of the docSet containing the document containing the sequence containing the block for which the items will be updated"""
+    docSetId: String!
+    """The id of the document containing the sequence containing the block for which the items will be updated"""
+    documentId: String!
+    """The id of the sequence containing the block for which the items will be updated (defaults to the main sequence)"""
+    sequenceId: String
+    """The zero-indexed number of the block for which the items will be updated"""
+    blockPosition: Int!
+    """The new content for the block as item objects"""
+    items: [InputItemObject!]
+    """BlockGrafts for the block as item objects"""
+    blockGrafts: [InputItemObject!]
+    """Optional blockScope for the block as an item object"""
+    blockScope: InputItemObject
+  ): Boolean!
+  """Replaces all the blocks of a sequence with a new set of blocks"""
+  updateAllBlocks(
+    """The id of the docSet containing the document containing the sequence for which the blocks will be updated"""
+    docSetId: String!
+    """The id of the document containing the sequence for which the blocks will be updated"""
+    documentId: String!
+    """The id of the sequence for which the blocks will be updated (defaults to the main sequence)"""
+    sequenceId: String
+    """The JSON describing blocks"""
+    blocksSpec: [inputBlockSpec!]!
+  ): Boolean!
+  """Replaces all the blocks of a sequence with a new set of blocks derived from PERF"""
+  updateSequenceFromPerf(
+    """The id of the docSet containing the document containing the sequence for which the blocks will be updated"""
+    docSetId: String!
+    """The id of the document containing the sequence for which the blocks will be updated"""
+    documentId: String!
+    """The id of the sequence for which the blocks will be updated (defaults to the main sequence)"""
+    sequenceId: String
+    """The JSON describing blocks"""
+    perf: String!
+  ): Boolean!
+  """Garbage collects unused sequences within a document. (You probably don\\'t need to do this.)"""
+  gcSequences(
+    """The id of the docSet containing the document to be garbage collected"""
+    docSetId: String!
+    """The id of the document to be garbage collected"""
+    documentId: String!
+  ) : Boolean!
+ 
+`;
+const updateMutationsResolvers = {
+  updateItems: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+
+    if (!docSet) {
+      throw new Error(`DocSet '${args.docSetId}' not found`);
+    }
+
+    if (!args.items) {
+      throw new Error('Must provide items');
+    }
+
+    const itemsResult = docSet.updateItems(
+      args.documentId,
+      args.sequenceId,
+      args.blockPosition,
+      args.items,
+    );
+
+    if (!itemsResult) {
+      return false;
+    }
+
+    if (args.blockGrafts) {
+      const bgResult = docSet.updateBlockGrafts(
+        args.documentId,
+        args.sequenceId,
+        args.blockPosition,
+        args.blockGrafts,
+      );
+
+      if (!bgResult) {
+        return false;
+      }
+    }
+
+    if (args.blockScope) {
+      const bsResult = docSet.updateBlockScope(
+        args.documentId,
+        args.sequenceId,
+        args.blockPosition,
+        args.blockScope,
+      );
+
+      if (!bsResult) {
+        return false;
+      }
+    }
+    return true;
+  },
+  updateAllBlocks: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+
+    if (!docSet) {
+      throw new Error(`DocSet '${args.docSetId}' not found`);
+    }
+
+    const document = root.documents[args.documentId];
+
+    if (!document) {
+      throw new Error(`Document '${args.documentId}' not found`);
+    }
+
+    const sequence = document.sequences[args.sequenceId || document.mainId];
+
+    if (!sequence) {
+      throw new Error(`Sequence '${args.sequenceId || document.mainId}' not found`);
+    }
+    remakeBlocks(docSet, document, sequence, args.blocksSpec);
+    document.buildChapterVerseIndex();
+    return true;
+  },
+  updateSequenceFromPerf: async (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+
+    if (!docSet) {
+      throw new Error(`DocSet '${args.docSetId}' not found`);
+    }
+
+    const document = root.documents[args.documentId];
+
+    if (!document) {
+      throw new Error(`Document '${args.documentId}' not found`);
+    }
+
+    const sequence = document.sequences[args.sequenceId || document.mainId];
+
+    if (!sequence) {
+      throw new Error(`Sequence '${args.sequenceId || document.mainId}' not found`);
+    }
+
+    const sequencePerf = JSON.parse(args.perf);
+    const perf = {
+      'schema': {
+        'structure': 'flat',
+        'structure_version': '0.3.0',
+        'constraints': [
+          {
+            'name': 'perf',
+            'version': '0.3.0',
+          },
+        ],
+      },
+      'metadata': {
+        'translation': {},
+        'document': {},
+      },
+      'sequences': {},
+      'main_sequence_id': args.sequenceId,
+    };
+    perf.sequences[args.sequenceId] = sequencePerf;
+
+    let blocksSpec = {};
+
+    try {
+      const pipelineHandler = new PipelineHandler({
+        pipelines:pipelines,
+        transforms:customTransforms,
+        proskomma:root,
+      });
+      const output = await pipelineHandler.runPipeline('perf2PkJsonPipeline', { perf });
+      blocksSpec = Object.values(output.pkJson)[0];
+    } catch (err) {
+      console.error('pipelineHandler Error :\n', err);
+      return false;
+    }
+    remakeBlocks(docSet, document, sequence, blocksSpec);
+    document.buildChapterVerseIndex();
+    return true;
+  },
+  gcSequences: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+
+    if (!docSet) {
+      throw new Error(`DocSet '${args.docSetId}' not found`);
+    }
+
+    const document = root.documents[args.documentId];
+
+    if (!document) {
+      throw new Error(`Document '${args.documentId}' not found`);
+    }
+
+    if (document.gcSequences()) {
+      docSet.rehash();
+      return true;
+    } else {
+      return false;
+    }
+  },
+};
+
+module.exports = {
+  updateMutationsSchemaString,
+  updateMutationsResolvers,
+};

package/src/graph/mutations/versification.cjs

@@ -0,0 +1,96 @@
+const utils = require('../../util/index.cjs');
+
+const versificationMutationsSchemaString = `
+  """Adds verse mapping tables to the documents in a docSet, where the verse mapping may be provided in legacy .vrs or JSON format"""
+  setVerseMapping(
+    """the id of the docSet to which the verse mapping will be added"""
+    docSetId: String!
+    """The verse mapping, in legacy .vrs format (as a string)"""
+    vrsSource: String
+    """The verse mapping, in JSON format (as a string)"""
+    jsonSource: String
+  ): Boolean!
+  """Removes verse mapping tables from the documents in a docSet"""
+  unsetVerseMapping(
+    """The id of the docSet from which verse mapping will be removed"""
+    docSetId: String!
+  ): Boolean!
+`;
+const versificationMutationsResolvers = {
+  setVerseMapping: (root, args) => {
+    if (args.vrsSource && args.jsonSource) {
+      throw new Error('Cannot specify both vrsSource and jsonSource');
+    } else if (!args.vrsSource && !args.jsonSource) {
+      throw new Error('Must specify either vrsSource or jsonSource');
+    }
+
+    const docSet = root.docSets[args.docSetId];
+
+    if (!docSet) {
+      return false;
+    }
+
+    let jsonSource;
+
+    if (args.vrsSource) {
+      jsonSource = utils.versification.vrs2json(args.vrsSource);
+    } else {
+      jsonSource = args.jsonSource;
+    }
+
+    const forwardSuccinctTree = utils.versification.succinctifyVerseMappings(
+      jsonSource.mappedVerses,
+    );
+
+    const reversedJsonSource = utils.versification.reverseVersification(jsonSource);
+    const reversedSuccinctTree = utils.versification.succinctifyVerseMappings(
+      reversedJsonSource.reverseMappedVerses,
+    );
+
+    for (const document of docSet.documents().filter(doc => 'bookCode' in doc.headers)) {
+      const bookCode = document.headers['bookCode'];
+      const bookDocument = docSet.documentWithBook(bookCode);
+
+      if (!bookDocument) {
+        continue;
+      }
+
+      const bookMainSequence = bookDocument.sequences[bookDocument.mainId];
+      bookMainSequence.verseMapping = {};
+
+      if (bookCode in forwardSuccinctTree) {
+        bookMainSequence.verseMapping.forward = forwardSuccinctTree[bookCode];
+      }
+
+      if (bookCode in reversedSuccinctTree) {
+        bookMainSequence.verseMapping.reversed = reversedSuccinctTree[bookCode];
+      }
+    }
+    docSet.tags.add('hasMapping');
+    return true;
+  },
+  unsetVerseMapping: (root, args) => {
+    const docSet = root.docSets[args.docSetId];
+
+    if (!docSet) {
+      return false;
+    }
+
+    for (const document of docSet.documents().filter(doc => 'bookCode' in doc.headers)) {
+      const bookCode = document.headers['bookCode'];
+      const bookDocument = docSet.documentWithBook(bookCode);
+
+      if (bookDocument) {
+        const bookMainSequence = bookDocument.sequences[bookDocument.mainId];
+        bookMainSequence.verseMapping = {};
+      }
+    }
+    docSet.tags.delete('hasMapping');
+    return true;
+  },
+};
+
+module.exports = {
+  versificationMutationsSchemaString,
+  versificationMutationsResolvers,
+};

package/src/graph/queries/block.cjs

@@ -0,0 +1,228 @@
+const xre = require('xregexp');
+const utils = require('../../util/index.cjs');
+const { dumpBlock } = require('../lib/dump.cjs');
+
+const scopeMatchesStartsWith = (sw, s) => {
+  if (sw.length === 0) {
+    return true;
+  }
+
+  for (const swv of sw) {
+    if (s.startsWith(swv)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const blockSchemaString = `
+"""Part of a sequence, roughly equivalent to a USFM paragraph"""
+type Block {
+  """The length in bytes of the succinct representation of c (block items)"""
+  cBL: Int!
+  """The length in bytes of the succinct representation of bg (block grafts)"""
+  bgBL: Int!
+  """The length in bytes of the succinct representation of os (open scopes)"""
+  osBL: Int!
+  """The length in bytes of the succinct representation of is (included scopes)"""
+  isBL: Int!
+  """The length in bytes of the succinct representation of nt (nextToken at the start of the block)"""
+  ntBL: Int!
+  """The number of items in the succinct representation of c (block items)"""
+  cL: Int!
+  """The number of items in the succinct representation of bg (block grafts)"""
+  bgL: Int!
+  """The number of items in the succinct representation of os (open scopes)"""
+  osL: Int!
+  """The number of items in the succinct representation of is (included scopes)"""
+  isL: Int!
+  """A list of included scopes for this block"""
+  is: [Item!]!
+  """A list of open scopes for this block"""
+  os: [Item!]!
+  """The block scope for this block"""
+  bs: Item!
+  """A list of block grafts for this block"""
+  bg: [Item!]!
+  """The value of nextToken at the start of this block"""
+  nt: Int!
+  """A list of items from the c (content) field of the block"""
+  items(
+    """Only return items that are within specific scopes"""
+    withScopes: [String!]
+    """If true, withScopes filtering matches items within at least one of the specified scopes"""
+    anyScope: Boolean
+    """Only return items that are within a chapterVerse range (ch or ch:v or ch:v-v or ch:v-ch:v)"""
+    withScriptureCV: String
+    """If true, adds scope and nextToken information to each token"""
+    includeContext: Boolean
+  ) : [Item!]! 
+  """A list of tokens from the c (content) field of the block"""
+  tokens(
+    """Only return tokens that are within specific scopes"""
+    withScopes: [String!]
+    """If true, withScopes filtering matches tokens within at least one of the specified scopes"""
+    anyScope: Boolean
+    """Only return tokens that are within a chapterVerse range (ch or ch:v or ch:v-v or ch:v-ch:v)"""
+    withScriptureCV: String
+    """If true, adds scope and nextToken information to each token"""
+    includeContext: Boolean
+    """Return tokens whose payload is an exact match to one of the specified strings"""
+    withChars: [String!]
+    """Return tokens whose payload matches one of the specified regexes"""
+    withMatchingChars: [String!]
+    """Return tokens with one of the specified subTypes"""
+    withSubTypes: [String!]
+  ) : [Item!]!
+  """The text of the block as a single string"""
+  text(
+    """Only return text that is within a chapterVerse range (ch or ch:v or ch:v-v or ch:v-ch:v)"""
+    withScriptureCV: String
+    """If true, converts each whitespace character to a single space"""
+    normalizeSpace: Boolean
+  ): String!
+  """'Block items grouped by scopes or milestones"""
+  itemGroups(
+    """Produce one itemGroup for every match of the list of scopes"""
+    byScopes: [String!]
+    """Start a new itemGroup whenever a milestone in the list is encountered"""
+    byMilestones: [String!]
+  ): [ItemGroup]!
+  """The block content as a string in a compact eyeballable format"""
+  dump: String!
+  """A list of the labels for the block\\'s bs, os and is scopes"""
+  scopeLabels(
+    """Only include scopes that begin with this value"""
+    startsWith: [String!]
+  ): [String!]!
+}
+`;
+
+const blockResolvers = {
+  cBL: root => root.c.length,
+  bgBL: root => root.bg.length,
+  osBL: root => root.os.length,
+  isBL: root => root.is.length,
+  ntBL: root => root.nt.length,
+  cL: (root, args, context) => context.docSet.countItems(root.c),
+  bgL: (root, args, context) => context.docSet.countItems(root.bg),
+  osL: (root, args, context) => context.docSet.countItems(root.os),
+  isL: (root, args, context) => context.docSet.countItems(root.is),
+  is: (root, args, context) => context.docSet.unsuccinctifyScopes(root.is),
+  os: (root, args, context) => context.docSet.unsuccinctifyScopes(root.os),
+  bs: (root, args, context) => {
+    // eslint-disable-next-line no-unused-vars
+    const [itemLength, itemType, itemSubtype] = utils.succinct.headerBytes(root.bs, 0);
+    return context.docSet.unsuccinctifyScope(root.bs, itemType, itemSubtype, 0);
+  },
+  bg: (root, args, context) => context.docSet.unsuccinctifyGrafts(root.bg),
+  nt: root => root.nt.nByte(0),
+  items:
+    (root, args, context) => {
+      if (args.withScopes && args.withScriptureCV) {
+        throw new Error('Cannot specify both withScopes and withScriptureCV');
+      }
+
+      if (args.withScriptureCV) {
+        return context.docSet.unsuccinctifyItemsWithScriptureCV(root, args.withScriptureCV, {}, args.includeContext || false);
+      } else {
+        return context.docSet.unsuccinctifyPrunedItems(
+          root,
+          {
+            tokens: true,
+            scopes: true,
+            grafts: true,
+            requiredScopes: args.withScopes || [],
+            anyScope: args.anyScope || false,
+          },
+        );
+      }
+    },
+  tokens:
+    (root, args, context) => {
+      if (Object.keys(args).filter(a => a.includes('Chars')).length > 1) {
+        throw new Error('Only one of "withChars", "withAnyCaseChars" and "withCharsMatchingRegex" may be specified');
+      }
+
+      let ret;
+
+      if (args.withScriptureCV) {
+        ret = context.docSet.unsuccinctifyItemsWithScriptureCV(
+          root,
+          args.withScriptureCV,
+          { tokens: true },
+          args.includeContext || false,
+        );
+      } else {
+        ret = context.docSet.unsuccinctifyPrunedItems(
+          root,
+          {
+            tokens: true,
+            scopes: true,
+            requiredScopes: args.withScopes || [],
+            anyScope: args.anyScope || false,
+          },
+        );
+      }
+
+      if (args.withSubTypes) {
+        ret = ret.filter(i => args.withSubTypes.includes(i[1]));
+      }
+
+      if (args.withChars) {
+        ret = ret.filter(i => args.withChars.includes(i[2]));
+      } else if (args.withMatchingChars) {
+        ret = ret.filter(i => {
+          for (const re of args.withMatchingChars) {
+            if (xre.test(i, xre(re))) {
+              return true;
+            }
+          }
+          return false;
+        });
+      }
+
+      return ret.filter(i => i[0] === 'token');
+    },
+  text:
+    (root, args, context) => {
+      const tokens = args.withScriptureCV ?
+        context.docSet.unsuccinctifyItemsWithScriptureCV(
+          root,
+          args.withScriptureCV,
+          { tokens: true },
+          false,
+        ) :
+        context.docSet.unsuccinctifyItems(root.c, { tokens: true }, null);
+      let ret = tokens.map(t => t[2]).join('').trim();
+
+      if (args.normalizeSpace) {
+        ret = ret.replace(/[ \t\n\r]+/g, ' ');
+      }
+      return ret;
+    },
+  itemGroups: (root, args, context) => {
+    if (args.byScopes && args.byMilestones) {
+      throw new Error('Cannot specify both byScopes and byMilestones');
+    }
+
+    if (!args.byScopes && !args.byMilestones) {
+      throw new Error('Must specify either byScopes or byMilestones');
+    }
+
+    if (args.byScopes) {
+      return context.docSet.sequenceItemsByScopes([root], args.byScopes);
+    } else {
+      return context.docSet.sequenceItemsByMilestones([root], args.byMilestones);
+    }
+  },
+  dump: (root, args, context) => dumpBlock(context.docSet.unsuccinctifyBlock(root, {}, null)),
+  scopeLabels: (root, args, context) =>
+    [...context.docSet.unsuccinctifyBlockScopeLabelsSet(root)]
+      .filter(s => !args.startsWith || scopeMatchesStartsWith(args.startsWith, s)),
+};
+
+module.exports = {
+  blockSchemaString,
+  blockResolvers,
+};