JavaScript Client

const json = [{ "@type" : "Class",
             "@id" : "Coordinate",
             "@key" : { '@type' : 'Hash',
             '@fields' : ['x','y'] },
             "x" : "xsd:decimal",
             "y" : "xsd:decimal" },
             { "@type" : "Class",
             "@id" : "Country",
             "@key" : { '@type' : 'Lexical',
                         '@fields' : [name] },
             "name" : "xsd:string",
             "perimeter" : { "@type" : "List",
                             "@class" : "Coordinate" } }]
client.addDocument(json,{"graph_type":"schema"},"mydb","add new schema documents")

//if we would like to override the entire schema
const json = [
{"@base": "terminusdb:///data/",
      "@schema": "terminusdb:///schema#",
      "@type": "@context"
  },
  {
      "@id": "Person",
       "@key": {
          "@type": "Random"
      },
      "@type": "Class",
      "name": {
          "@class": "xsd:string",
          "@type": "Optional"
      }
  }]

// client.addDocument(json,{"graph_type":"schema","full_replace:true"},
      "mydb","update the all schema");

// Here we will pass true to show how to get dataVersion

const response = await client.addDocument(json, {"graph_type": "schema"},
  "mydb",
  "add new schema", '',
  true
)
console.log(response);

 // This will output:
 // {
 //   result: [ ...... ],
 //   dataVersion: 'branch:5fs681tlycnn6jh0ceiqcq4qs89pdfs'
 // }

 // Now we can use the data version we recieved as a response in previous
 // function call and used it is next function call as lastDataVersion

const response1 = await client.addDocument(json, {"graph_type": "schema"},
  "mydb",
  "add new schema", response.dataVersion,
)

let api_url = client.api()

client.checkout("mybranch")
client.apply("mybranch","mybranch_new","merge main").then(result=>{
   console.log(result)
})

client.author()

client.branch("dev")

client.clonedb({remote_url: "https://my.terminusdb.com/myorg/mydb", label "Cloned DB", comment: "Cloned from mydb"}, newid: "mydb")

client.connect()

let newClient = client.copy()

//remember set schema:true if you need to add a schema graph
client.createDatabase("mydb", {label: "My Database", comment: "Testing", schema: true})

client.createRemote("origin", "http://remote.server.com/org/db")

//to get the list of all organization's databases
async function callGetDatabases(){
     await client.getDatabases()
     console.log(client.databases())
}

client.db("mydb")

client.deleteDatabase("mydb")

client.deleteDocument({"graph_type":"schema",id:['Country','Coordinate']})


// Here we will pass true to show how to get dataVersion

const response = await client.deleteDocument({"graph_type":"schema",id:['Country','Coordinate']},
  "",
  "",
  "",
  true
)
console.log(response);

 // This will output:
 // {
 //   result: [ ...... ],
 //   dataVersion: 'branch:5fs681tlycnn6jh0ceiqcq4qs89pdfs'
 // }

 // Now we can use the data version we recieved as a response in previous
 // function call and used it is next function call as lastDataVersion

const response1 = await client.deleteDocument({"graph_type":"schema",
  id:['Country','Coordinate']},
  "",
  "",
  response.dataVersion,
)

client.deleteRemote("origin")

client.getBranches()

client.getClassDocuments()

client.getClasses()

client.getCommitsLog(count=10)

async function callGetDatabases(){
     const dbList = await client.getDatabases()
     console.log(dbList)
}

//return the schema graph as a json array
client.getDocument({"graph_type":"schema","as_list":true}).then(result={
   console.log(result)
})

//retutn the Country class document from the schema graph
client.getDocument({"graph_type":"schema","as_list":true,"id":"Country"}).then(result={
   console.log(result)
})

//pass a document query template to query the document interface
const queryTemplate = { "name": "Ireland"}
client.getDocument({"as_list":true, "@type":"Country"
           query:queryTemplate}).then(result=>{
   console.log(result)
})


// Here we will pass true to show how to get dataVersion
const response = await client.getDocument({"graph_type":"schema","as_list":true},
  "",
  "",
  "",
  true
)
console.log(response);

 // This will output:
 // {
 //   result: [ ...... ],
 //   dataVersion: 'branch:5fs681tlycnn6jh0ceiqcq4qs89pdfs'
 // }

 // Now we can use the data version we recieved as a response in previous
 // function call and used it is next function call as lastDataVersion

const response1 = await client.getDocument({"graph_type":"schema","as_list":true},
  "",
  "",
  response.dataVersion,
)

//this will return the last 5 commits for the Person/Anna document
client.checkout("mybranch")
client.docHistory("Person/Anna",{start:0,count:5}).then(result=>{
   console.log(result)
})
//this will return the last and the first commit for the Person/Anna document
client.docHistory("Person/Anna",{updated:true,created:true}).then(result=>{
   console.log(result)
})

client.getEnums()

