MarkLogicContext

import { MarkLogicProvider } from "ml-fasttrack"
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <MarkLogicProvider
    scheme="http"
    host="localhost"
    port="4001"
    options="my-options"
    auth={{ username: "theUser", password: "p4ssw0rd" }}
    paginationOptions={{ pageLength: 20 }}
    debug={true}
  >
    <App />
  </MarkLogicProvider>
);

context.setQtext("fast OR track");

context.setCollections(["person", "organization"]);

context.setDirectories(["/pets/dogs/", "/pets/cats/"]);

context.setPageStart(2);

context.setPageLength(20);

context.setOptions("myQueryOptions")

context.setSearchTransform("myTransformFunction")

context.setDocumentTransform("myTransformFunction")

const combinedQuery = {  
  qtext: "fast OR track"
}
 
context.postSearch(combinedQuery, {start: 2}).then(response => {
  console.log(response);
})

<MarkLogicProvider
  host={host}
  port="4000"
  updateSearchOnChange={false}
>
  <App />
</MarkLogicProvider>

// ...

context.setQtext("fast OR track"); // Does not trigger search
context.updateSearch();

context.getSuggestedSearch("New", 5).then(response => {
  console.log(response);
})

const uri = "/person/1001.json";
 
context.getDocument(uri, {database: "my-app-db"}).then(response => {
  console.log(response);
})

const sq = `SELECT * 
  WHERE { 
    ?s <http://xmlns.com/foaf/0.1/givenname/> ?o 
  } LIMIT 10`; 
context.getSparql(sq, {database: "ml-demo-app-content"}, 
  {headers: {'X-Example-Header': 'my-header-value'}} ).then(response => { 
  console.log(response); 
})

const sq = `SELECT *
  WHERE {
    ?s <http://xmlns.com/foaf/0.1/givenname/> ?o
  } LIMIT 10`;
const combinedQuery = {  
  qtext: "fast OR track",
  sparql: sq
}
context.postSparql(combinedQuery, {database: "my-app-db"}).then(response => {
  console.log(response);
})

const myBot = {
    id: 0,
  name: 'ExampleBot'
}
const myCombinedQuery = {
  qtext: 'suv OR crossover'
}
const myParameters={{
  host: '127.0.0.1',
  port: 4015
}}
context.postChat('What are the safest new cars?', myCombinedQuery, myParameters)
  .then((response) => {
    console.log("Response", response);
  }
);

context.request({
      url: '/v1/resources/customEndpoint',
      method: 'POST',
      data: { prop1: 'foo', prop2: 'bar' },
      headers: { 'Content-Type': 'application/json' }
}).then(response => {
  console.log(response);
})

const handleFacetClick = (constraint) => {
  context.addStringFacetConstraint(constraint);
}
 
return (
  <StringFacet
    title="Status"
    name="status"
    data={context.searchResponse?.facets?.status}
    onSelect={handleFacetClick}
    reset={resetStringFacet}
  />
)

return (  
  <SelectedFacets
    selectedFacetConfig={{
      string: {
        color: 'red',
        closable: true,
      }
    }}
    stringFacets={context.stringFacetConstraints}
    removeStringFacet={context.removeStringFacetConstraint}
  ></SelectedFacets>
)

const handleValueRange = (constraint) => {
  context.addRangeFacetConstraint(constraint);
}
 
return (
  <NumberRangeFacet
    title="Salary"
    name="salary"
    data={context?.searchResponse?.facets?.salary}
    minValue={0}
    maxValue={100000}
    onChange={handleValueRange}
  />
)

return (  
  <SelectedFacets
    selectedFacetConfig={{
      string: {
        color: 'red',
        closable: true,
      }
    }}
    rangeFacets={context.rangeFacetConstraints}
    removeRangeFacet={context.removeRangeFacetConstraint}
  ></SelectedFacets>
)

const handleGeoSearch = (polygonsCoordsArr) => {
  const query =
  {
    "type": "geo-elem-pair-query",
    "lat": "Latitude",
    "lon": "Longitude",
    "parent": "Location",
    "polygon": polygonsCoordsArr.map((coords) => {
      const pointObj = {
        "point": coords[0]?.map((ele) => {
          return {
            "latitude": parseFloat(ele[1]),
            "longitude": parseFloat(ele[0])
          }
        })
      }
      return pointObj
    })
  }
  context.addGeoConstraint(query);
}
  
