proskomma-core 0.9.10 → 0.9.13

package/src/graph/queries/index.cjs

@@ -0,0 +1,151 @@
+const { bookCodeCompareFunctions } = require('../lib/sort.cjs');
+const versifications = require('../../model/versifications/index.cjs');
+
+const querySchemaString = `
+"""The top level of Proskomma queries"""
+type Query {
+  """The id of the processor, which is different for each Proskomma instance"""
+  id: String!
+  """A string describing the processor class"""
+  processor: String!
+  """The NPM package version"""
+  packageVersion: String!
+  """The selectors used to define docSets"""
+  selectors: [selectorSpec!]!
+  """The number of docSets"""
+  nDocSets: Int!
+  """The docSets in the processor"""
+  docSets(
+    """A whitelist of ids of docSets to include"""
+    ids: [String!]
+    """Only return docSets that match the list of selector values"""
+    withSelectors: [InputKeyValue!]
+    """Only return docSets containing a document with the specified bookCode"""
+    withBook: String
+    """Only return docSets with all the specified tags"""
+    withTags: [String!]
+    """Only return docSets with none of the specified tags"""
+    withoutTags: [String!]
+  ): [DocSet!]!
+  """The docSet with the specified id"""
+  docSet(
+    """The id of the docSet"""
+    id: String!
+  ): DocSet
+  """The number of documents in the processor"""
+  nDocuments: Int!
+  """The documents in the processor"""
+  documents(
+    """A whitelist of ids of documents to include"""
+    ids: [String!]
+    """Only return documents with the specified bookCode"""
+    withBook: String
+    """Only return documents with the specified header key/values"""
+    withHeaderValues: [InputKeyValue!]
+    """Only return documents with all the specified tags"""
+    withTags: [String!]
+    """Only return documents with none of the specified tags"""
+    withoutTags: [String!]
+    """Sort returned documents by the designated method (currently ${Object.keys(bookCodeCompareFunctions).join(', ')})"""
+    sortedBy: String
+  ): [Document!]!
+  """The document with the specified id, or the specified docSet and withBook"""
+  document(
+    """The id of the document"""
+    id: String
+    """The docSet of the document (use with withBook)"""
+    docSetId: String
+    """The book of the document (use with docSetId)"""
+    withBook: String
+  ) : Document
+  """Reference information about standard versifications"""
+  versifications: [versification!]!
+  """Reference information about a named, standard versification"""
+  versification(
+    """The id of the versification"""
+    id: String!
+  ) : versification!
+}
+`;
+const queryResolvers = {
+  id: root => root.processorId,
+  selectors: root => root.selectors,
+  docSets: (root, args) => {
+    const docSetMatchesSelectors = (ds, selectors) => {
+      for (const selector of selectors) {
+        if (ds.selectors[selector.key].toString() !== selector.value) {
+          return false;
+        }
+      }
+      return true;
+    };
+
+    let ret = ('withBook' in args ? root.docSetsWithBook(args.withBook) : Object.values(root.docSets))
+      .filter(ds => !args.ids || args.ids.includes(ds.id));
+
+    if (args.withSelectors) {
+      ret = ret.filter(ds => docSetMatchesSelectors(ds, args.withSelectors));
+    }
+
+    if (args.withTags) {
+      ret = ret.filter(ds => args.withTags.filter(t => ds.tags.has(t)).length === args.withTags.length);
+    }
+
+    if (args.withoutTags) {
+      ret = ret.filter(ds => args.withoutTags.filter(t => ds.tags.has(t)).length === 0);
+    }
+
+    return ret;
+  },
+  docSet: (root, args) => root.docSetById(args.id),
+  documents: (root, args) => {
+    const headerValuesMatch = (docHeaders, requiredHeaders) => {
+      for (const requiredHeader of requiredHeaders || []) {
+        if (!(requiredHeader.key in docHeaders) || docHeaders[requiredHeader.key] !== requiredHeader.value) {
+          return false;
+        }
+      }
+      return true;
+    };
+
+    let ret = args.withBook ? root.documentsWithBook(args.withBook) : root.documentList();
+    ret = ret.filter(d => !args.ids || args.ids.includes(d.id));
+
+    if (args.withHeaderValues) {
+      ret = ret.filter(d => headerValuesMatch(d.headers, args.withHeaderValues));
+    }
+
+    if (args.withTags) {
+      ret = ret.filter(d => args.withTags.filter(t => d.tags.has(t)).length === args.withTags.length);
+    }
+
+    if (args.withoutTags) {
+      ret = ret.filter(d => args.withoutTags.filter(t => d.tags.has(t)).length === 0);
+    }
+
+    if (args.sortedBy) {
+      if (!(args.sortedBy in bookCodeCompareFunctions)) {
+        throw new Error(`sortedBy value must be one of [${Object.keys(bookCodeCompareFunctions).join(', ')}], not ${args.sortedBy}`);
+      }
+      ret.sort(bookCodeCompareFunctions[args.sortedBy]);
+    }
+
+    return ret;
+  },
+  document: (root, args) => {
+    if (args.id && !args.docSetId && !args.withBook) {
+      return root.documentById(args.id);
+    } else if (!args.id && args.docSetId && args.withBook) {
+      return root.documentsWithBook(args.withBook).filter(d => d.docSetId === args.docSetId)[0];
+    } else {
+      throw new Error('document requires either id or both docSetId and withBook (but not all three)');
+    }
+  },
+  versifications: () => Object.entries(versifications),
+  versification: (root, args) => Object.entries(versifications).filter(v => v[0] === args.id)[0],
+};
+
+module.exports = {
+  querySchemaString,
+  queryResolvers,
+};

