proskomma-core 0.9.10 → 0.9.13

package/src/graph/lib/tribos_step.cjs

@@ -0,0 +1,434 @@
+const xre = require('xregexp');
+
+const predicateRegex = '(\\[(([^\\]\']|\'([^\']|\\\\\')*\')+)\\])*';
+
+// Nodes with one of the listed ids
+const doAbsoluteIdStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
+  const values = matches[1].split(',').map(v => v.trim());
+  return { data: Array.from(values).map(nid => allNodes[nodeLookup.get(nid)]) };
+};
+
+// The root Node
+const doAbsoluteRootStep = (docSet, allNodes) => ({ data: [allNodes[0]] });
+
+// All the nodes
+const doAbsoluteNodesStep = (docSet, allNodes) => ({ data: allNodes });
+
+// Children of the nodes
+const doChildrenStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
+  const childNo = matches[2];
+  const childNodeIds = new Set([]);
+
+  for (const parentNode of result.data) {
+    const children = docSet.unsuccinctifyScopes(parentNode.is)
+      .map(s => s[2].split('/'))
+      .filter(s => s[0] === 'tTreeChild')
+      .filter(s => !childNo || s[1] === childNo)
+      .map(s => s[2]);
+
+    for (const child of children) {
+      childNodeIds.add(child);
+    }
+  }
+  return { data: Array.from(childNodeIds).map(nid => allNodes[nodeLookup.get(nid)]) };
+};
+
+// The parent of each node
+const doParentStep = (docSet, allNodes, nodeLookup, result) => {
+  const parentNodeIds = new Set([]);
+
+  for (const childNode of result.data) {
+    const parentId = docSet.unsuccinctifyScopes(childNode.is)
+      .filter(s => s[2].startsWith('tTreeParent'))
+      .map(s => s[2].split('/')[1])[0];
+    parentNodeIds.add(parentId);
+  }
+  return { data: Array.from(parentNodeIds).map(nid => allNodes[nodeLookup.get(nid)]) };
+};
+
+// The nth ancestor of each node (where 1 === parent)
+const doAncestorStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
+  let ancestorNo = parseInt(matches[2]);
+
+  if (ancestorNo < 1) {
+    return { errors: `Expected a positive integer argument for ancestor, found ${queryStep}` };
+  }
+
+  let nodes = result.data;
+
+  while (ancestorNo > 0) {
+    const parentNodeIds = new Set([]);
+
+    for (const childNode of nodes) {
+      const parentId = docSet.unsuccinctifyScopes(childNode.is)
+        .filter(s => s[2].startsWith('tTreeParent'))
+        .map(s => s[2].split('/')[1])[0];
+      parentNodeIds.add(parentId);
+    }
+    nodes = Array.from(parentNodeIds).map(nid => allNodes[nodeLookup.get(nid)]);
+    ancestorNo--;
+  }
+  return { data: nodes };
+};
+
+// The nth-generation descendants of each node (where 1 === child)
+const doDescendantsStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
+  const descendantIds = new Set([]);
+
+  const getDescendants = (node, depth) => {
+    const childIds = docSet.unsuccinctifyScopes(node.is)
+      .filter(s => s[2].startsWith('tTreeChild'))
+      .map(s => s[2].split('/')[2]);
+
+    if (depth <= 1 || depth === null) {
+      childIds.forEach(n => descendantIds.add(n));
+    }
+
+    if (depth === null || depth > 1) {
+      childIds.map(nid => allNodes[nodeLookup.get(nid)]).forEach(n => getDescendants(n, depth - 1));
+    }
+  };
+
+  let descendantGen = null;
+
+  if (matches[3]) {
+    descendantGen = parseInt(matches[3]);
+  }
+
+  let descendantNo = -1;
+
+  if (matches[5]) {
+    descendantNo = parseInt(matches[5]);
+  }
+
+  for (const node of result.data) {
+    getDescendants(node, descendantGen);
+  }
+  return {
+    data: [...Array.from(descendantIds).entries()]
+      .filter(n => descendantNo < 0 || n[0] === descendantNo)
+      .map(n => n[1])
+      .map(nid => allNodes[nodeLookup.get(nid)]),
+  };
+};
+
+// The leaves of each node
+const doLeavesStep = (docSet, allNodes, nodeLookup, result) => {
+  const leafIds = new Set([]);
+
+  const getLeaves = node => {
+    const childIds = docSet.unsuccinctifyScopes(node.is)
+      .filter(s => s[2].startsWith('tTreeChild'))
+      .map(s => s[2].split('/')[2]);
+
+    if (childIds.length === 0) {
+      leafIds.add(docSet.unsuccinctifyScopes(node.bs)[0][2].split('/')[1]);
+    } else {
+      childIds.map(nid => allNodes[nodeLookup.get(nid)]).forEach(n => getLeaves(n));
+    }
+  };
+
+  for (const node of result.data) {
+    getLeaves(node);
+  }
+  return { data: Array.from(leafIds).map(nid => allNodes[nodeLookup.get(nid)]) };
+};
+
+// The children of the parent of each node
+// - get parent of starting node
+// - get children of parent node
+const doSiblingsStep = (docSet, allNodes, nodeLookup, result) => {
+  const parentNodeIds = new Set([]);
+
+  for (const childNode of result.data) {
+    const parentId = docSet.unsuccinctifyScopes(childNode.is)
+      .filter(s => s[2].startsWith('tTreeParent'))
+      .map(s => s[2].split('/')[1])[0];
+    parentNodeIds.add(parentId);
+  }
+
+  const parentNodes = allNodes.filter(n => parentNodeIds.has(docSet.unsuccinctifyScopes(n.bs)[0][2].split('/')[1]));
+  const childNodeIds = new Set([]);
+
+  for (const parentNode of parentNodes) {
+    const children = docSet.unsuccinctifyScopes(parentNode.is)
+      .filter(s => s[2].startsWith('tTreeChild'))
+      .map(s => s[2].split('/')[2]);
+
+    for (const child of children) {
+      childNodeIds.add(child);
+    }
+  }
+  // return { data: allNodes.filter(n => childNodeIds.has(docSet.unsuccinctifyScopes(n.bs)[0][2].split('/')[1])) };
+  return { data: Array.from(childNodeIds).map(nid => allNodes[nodeLookup.get(nid)]) };
+};
+
+const nodeDetails = (docSet, node, allNodes, nodeLookup, fields, isBranch) => {
+  const record = {};
+
+  if (fields.size === 0 || fields.has('id')) {
+    record.id = docSet.unsuccinctifyScopes(node.bs)[0][2].split('/')[1];
+  }
+
+  if (fields.size === 0 || fields.has('parentId')) {
+    record.parentId = docSet.unsuccinctifyScopes(node.is)
+      .filter(s => s[2].startsWith('tTreeParent'))
+      .map(s => s[2].split('/')[1])[0];
+  }
+
+  const content = {};
+
+  for (const [scopeLabels, items] of docSet.sequenceItemsByScopes([node], ['tTreeContent/'], false)) {
+    const key = scopeLabels.filter(s => s.startsWith('tTreeContent'))[0].split('/')[1];
+
+    if (fields.size === 0 || fields.has('content') || fields.has(`@${key}`)) {
+      content[key] = items.filter(i => i[0] === 'token').map(t => t[2]).join('');
+    }
+  }
+
+  if (Object.keys(content).length > 0) {
+    record.content = content;
+  }
+
+  const children = [];
+
+  if (fields.has('children')) {
+    for (const childScope of docSet.unsuccinctifyScopes(node.is)
+      .filter(s => s[2].startsWith('tTreeChild'))
+      .map(s => s[2].split('/')[2])) {
+      children.push(childScope);
+    }
+  }
+
+  if (children.length > 0) {
+    if (isBranch) {
+      record.children = children
+        .map(nid => allNodes[nodeLookup.get(nid)])
+        .map(n => nodeDetails(docSet, n, allNodes, nodeLookup, fields, true));
+    } else {
+      record.children = children;
+    }
+  }
+  return record;
+};
+
+
+// The node details included children
+// optional fields are id, parentId, content, @<contentName>, children
+const doBranchStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
+  const ret = [];
+  let fields = new Set([]);
+
+  if (matches[2]) {
+    fields = new Set(
+      matches[2]
+        .split(',')
+        .map(f => f.trim()),
+    );
+  }
+
+  for (const node of result.data) {
+    ret.push(nodeDetails(docSet, node, allNodes, nodeLookup, fields, true));
+  }
+  return { data: ret };
+};
+
+// All values across nodes for the specified content fields
+const doValuesStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
+  const nodeFields = [];
+  let fields = new Set([]);
+
+  if (matches[2]) {
+    fields = new Set(
+      matches[2]
+        .split(',')
+        .map(f => f.trim())
+        .filter(f => f.startsWith('@')),
+    );
+  }
+
+  for (const node of result.data) {
+    nodeFields.push(nodeDetails(docSet, node, allNodes, nodeLookup, fields, true));
+  }
+
+  const values = {};
+
+  for (const field of Array.from(fields).map(f => f.substring(1))) {
+    values[field] = Array.from(
+      new Set(
+        nodeFields
+          .filter(nd => nd.content)
+          .map(nd => nd.content)
+          .filter(nd => field in nd)
+          .map(nd => nd[field])
+          .sort(),
+      ),
+    );
+  }
+  return { data: values };
+};
+
+// The node details
+// optional fields are id, parentId, content, @<contentName>, children
+const doNodeStep = (docSet, allNodes, nodeLookup, result, queryStep, matches) => {
+  const ret = [];
+  let fields = new Set([]);
+
+  if (matches[2]) {
+    fields = new Set(matches[2].split(',').map(f => f.trim()));
+  }
+
+  for (const node of result.data) {
+    ret.push(nodeDetails(docSet, node, allNodes, nodeLookup, fields, false));
+  }
+  return { data: ret };
+};
+
+const stepActions = [
+  {
+    regex: xre(`^#\\{([^}]+)\\}${predicateRegex}$`),
+    doc: {
+      title: 'Nodes by Id',
+      syntax: '#(id, id, ...)',
+      description: 'Returns nodes whose id is listed',
+    },
+    predicateCapture: 3,
+    inputType: null,
+    outputType: 'nodes',
+    function: doAbsoluteIdStep,
+  },
+  {
+    regex: xre(`^root${predicateRegex}$`),
+    doc: {
+      title: 'Root Node',
+      syntax: 'root',
+      description: 'Returns the root node',
+    },
+    predicateCapture: 2,
+    inputType: null,
+    outputType: 'nodes',
+    function: doAbsoluteRootStep,
+  },
+  {
+    regex: xre(`^nodes${predicateRegex}$`),
+    doc: {
+      title: 'Nodes',
+      syntax: 'nodes',
+      description: 'Returns all the nodes',
+    },
+    predicateCapture: 2,
+    function: doAbsoluteNodesStep,
+    inputType: null,
+    outputType: 'nodes',
+  },
+  {
+    regex: xre(`^children(\\((\\d+)\\))?${predicateRegex}$`),
+    doc: {
+      title: 'Children',
+      syntax: 'children; children(pos)',
+      description: 'Returns the children of the current node(s), optionally filtered by position within the parent node',
+    },
+    predicateCapture: 4,
+    inputType: 'nodes',
+    outputType: 'nodes',
+    function: doChildrenStep,
+  },
+  {
+    regex: xre(`^descendants((\\((\\d+)(,\\s*(\\d+))?\\))?)${predicateRegex}$`),
+    doc: {
+      title: 'Descendants',
+      syntax: 'descendants; descendants(depth); descendants(depth, pos)',
+      description: 'Returns the descendants of the current node(s), optionally at the specified level, optionally filtered by position',
+    },
+    predicateCapture: 7,
+    inputType: 'nodes',
+    outputType: 'nodes',
+    function: doDescendantsStep,
+  },
+  {
+    regex: xre(`^leaves${predicateRegex}$`),
+    doc: {
+      title: 'Leaves',
+      syntax: 'leaves',
+      description: 'Returns the leaves (ie the nodes with no children) below the current node',
+    },
+    predicateCapture: 2,
+    inputType: 'nodes',
+    outputType: 'nodes',
+    function: doLeavesStep,
+  },
+  {
+    regex: xre(`^parent${predicateRegex}$`),
+    doc: {
+      title: 'Parent',
+      syntax: 'parent',
+      description: 'Returns the parent of the current node',
+    },
+    predicateCapture: 2,
+    inputType: 'nodes',
+    outputType: 'nodes',
+    function: doParentStep,
+  },
+  {
+    regex: xre(`^ancestor(\\((\\d+)\\))${predicateRegex}$`),
+    doc: {
+      title: 'Ancestor',
+      syntax: 'ancestor(depth)',
+      description: 'Returns the nth ancestor of the node',
+    },
+    predicateCapture: 5,
+    inputType: 'nodes',
+    outputType: 'nodes',
+    function: doAncestorStep,
+  },
+  {
+    regex: xre(`^siblings${predicateRegex}$`),
+    doc: {
+      title: 'Siblings',
+      syntax: 'siblings',
+      description: 'Returns the children of the parent of the current node',
+    },
+    predicateCapture: 2,
+    inputType: 'nodes',
+    outputType: 'nodes',
+    function: doSiblingsStep,
+  },
+  {
+    regex: xre(`^node(\\{([^}]+)\\})?${predicateRegex}$`),
+    doc: {
+      title: 'Node Details',
+      syntax: 'node; node{ id, parentId, content, children, @foo }',
+      description: 'Returns an object containing the specified content',
+    },
+    predicateCapture: 4,
+    inputType: 'nodes',
+    outputType: 'node',
+    function: doNodeStep,
+  },
+  {
+    regex: xre(`^branch(\\{([^}]+)\\})?${predicateRegex}$`),
+    doc: {
+      title: 'Branch',
+      syntax: 'branch; branch{ id, parentId, content, children, @foo }',
+      description: 'Returns nested objects containing the specified content',
+    },
+    predicateCapture: 4,
+    inputType: 'nodes',
+    outputType: 'node',
+    function: doBranchStep,
+  },
+  {
+    regex: xre(`^values(\\{([^}]+)\\})?${predicateRegex}$`),
+    doc: {
+      title: 'Values',
+      syntax: 'values{ @foo ... }',
+      description: 'Returns all values across nodes for the specified fields',
+    },
+    predicateCapture: 4,
+    inputType: 'nodes',
+    outputType: 'values',
+    function: doValuesStep,
+  },
+];
+
+module.exports = { stepActions };