client.getJSONDiff(
     { "@id": "Person/Jane", "@type": "Person", name: "Jane" },
     { "@id": "Person/Jane", "@type": "Person", name: "Janine" }
 ).then(diffResult=>{
 console.log(diffResult)
})
//result example
//{'@id': 'Person/Jane',
// name: { '@after': 'Janine', '@before': 'Jane', '@op': 'SwapValue' }}

client.getPrefixes()
//return object example
{
'@base': 'terminusdb:///data/',
'@schema': 'terminusdb:///schema#',
'@type': 'Context'}

const remote = await client.getRemote("origin")

client.getSchema()

client.getSchemaFrame("Country")

const turtle = await client.getTriples("schema", "alt")

async funtion callGetUserOrganizations(){
     await getUserOrganizations()
     console.log(client.userOrganizations())
}

//This is to view all the changes between two commits
const beforeCommit = "a73ssscfx0kke7z76083cgswszdxy6l"
const afterCommit = "73rqpooz65kbsheuno5dsayh71x7wf4"

client.getVersionDiff( beforeCommit, afterCommit).then(diffResult=>{
 console.log(diffResult)
})

//This is to view the changes between two commits but only for the given document
client.getVersionDiff( beforeCommit, afterCommit, "Person/Tom").then(diffResult=>{
 console.log(diffResult)
})

//This is to view the changes between a branch (head) and a commit for the given document
client.getVersionDiff("main", afterCommit, "Person/Tom" ).then(diffResult=>{
   console.log(diffResult)
})

//This is to view the changes between two branches with the keep options
const options = {"keep":{"@id":true, "name": true}, start:0, count:10}
client.getVersionDiff("main","mybranch",options).then(diffResult=>{
   console.log(diffResult)
})

const jsonObj =  { "@id": "Person/Jane", "@type": "Person", name: "Janine" }
client.getVersionObjectDiff("main",jsonObj
     "Person/Jane").then(diffResp=>{
   console.log(diffResp)
})

async function executeIfDatabaseExists(f){
     const hasDB = await client.hasDatabase("admin", "testdb")
     if (hasDB) {
         f()
     }
}

client.info()

client.localAuth({user:"admin","key":"mykey","type":"basic"})

client.organization("admin")

client.patch(
     { "@id" : "Person/Jane", "@type" : "Person", "name" : "Jane"},
     { "name" : { "@op" : "ValueSwap", "@before" : "Jane", "@after": "Janine" }}
 ).then(patchResult=>{
 console.log(patchResult)
})
//result example
//{ "@id" : "Person/Jane", "@type" : "Person", "name" : "Jannet"}

const patch = [
  {
   "@id": "Obj/id1",
    "name": {
     "@op": "SwapValue",
      "@before": "foo",
      "@after": "bar"
    }
  },
 {
   "@id": "Obj/id2",
    "name": {
      "@op": "SwapValue",
      "@before": "foo",
     "@after": "bar"
    }
 }
]
client.db("mydb")
client.checkout("mybranch")
client.patchResource(patch,"apply patch to mybranch").then(patchResult=>{
 console.log(patchResult)
})
// result example
// ["Obj/id1",
// "Obj/id2"]
// or conflict error 409
// {
// "@type": "api:PatchError",
// "api:status": "api:conflict",
// "api:witnesses": [
//  {
//   "@op": "InsertConflict",
//    "@id_already_exists": "Person/Jane"
//  }
//]
//}

client.pull({remote: "origin", remote_branch: "main", message: "Pulling from remote"})

client.push({remote: "origin", remote_branch: "main", message: "Pulling from remote"})

const result = await client.query(WOQL.star())

const query = {
  "type": "Person",
  "query": { "age": 42 },
 }
client.queryDocument(query, {"as_list":true})


// Here we will pass true to show how to get dataVersion
const query = {
  "type": "Person",
  "query": { "age": 42 },
 }

const response = await client.queryDocument(query, {"as_list": true}, '', '','',true);
console.log(response);

 // This will output:
 // {
 //   result: [
 //     {
 //       '@id': 'Person/052d60ffbd114bf5e7331b03f07fcb7',
 //       '@type': 'Person',
 //       age: 42,
 //       name: 'John',
 //     },
 //   ],
 //   dataVersion: 'branch:5fs681tlycnn6jh0ceiqcq4qs89pdfs'
 // }

 // Now we can use the data version we recieved as a response in previous
 // query and used it is next query as lastDataVersion
 const query = {
  "type": "Person",
  "query": { "age": 18 },
 }

 const response1 = await client.queryDocument(query, {"as_list": true}, '',
   '',
   response.dataVersion
 );