package/src/graph/queries/inputBlockSpec.cjs

@@ -0,0 +1,17 @@
+const inputBlockSpecSchemaString = `
+"""A specification to create or update a block"""
+input inputBlockSpec {
+  """The block scope as an item"""
+  bs: InputItemObject!
+  """The block grafts as items"""
+  bg: [InputItemObject!]!
+  """The open scopes as items"""
+  os: [InputItemObject!]!
+  """The included scopes as items"""
+  is: [InputItemObject!]!
+  """The items"""
+  items: [InputItemObject!]!
+}
+`;
+
+module.exports = { inputBlockSpecSchemaString };

package/src/graph/queries/inputItemObject.cjs

@@ -0,0 +1,12 @@
+const inputItemObjectSchemaString = `
+"""Item for arguments"""
+input InputItemObject {
+    """The basic item type (token, scope or graft)'"""
+    type: String!
+    """The type-dependent subtype of the item"""
+    subType: String!
+    """The content of the item (the text for tokens, the label for scopes and the sequence id for grafts)"""
+    payload: String!
+}`;
+
+module.exports = { inputItemObjectSchemaString };

package/src/graph/queries/input_att_spec.cjs

@@ -0,0 +1,14 @@
+const inputAttSpecSchemaString = `
+"""Attribute Specification"""
+input AttSpec {
+"""The type of attribute, ie what type of thing it's connected to"""
+attType: String!
+"""The name of the USFM tag to which the attribute is connected"""
+tagName: String!
+"""The attribute key (ie the bit to the left of the equals sign in USX)"""
+attKey: String!
+"""The position of the value (which is 0 except for attributes with multiple values)"""
+valueN: Int!
+}`;
+
+module.exports = { inputAttSpecSchemaString };

package/src/graph/queries/input_key_matches.cjs

@@ -0,0 +1,11 @@
+const keyMatchesSchemaString = `
+"""Key/Regex tuple"""
+input KeyMatches {
+  """The key"""
+  key: String!
+  """The regex to match"""
+  matches: String!
+}
+`;
+
+module.exports = { keyMatchesSchemaString };