package/src/graph/mutations/add.cjs

@@ -0,0 +1,91 @@
+const utils = require('../../util/index.cjs');
+const { remakeBlocks } = require('../lib/remake_blocks.cjs');
+
+const addMutationsSchemaString = `
+  """Adds a document which will be assigned to an existing or new docSet on the basis of the specified selectors"""
+  addDocument(
+    """The selectors for this document, the keys of which must match those of the Proskomma instance"""
+    selectors: [InputKeyValue!]!
+    """The format of the content (probably usfm or usx)"""
+    contentType: String!
+    """The document content as a string"""
+    content: String!
+    """A list of tags to be added"""
+    tags: [String!]
+  ): Boolean!
+  """Creates a new, empty sequence"""
+  newSequence(
+    """The id of the document to which the sequence will be added"""
+    documentId: String!
+    """The type of the new sequence (main, heading...)"""
+    type: String!
+    """The JSON describing blocks, if any, for the new sequence"""
+    blocksSpec: [inputBlockSpec!]
+    """If true, graft to the first block of the main sequence"""
+    graftToMain: Boolean
+    """'A list of tags to be added"""
+    tags: [String!]
+  ): String!
+  """Adds a new block to a sequence"""
+  newBlock(
+    """The id of the document containing the sequence to which the block will be added"""
+    documentId: String!
+    """The id of the sequence to which the block will be added"""
+    sequenceId: String!
+    """The zero-indexed position at which to add the block"""
+    blockN: Int!
+    """The scope to be applied to the block, eg blockScope/p"""
+    blockScope: String!
+  ): Boolean!
+`;
+
+const addMutationsResolvers = {
+  addDocument: (root, args) => {
+    const selectorsObject = {};
+
+    args.selectors.forEach(
+      s => {
+        selectorsObject[s.key] = s.value;
+      },
+    );
+    return !!root.importDocument(selectorsObject, args.contentType, args.content, null, null, null, args.tags || []);
+  },
+  newSequence: (root, args) => {
+    const document = root.documents[args.documentId];
+    const docSet = document.processor.docSets[document.docSetId];
+
+    if (!document) {
+      throw new Error(`Document '${args.documentId}' not found`);
+    }
+
+    const newSeqId = document.newSequence(args.type, args.tags);
+
+    if (args.blocksSpec) {
+      remakeBlocks(docSet, document, document.sequences[newSeqId], args.blocksSpec);
+      document.buildChapterVerseIndex();
+    }
+
+    if (args.graftToMain) {
+      docSet.maybeBuildPreEnums();
+      const mainSequenceBG = document.sequences[document.mainId].blocks[0].bg;
+      const graftTypeEnumIndex = docSet.enumForCategoryValue('graftTypes', args.type, true);
+      const seqEnumIndex = docSet.enumForCategoryValue('ids', newSeqId, true);
+      utils.succinct.pushSuccinctGraftBytes(mainSequenceBG, graftTypeEnumIndex, seqEnumIndex);
+    }
+    return newSeqId;
+  },
+  newBlock: (root, args) => {
+    const document = root.documents[args.documentId];
+
+    if (!document) {
+      throw new Error(`Document '${args.documentId}' not found`);
+    }
+
+    return document.newBlock(args.sequenceId, args.blockN, args.blockScope);
+  },
+};
+
+module.exports = {
+  addMutationsSchemaString,
+  addMutationsResolvers,
+};