return (      
  <GeoMap
    markers={context.searchResponse?.results}
    sketch={true}
    transformMarkers={transformMarkers}
    transformShapes={transformShapes}
    viewType="2D"
    useWeb={false}
    showGallery={false}
    showToggle={false}
    onClickMap={onClickMap}
    onGeoSearch={handleGeoSearch}
  /> )

context.addWordQueryConstraint(
  {
    'json-property': 'transcript',
     text: ['dog', 'cat']
  }
)

context.removeWordQueryConstraint(
  {
    'json-property': 'transcript',
     text: ['dog', 'cat']
  }
)

context.removeAllWordQueryConstraints()

const onSubmitComment = async (comment) => {
  let res = await context.patchComment("/person/1001.json", { content: comment, context: '/person/comments' })
  if (res.success === true) {
    context.getDocument(selectedUri);
  } else {
    alert('Comment submission failed')
  }
}
 
<CommentBox
  label="Comments"
  inputPlaceholder="Add a comment"
  buttonLabel="Post"
  onSubmit={(comment) => onSubmitComment(comment)}
  username="joe-user"
  imgSrc="https://example.org/joe.jpg"
  profileImage={{
    alt: 'Avatar',
    path: 'https://example.org/joe.jpg'
  }}
/>

const onEditComment = async (id, comment) => {
  let res = await context.editComment("/person/1001.json", id, { content: comment, context: '/person/comments/comment' })
  if (res.success !== true) {
    alert('Comment failed to be edited')
  }
}
 
<CommentList
  data={context.documentResponse}
  config={{comments: {
    path: 'data.person.comments.comment'
  }}}
  username="joe-user"
  onSaveComment={(id, comment) => onEditComment(id, comment)}
  onDeleteComment={(id) => onDeleteComment(id)}

const onDeleteComment = async (id) => {
  let res = await context.deleteComment("/person/1001.json", id, '/person/comments/comment')
  if (res.success !== true) {
    alert('Comment failed to be deleted')
  }
}
 
<CommentList
  data={context.documentResponse}
  config={{comments: {
    path: 'data.person.comments.comment'
  }}}
  username="joe-user"
  onSaveComment={(id, comment) => onEditComment(id, comment)}
  onDeleteComment={(id) => onDeleteComment(id)}
/>

useEffect(() => {
  context.postChat(
    {
        "what is marklogic",
        {}
    })
}, []);
// chatResponse
{
    "citations": [
        {
            "citationId": "/chunks/Inside MarkLogic Server.pdf-5.json",
            "citationLabel": "[1] - Inside MarkLogic Server.pdf, Page 5"
        },
        {
            "citationId": "/chunks/Inside MarkLogic Server.pdf-5.json",
            "citationLabel": "[2] - Inside MarkLogic Server.pdf, Page 5"
        },
        {
            "citationId": "/chunks/Inside MarkLogic Server.pdf-5.json",
            "citationLabel": "[3] - Inside MarkLogic Server.pdf, Page 5"
        }
    ],
    "output": " MarkLogic Server is an Enterprise NoSQL Database that combines database 
                internals, search-style indexing, and application server behaviors into
                a unified system.[1] It is a multi-model database management system that 
                combines a document model with a semantic triple model and stores all of 
                its data within a fully ACID-compliant transactional repository.
                [1] MarkLogic supports massive scale and exceptional performance while maintaining 
                enterprise capabilities required for mission-critical applications.[1]"
} 

useEffect(() => {
  context.postSearch({qtext: "Alabama OR Texas"});
}, []);
 
// searchResponse
 
{
    "snippet-format": "snippet",
    "total": 2,
    "start": 1,
    "page-length": 10,
    "results": [
        {
            "index": 1,
            "uri": "/person/1002.json",
            "path": "fn:doc(\"/person/1002.json\")",
            "score": 10240,
            "confidence": 0.5028362,
            "fitness": 0.5028362,
            "href": "/v1/documents?uri=%2Fperson%2F1002.json",
            "mimetype": "application/json",
            "format": "json",
            "matches": [
                {
                    "path": "fn:doc(\"/person/1002.json\")/envelope/address/text(\"state\")",
                    "match-text": [
                        {
                            "highlight": "Texas"
                        }
                    ]
                }
            ]
        },
        {
            "index": 2,
            "uri": "/person/1003.json",
            "path": "fn:doc(\"/person/1003.json\")",
            "score": 10240,
            "confidence": 0.5028362,
            "fitness": 0.5028362,
            "href": "/v1/documents?uri=%2Fperson%2F1003.json",
            "mimetype": "application/json",
            "format": "json",
            "matches": [
                {
                    "path": "fn:doc(\"/person/1003.json\")/envelope/address/text(\"state\")",
                    "match-text": [
                        {
                            "highlight": "Alabama"
                        }
                    ]
                }
            ]
        }
    ],
    "qtext": "Alabama OR Texas",
    "metrics": {
        "query-resolution-time": "PT0.005024S",
        "snippet-resolution-time": "PT0.000615S",
        "total-time": "PT0.315651S"
    }
}