package/src/graph/queries/input_key_value.cjs

@@ -0,0 +1,11 @@
+const inputKeyValueSchemaString = `
+"""Input Key/Value Object"""
+input InputKeyValue {
+    """The key"""
+    key: String!
+    """The value"""
+    value: String!
+}
+`;
+
+module.exports = { inputKeyValueSchemaString };

package/src/graph/queries/input_key_values.cjs

@@ -0,0 +1,11 @@
+const keyValuesSchemaString = `
+"""Input Key/Values Object"""
+input KeyValues {
+    """The key"""
+    key: String!
+    """The values"""
+    values: [String!]!
+}
+`;
+
+module.exports = { keyValuesSchemaString };

package/src/graph/queries/input_selector_spec.cjs

@@ -0,0 +1,19 @@
+const inputSelectorSpecSchemaString = `
+"""Input specification of a selector"""
+input inputSelectorSpec {
+  """Name (ie the key)"""
+  name: String!
+  """Data type (string or integer)"""
+  type: String!
+  """Regex for validating string selector"""
+  regex: String
+  """Inclusive minimum value for integer selector"""
+  min: String
+  """Inclusive maximum value for integer selector"""
+  max: String
+  """Enum of permitted string values"""
+  enum: [String!]
+}
+`;
+
+module.exports = { inputSelectorSpecSchemaString };

package/src/graph/queries/item.cjs