package/src/graph/mutations/delete.cjs

@@ -0,0 +1,61 @@
+const deleteMutationsSchemaString = `
+  """Deletes a docSet"""
+  deleteDocSet(
+    """The id of the docSet containing the document to be deleted"""
+    docSetId: String!
+  ): Boolean
+  """Deletes a document"""
+  deleteDocument(
+    """The id of the docSet containing the document to be deleted"""
+    docSetId: String!
+    """The id of the document to be deleted"""
+    documentId: String!
+  ): Boolean
+  """Deletes a sequence from a document"""
+  deleteSequence(
+    """The id of the document containing the sequence to be deleted"""
+    documentId: String!
+    """The id of the sequence to be deleted"""
+    sequenceId: String!
+  ): Boolean
+  """Deletes a block from a sequence"""
+  deleteBlock(
+    """The id of the document containing the sequence from which the block will be deleted"""
+    documentId: String!
+    """The id of the sequence from which the block will be deleted"""
+    sequenceId: String!
+    """The zero-indexed number of the block to be deleted"""
+    blockN: Int!
+  ): Boolean
+`;
+
+const deleteMutationsResolvers = {
+  deleteDocSet: (root, args) =>
+    root.deleteDocSet(args.docSetId),
+  deleteDocument: (root, args) =>
+    root.deleteDocument(args.docSetId, args.documentId),
+  deleteSequence: (root, args) => {
+    const document = root.documents[args.documentId];
+
+    if (!document) {
+      throw new Error(`Document '${args.documentId}' not found`);
+    }
+
+    return document.deleteSequence(args.sequenceId);
+  },
+  deleteBlock: (root, args) => {
+    const document = root.documents[args.documentId];
+
+    if (!document) {
+      throw new Error(`Document '${args.documentId}' not found`);
+    }
+
+    return document.deleteBlock(args.sequenceId, args.blockN);
+  },
+};
+
+
+module.exports = {
+  deleteMutationsSchemaString,
+  deleteMutationsResolvers,
+};