//from the branch head
client.rebase({rebase_from: "admin/db_name/local/branch/branch_name", message:
"Merging from dev")
//or from a commit id
client.rebase({rebase_from: "admin/db_name/local/commit/9w8hk3y6rb8tjdy961de3i536ntkqd8",
message: "Merging from dev")

client.ref("mkz98k2h3j8cqjwi3wxxzuyn7cr6cw7")

client.remoteAuth({"key":"dhfmnmjglkrelgkptohkn","type":"jwt"})

client.repo("origin")

const branch_resource = client.resource("branch")

client.sendCustomRequest("GET", "http://localhost:3030/changes/").then(result=>{
   console.log(result)
})

sets several of the internal state values in a single call
(similar to connect, but only sets internal client state, does not communicate with server)
client.set({key: "mypass", branch: "dev", repo: "origin"})

client.updateDatabase({id: "mydb", label: "My Database", comment: "Testing"})

client.updateDocument(
{
 "@id": "Person",
   "@key": {
     "@type": "Random",
   },
   "@type": "Class",
   label: "xsd:string",
 },
{ graph_type: "schema" }
);


// Here we will pass true to show how to get dataVersion

    const response = await client.updateDocument(
      {
        "@id": "Person",
        "@key": {
          "@type": "Random",
        },
        "@type": "Class",
        label: "xsd:string",
      },
      { graph_type: "schema" },
      "",
      "",
      "",
      true
    );
console.log(response);

 // This will output:
 // {
 //   result: [ ...... ],
 //   dataVersion: 'branch:5fs681tlycnn6jh0ceiqcq4qs89pdfs'
 // }

 // Now we can use the data version we recieved as a response in previous
 // function call and used it is next function call as lastDataVersion

const response1 = await client.updateDocument(
      {
        "@id": "Person",
        "@key": {
          "@type": "Random",
        },
        "@type": "Class",
        label: "xsd:string",
      },
      { graph_type: "schema" },
      "",
      "",
      response.dataVersion
    );

 // update a document and create the linked document together
 // we are update the document "Person/Person01"
 // and create a new document {"@type": "Person","name": "child01"} at the same time
 const response1 = await client.updateDocument(
     {
      "@id": "Person/Person01",
      "@type": "Person",
      "name": "Person01"
      "children":[{"@type": "Person","name": "child01"}]
    },{create:true})

client.updateRemote("origin", "http://new.remote.server.com/org/db")

client.updateTriples("schema", "alt", turtle_string, "dumping triples to graph alt")

async funtion callGetUserOrganizations(){
     await client.getUserOrganizations()
     console.log(client.userOrganizations())
}

//find triples that are of type scm:Journey, and have
//a start_station Start, and that start_station is labeled Start_Label
let [Journey, Start, Start_Label] = vars("Journey", "Start", "Start_Label")
WOQL.and(
     WOQL.triple(Journey, "rdf:type", "@schema:Journey"),
     WOQL.triple(Journey, "start_station", Start),
     WOQL.triple(Start, "label", Start_Label))

let [First_Var, Second_Var] = vars('First_Var', 'Second_Var')
WOQL.as("first var", First_Var, "string").as("second var", Second_Var)
WOQL.as(["first var", First_Var, "string"], ["second var", Second_Var])

boolean(true)
//returns { "@type": "xsd:boolean", "@value": true }

let [first_name, last_name, full_name] = vars("first_name", "last_name", "full_name")
concat([first_name, " ", last_name], full_name)

let [count, Person] = vars("count", "Person")
WOQL.count(count).triple(Person, "rdf:type", "@schema:Person")

date("2022-10-02")
//returns { "@type": "xsd:date", "@value": "2022-10-02" }

datetime("2022-10-19T14:17:12Z")
//returns { "@type": "xsd:dateTime", "@value": "2022-10-19T14:17:12Z" }

remove the class Person from the schema graph
WOQL.delete_quad("Person", "rdf:type", "sys:Class", "schema")

delete_triple("john", "age", 42)

let [result] = vars("result")
evaluate(div(10, 3), result)
//result contains 3

const doc = WOQL.doc({ "@type": "Person", name: "Newperson" })

let [result] = vars("result")
eval(plus(2, minus(3, 1)), result)

let [result] = vars("result")
evaluate(plus(2, minus(3, 1)), result)

let [result] = vars("result")
evaluate(exp(3, 2), result)
//result contains 9

let [result] = vars("result")
evaluate(divide(floor(times(10, minus(2.1, plus(0.2, 1)))), 10), result)
//result contains 0.9 - floating point error removed

let [a, b] = vars("a", "b")
get(as("a", a).as("b", b)).remote("http://my.url.com/x.csv")
//copies the values from column headed "a" into a variable a and from column
//"b" into a variable b from remote CSV

WOQL.graph("schema")
//equivalent to add_quad("MyClass", "label", "My Class Label", "schema/main")

let [result] = vars("result")
greater(1.2, 1.1).eq(result, literal(true, "boolean"))
//result contains true

//subquery is an argument or a chained query
let [age, last_name, first_name, age_group, person] = vars("age", "last name", "first name",
"age group", "person")
group_by(age, [last_name, first_name], age_group)
  .triple(person, "first_name", first_name)
  .triple(person, "last_name", last_name)
  .triple(person, "age", age)