@@ -0,0 +1,71 @@
+const scopeMatchesStartsWith = (sw, s) => {
+  if (sw.length === 0) {
+    return true;
+  }
+
+  for (const swv of sw) {
+    if (s.startsWith(swv)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const itemSchemaString = `
+"""Item"""
+type Item {
+  """The basic item type (token, scope or graft)"""
+  type: String!
+  """The type-dependent subtype of the item"""
+  subType: String!
+  """The content of the item (the text for tokens, the label for scopes and the sequence id for grafts)"""
+  payload(
+    """If true, turn all whitespace into a normal space"""
+    normalizeSpace: Boolean
+    """A whitelist of characters to include"""
+    includeChars: [String!]
+    """A blacklist of characters to exclude"""
+    excludeChars: [String!],
+  ): String!
+  """If 'includeContext' was selected, and for tokens, the index of the token from the start of the sequence"""
+  position(
+    """Only include scopes that begin with this value"""
+    startsWith: [String!]
+  ): Int
+  """If 'includeContext' was selected, a list of scopes that are open around the item"""
+  scopes(
+    """Only include scopes that begin with this value"""
+    startsWith: [String!]
+  ): [String!]
+}
+`;
+
+const itemResolvers = {
+  type: root => root[0],
+  subType: root => root[1],
+  payload: (root, args) => {
+    let ret = root[2];
+
+    if (root[0] === 'token') {
+      if (args.normalizeSpace) {
+        ret = root[2].replace(/[ \t\n\r]+/g, ' ');
+      }
+
+      if (args.includeChars || args.excludeChars) {
+        let retArray = ret.split('');
+        retArray = retArray.filter(c => !args.includeChars || args.includeChars.includes(c));
+        retArray = retArray.filter(c => !args.excludeChars || !args.excludeChars.includes(c));
+        ret = retArray.join('');
+      }
+    }
+    return ret;
+  },
+  position: root => root[3],
+  scopes: (root, args) =>
+    root[4] ? root[4].filter(s => !args.startsWith || scopeMatchesStartsWith(args.startsWith, s)) : [],
+};
+
+module.exports = {
+  itemSchemaString,
+  itemResolvers,
+};

package/src/graph/queries/itemGroup.cjs

@@ -0,0 +1,75 @@
+const { dumpItemGroup } = 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;
+};
+
+// [scopeLabels, items]
+
+const itemGroupSchemaString = `
+"""A collection of items, with scope context"""
+type ItemGroup {
+  """Items for this itemGroup"""
+  items: [Item!]!
+  """Tokens for this itemGroup"""
+  tokens(
+    """Return tokens whose payload is an exact match to one of the specified strings"""
+    withChars: [String!]
+    """Return tokens with one of the specified subTypes"""
+    withSubTypes: [String!]
+  ): [Item!]!
+  """The text of the itemGroup as a single string"""
+  text(
+    """If true, converts each whitespace character to a single space"""
+    normalizeSpace: Boolean
+  ): String!
+  """The labels of scopes that were open at the beginning of the itemGroup"""
+  scopeLabels(
+    """Only include scopes that begin with this value"""
+    startsWith: [String!]
+  ): [String!]!
+  """The itemGroup content as a string in a compact eyeballable format"""
+  dump: String!
+  """A list of scopes from the items of the itemGroup"""
+  includedScopes: [String!]!
+} 
+`;
+
+const itemGroupResolvers = {
+  items: root => root[1],
+  tokens: (root, args) =>
+    root[1].filter(i =>
+      i[0] === 'token' &&
+      (!args.withChars || args.withChars.includes(i[2])) &&
+      (!args.withSubTypes || args.withSubTypes.includes(i[1])),
+    ),
+  text: (root, args) => {
+    const tokensText = root[1].filter(i => i[0] === 'token').map(t => t[2]).join('');
+    return args.normalizeSpace ? tokensText.replace(/[ \t\n\r]+/g, ' ') : tokensText;
+  },
+  scopeLabels: (root, args) =>
+    root[0].filter(s => !args.startsWith || scopeMatchesStartsWith(args.startsWith, s)),
+  dump: root => dumpItemGroup(root),
+  includedScopes: root =>
+    Array.from(
+      new Set(
+        root[1]
+          .filter(i => i[0] === 'scope' && i[1] === 'start')
+          .map(t => t[2]),
+      ),
+    ),
+};
+
+module.exports = {
+  itemGroupSchemaString,
+  itemGroupResolvers,
+};

package/src/graph/queries/key_value.cjs

@@ -0,0 +1,18 @@
+const keyValueSchemaString = `
+"""Key/Value tuple"""
+type KeyValue {
+    """The key"""
+    key: String!
+    """The value"""
+    value: String!
+}`;
+
+const keyValueResolvers = {
+  key: root => root[0],
+  value: root => root[1],
+};
+
+module.exports = {
+  keyValueSchemaString,
+  keyValueResolvers,
+};

package/src/graph/queries/kv_entry.cjs

@@ -0,0 +1,21 @@
+const kvEntrySchemaString = `
+"""Key/Items tuple"""
+type kvEntry {
+    """The key"""
+    key: String!
+    """The secondary keys"""
+    secondaryKeys: [KeyValue!]
+    """The fields as itemGroups"""
+    itemGroups: [ItemGroup]!
+}`;
+
+const kvEntryResolvers = {
+  key: root => root[0],
+  secondaryKeys: root => root[1],
+  itemGroups: root => root[2],
+};
+
+module.exports = {
+  kvEntrySchemaString,
+  kvEntryResolvers,
+};

package/src/graph/queries/kv_sequence.cjs

@@ -0,0 +1,151 @@
+const xre = require('xregexp');
+
+const kvSequenceSchemaString = `
+"""A contiguous flow of content for key-values"""
+type kvSequence {
+  """The id of the sequence"""
+  id: String!
+  """The number of entries in the key-value sequence"""
+  nEntries: Int!
+  """The entries in the key-value sequence"""
+  entries(
+    """Only return entries whose key matches the specification"""
+    keyMatches: String
+    """Only return entries whose key equals one of the values in the specification"""
+    keyEquals: [String!]
+    """Only return entries whose secondary keys match the specification"""
+    secondaryMatches: [KeyMatches!]
+    """Only return entries whose secondary keys equal one of the values in the specification"""
+    secondaryEquals: [KeyValues!]
+    """Only return entries whose content matches the specification"""
+    contentMatches: [KeyMatches!]
+    """Only return entries whose content equals one of the values in the specification"""
+    contentEquals: [KeyValues!]
+  ): [kvEntry!]
+  """A list of the tags of this sequence"""
+  tags: [String!]!
+  """A list of the tags of this sequence as key/value tuples"""
+  tagsKv: [KeyValue!]!
+  """Whether or not the sequence has the specified tag"""
+  hasTag(
+    """The tag name"""
+    tagName: String
+  ): Boolean!
+}
+`;
+
+const kvSequenceResolvers = {
+  nEntries: root => root.blocks.length,
+  entries: (root, args, context) => {
+    let ret = root.blocks.map(
+      b => [
+        context.docSet.unsuccinctifyScopes(b.bs)
+          .map(s => s[2].split('/')[1])[0],
+        context.docSet.unsuccinctifyScopes(b.is)
+          .filter(s => s[2].startsWith('kvSecondary/'))
+          .map(s => [s[2].split('/')[1], s[2].split('/')[2]]),
+        context.docSet.sequenceItemsByScopes([b], ['kvField/'], false),
+      ],
+    );
+
+    if (args.keyMatches) {
+      ret = ret.filter(e => xre.test(e[0], xre(args.keyMatches)));
+    }
+
+    if (args.keyEquals) {
+      ret = ret.filter(e => args.keyEquals.includes(e[0]));
+    }
+
+    if (args.secondaryMatches) {
+      const matchesOb = {};
+      args.secondaryMatches.forEach(sm => (matchesOb[sm.key] = sm.matches));
+      ret = ret.filter(
+        e => {
+          const secondaryOb = {};
+          e[1].forEach(st => (secondaryOb[st[0]] = st[1]));
+
+          for (const mo of Object.entries(matchesOb)) {
+            const secondaryString = secondaryOb[mo[0]];
+
+            if (!secondaryString || !xre.test(secondaryString, xre(mo[1]))) {
+              return false;
+            }
+          }
+          return true;
+        });
+    }
+
+    if (args.secondaryEquals) {
+      const equalsOb = {};
+      args.secondaryEquals.forEach(sm => (equalsOb[sm.key] = sm.values));
+      ret = ret.filter(
+        e => {
+          const secondaryOb = {};
+          e[1].forEach(st => (secondaryOb[st[0]] = st[1]));
+
+          for (const mo of Object.entries(equalsOb)) {
+            const secondaryString = secondaryOb[mo[0]];
+
+            if (!secondaryString || !mo[1].includes(secondaryString)) {
+              return false;
+            }
+          }
+          return true;
+        });
+    }
+
+    if (args.contentMatches) {
+      const matchesOb = {};
+      args.contentMatches.forEach(sm => (matchesOb[sm.key] = sm.matches));
+      ret = ret.filter(
+        e => {
+          const contentOb = {};
+          e[2].forEach(st => (contentOb[st[0].filter(s => s.startsWith('kvField'))[0].split('/')[1]] = st[1].filter(i => i[0] === 'token').map(t => t[2]).join('')));
+
+          for (const mo of Object.entries(matchesOb)) {
+            const contentString = contentOb[mo[0]];
+
+            if (!contentString || !xre.test(contentString, xre(mo[1]))) {
+              return false;
+            }
+          }
+          return true;
+        });
+    }
+
+    if (args.contentEquals) {
+      const equalsOb = {};
+      args.contentEquals.forEach(sm => (equalsOb[sm.key] = sm.values));
+      ret = ret.filter(
+        e => {
+          const contentOb = {};
+          e[2].forEach(st => (contentOb[st[0].filter(s => s.startsWith('kvField'))[0].split('/')[1]] = st[1].filter(i => i[0] === 'token').map(t => t[2]).join('')));
+
+          for (const mo of Object.entries(equalsOb)) {
+            const contentString = contentOb[mo[0]];
+
+            if (!contentString || !contentString.includes(mo[1])) {
+              return false;
+            }
+          }
+          return true;
+        });
+    }
+
+    return ret;
+  },
+  tags: root => Array.from(root.tags),
+  tagsKv: root => Array.from(root.tags).map(t => {
+    if (t.includes(':')) {
+      return [t.substring(0, t.indexOf(':')), t.substring(t.indexOf(':') + 1)];
+    } else {
+      return [t, ''];
+    }
+  }),
+  hasTag: (root, args) => root.tags.has(args.tagName),
+};
+
+module.exports = {
+  kvSequenceSchemaString,
+  kvSequenceResolvers,
+};

package/src/graph/queries/node.cjs

@@ -0,0 +1,44 @@
+const utils = require('../../util/index.cjs');
+
+const nodeSchemaString = `
+"""A tree node"""
+type node {
+  """The node id"""
+  id: String!
+  """The node parent id"""
+  parentId: String
+  """The keys for content"""
+  keys: [String!]!
+  """The content as itemGroups"""
+  itemGroups(
+    """If true, adds scope and nextToken information to each token"""
+    includeContext: Boolean
+  ): [ItemGroup!]!
+  """The node children ids"""
+  childIds: [String!]!
+}
+`;
+
+const nodeResolvers = {
+  id: (root, args, context) => {
+    const [itemLength, itemType, itemSubtype] = utils.succinct.headerBytes(root.bs, 0);
+    return context.docSet.unsuccinctifyScope(root.bs, itemType, itemSubtype, 0)[2].split('/')[1];
+  },
+  parentId: (root, args, context) => {
+    const parentId = context.docSet.unsuccinctifyScopes(root.is).filter(s => s[2].startsWith('tTreeParent'))[0][2].split('/')[1];
+    return parentId === 'none' ? null: parentId;
+  },
+  keys: (root, args, context) => context.docSet.unsuccinctifyScopes(root.is)
+    .filter(s => s[2].startsWith('tTreeContent'))
+    .map(s => s[2].split('/')[1]),
+  itemGroups: (root, args, context) =>
+    context.docSet.sequenceItemsByScopes([root], ['tTreeContent/'], args.includeContext || false),
+  childIds: (root, args, context) =>
+    context.docSet.unsuccinctifyScopes(root.is).filter(s => s[2].startsWith('tTreeChild'))
+      .map(s => s[2].split('/')[2]),
+};
+
+module.exports = {
+  nodeSchemaString,
+  nodeResolvers,
+};

package/src/graph/queries/orig.cjs

@@ -0,0 +1,11 @@
+const origSchemaString = `
+"""Mapped verse information"""
+type orig {
+  """The book code"""
+  book: String
+  """A list of chapter-verse references"""
+  cvs: [cv!]!
+}
+`;
+
+module.exports = { origSchemaString };

package/src/graph/queries/regex_index.cjs

@@ -0,0 +1,18 @@
+const regexIndexSchemaString = `
+"""Information about a regex match on an enum"""
+type regexIndex {
+    """The index in the enum"""
+    index: String!
+    """The string in the enum that matched"""
+    matched: String!
+}`;
+
+const regexIndexResolvers = {
+  index: root => root[0],
+  matched: root => root[1],
+};
+
+module.exports = {
+  regexIndexSchemaString,
+  regexIndexResolvers,
+};

package/src/graph/queries/row_equals_spec.cjs

@@ -0,0 +1,11 @@
+const rowEqualsSpecSchemaString = `
+"""Row Equals Specification"""
+input rowEqualsSpec {
+  """The position of the column in which to search a match"""
+  colN: Int!
+  """The values to match"""
+  values: [String!]!
+}
+`;
+
+module.exports = { rowEqualsSpecSchemaString };