package/src/graph/mutations/index.cjs

@@ -0,0 +1,54 @@
+const {
+  addMutationsSchemaString,
+  addMutationsResolvers,
+} = require('./add.cjs');
+
+const {
+  deleteMutationsSchemaString,
+  deleteMutationsResolvers,
+} = require('./delete.cjs');
+
+const {
+  rehashMutationsSchemaString,
+  rehashMutationsResolvers,
+} = require('./rehash.cjs');
+
+const {
+  tagMutationsSchemaString,
+  tagMutationsResolvers,
+} = require('./tags.cjs');
+
+const {
+  updateMutationsSchemaString,
+  updateMutationsResolvers,
+} = require('./update.cjs');
+
+const {
+  versificationMutationsSchemaString,
+  versificationMutationsResolvers,
+} = require('./versification.cjs');
+
+const mutationsSchemaString = `
+type Mutation {
+${addMutationsSchemaString}
+${deleteMutationsSchemaString}
+${rehashMutationsSchemaString}
+${tagMutationsSchemaString}
+${updateMutationsSchemaString}
+${versificationMutationsSchemaString}
+}`;
+
+const mutationsResolvers = {
+  ...addMutationsResolvers,
+  ...deleteMutationsResolvers,
+  ...rehashMutationsResolvers,
+  ...tagMutationsResolvers,
+  ...updateMutationsResolvers,
+  ...versificationMutationsResolvers,
+};
+
+
+module.exports = {
+  mutationsSchemaString,
+  mutationsResolvers,
+};

package/src/graph/mutations/rehash.cjs

@@ -0,0 +1,17 @@
+const rehashMutationsSchemaString = `
+  """Explicitly rebuild the text lookup tables for a docSet. (You probably don't need to do this)"""
+  rehashDocSet(
+    """The id of the docSet"""
+    docSetId: String!
+  ): Boolean!
+`;
+
+const rehashMutationsResolvers = {
+  rehashDocSet: (root, args) =>
+    root.rehashDocSet(args.docSetId),
+};
+
+module.exports = {
+  rehashMutationsSchemaString,
+  rehashMutationsResolvers,
+};