{ context.searchResponseLoading ? 
  <div>Loading...</div> :
  <ResultsSnippet 
    results={context.searchResponse.results}
  />
}

useEffect(() => {
  context.getSuggestedSearch("New", 5)
}, []);
 
// suggestedSearchResponse
 
{
    "suggestions": [
        "\"New Haven\"",
        "\"New York City\"",
        "Newark",
        "Newton"
    ]
}

useEffect(() => {
  context.getDocument({"/person/1001.json", {database: "my-app-db"})
}, []);

// documentResponse

{ 
  data: {
    id: "1001",
    first: "Jane",
    last: "Smith"
  },
  uri: "/person/1001.json"
}

useEffect(() => {
  context.getSparql(`
    SELECT *
    WHERE {
    ?s ?p ?o .
    ?s <http://xmlns.com/foaf/0.1/knows/> ?o
    } LIMIT 10
  `);
}, []);
 
// sparqlResponse
 
{
    "head": {
        "vars": [
            "s",
            "p",
            "o"
        ]
    },
    "results": {
        "bindings": [
            {
                "s": {
                    "type": "uri",
                    "value": "http://example.org/1001"
                },
                "p": {
                    "type": "uri",
                    "value": "http://xmlns.com/foaf/0.1/knows/"
                },
                "o": {
                    "type": "literal",
                    "value": "1002"
                }
            },
            {
                "s": {
                    "type": "uri",
                    "value": "http://example.org/1001"
                },
                "p": {
                    "type": "uri",
                    "value": "http://xmlns.com/foaf/0.1/knows/"
                },
                "o": {
                    "type": "literal",
                    "value": "1003"
                }
            },
            {
                "s": {
                    "type": "uri",
                    "value": "http://example.org/1002"
                },
                "p": {
                    "type": "uri",
                    "value": "http://xmlns.com/foaf/0.1/knows/"
                },
                "o": {
                    "type": "literal",
                    "value": "1001"
                }
            },
            {
                "s": {
                    "type": "uri",
                    "value": "http://example.org/1003"
                },
                "p": {
                    "type": "uri",
                    "value": "http://xmlns.com/foaf/0.1/knows/"
                },
                "o": {
                    "type": "literal",
                    "value": "1001"
                }
            }
        ]
    }
}

useEffect(() => {
  context.request({
    url: '/v1/resources/currentTime',
    method: 'GET',
    headers: { 'Content-Type': 'application/json' }
  });
}, []);
 
// response

{ 
  currentTime:"10:22:25-07:00" 
}

useEffect(() => {
  context.addStringFacetConstraint([
    {
        "type": "string",
        "name": "status",
        "value": [
            "Active"
        ],
        "title": "Status"
    }
])
}, []);
 
// stringFacetConstraints
 
[
    {
        "type": "string",
        "name": "status",
        "value": [
            "Active"
        ],
        "title": "Status"
    }
]

useEffect(() => {
  context.addRangeFacetConstraint([
    [
        {
            "type": "number",
            "name": "salary",
            "value": 50000,
            "operator": "GE",
            "title": "Salary"
        },
        {
            "type": "number",
            "name": "salary",
            "value": 100000,
            "operator": "LE",
            "title": "Salary"
        }
    ]
  ])
}, []);
 
// rangeFacetConstraints
 
[
    [
        {
            "type": "number",
            "name": "salary",
            "value": 50000,
            "operator": "GE",
            "title": "Salary"
        },
        {
            "type": "number",
            "name": "salary",
            "value": 100000,
            "operator": "LE",
            "title": "Salary"
        }
    ]
]

   useEffect(() => {
        context.addWordQueryConstraint(
          {
              "json-property": "transcript",
              "text": ['dog', 'cat']
          })
        }, []);
// wordQueryConstraint
    {
        "json-property": "transcript",
        "text": ['dog', 'cat']
    }