Triply

https://docs.triply.cc/
Admin
Triply provides a linked data platform featuring TriplyDB for storing and querying knowledge graphs...
Tokens:99,256
Snippets:948
Trust Score:9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run TriplyETL Generator with npx

Source: https://docs.triply.cc/triply-etl/generic/getting-started

Use this command to start the TriplyETL Generator. On first use, it downloads and installs the latest version; on subsequent uses, it updates to the latest version if available.

```bash
npx @triply/etl-generator

```

--------------------------------

### Install TriplyDB.js with npm

Source: https://docs.triply.cc/triplydb-js

Install the @triply/triplydb package. Requires Node.js 20 or newer; an API token is needed for non-public data access and writes.

```bash
npm install @triply/triplydb

```

--------------------------------

### Complex example with dots in keys

Source: https://docs.triply.cc/triply-etl/extract/xml

An extensive JSON example showing how complex sequences of keys with dots can be used.

```json
{
  "a": {
    "$text": "1"
  },
  "b": {
    "c": {
      "$text": "2"
    }
  },
  "b.c": {
    "$text": "3"
  },
  "d.d": {
    "e": {
      "$text": "4"
    },
    "f": {
      "$text": "5"
    }
  },
  "g.g": [
    {
      "h.h": {
        "$text": "6"
      }
    },
    {
      "h.h": {
        "$text": "7"
      }
    }
  ]
}

```

--------------------------------

### list() example: children linked lists

Source: https://docs.triply.cc/triply-etl/assert/ratt/terms

Example usage of list() to create linked lists for the children of every parent.

```text
fromJson([{ parent: 'John', children: ['Joe', 'Jane'] }]),
triple(iri(prefix.person, 'parent'), sdo.children, list(prefix.skolem, iris(prefix.person, 'children'))),

```

--------------------------------

### list() example: resulting linked data for children

Source: https://docs.triply.cc/triply-etl/assert/ratt/terms

The linked data produced by the children example, showing the RDF list structure.

```text
person:John sdo:children _:list1.
_:list1
  rdf:first person:Joe;
  rdf:rest _:list2.
_:list2
  rdf:first person:Jane;
  rdf:rest rdf:nil.

```

--------------------------------

### Trace output example

Source: https://docs.triply.cc/triply-etl/generic/debug

Example output of the trace middleware showing record trace information and quads trace information. The output includes a command to rerun the traced middlewares for the record.

```text
┌─────────────────────────────────────┐
│      Record trace information       │
│ {                                   │
│   "a": 101,                         │
│   "b": 1                            │
│   "b": 101                          │
│ }                                   │
│                                     │
└─────────────────────────────────────┘

┌─────────────────────────────────────┐
│ Quads trace information (unchanged) │
│ empty                               │
│                                     │
└─────────────────────────────────────┘


 To rerun the traced middlewares for this record use the following command:
 > npx etl lib/{script-name} --trace .trace-1650542307095

```

--------------------------------

### Example records from XLSX

Source: https://docs.triply.cc/triply-etl/extract/xlsx

Shows two example records emitted by fromXlsx() for a table with ID, Name, and Age columns. Includes special keys $recordId, $environment, $sheetName, and $fileName.

```json
{
  "$recordId": 1,
  "$environment": "Development",
  "$sheetName": "Sheet1",
  "$fileName": "static/Untitled 1.xlsx",
  "ID": "1",
  "Name": "Doe, John",
  "Age": 32
}
{
  "$recordId": 2,
  "$environment": "Development",
  "$sheetName": "Sheet1",
  "$fileName": "static/Untitled 1.xlsx",
  "ID": "2",
  "Name": "D., Jane",
}

```

--------------------------------

### Trace middleware example pipeline

Source: https://docs.triply.cc/triply-etl/generic/debug

Example pipeline using traceStart() and traceEnd() to trace changes to a record. The pipeline changes key 'a' by +100, then traces, then changes key 'b' by +100, and ends tracing.

```javascript
fromJson([
  { a: 1, b: 1 }, // first dummy record
  { a: 2, b: 2 }, // second dummy record
]),
change({key:'a', type:'number', change: (val) => val +100}), // change the 'a' key
traceStart(),
change({key:'b', type:'number', change: (val) => val +100}), // change the 'b' key
traceEnd(),

```

--------------------------------

### list() example: resulting linked data (collection notation)

Source: https://docs.triply.cc/triply-etl/assert/ratt/terms

The linked data produced by the list() example using collection notation.

```text
basket:123 def:contains ( 'apple'@en 'pear'@en 'banana'@en ).

```

--------------------------------

### list() example: fruit basket

Source: https://docs.triply.cc/triply-etl/assert/ratt/terms

Example usage of list() to create linked lists for the contents of a basket.

```text
fromJson([{ id: 123, contents: ['apple', 'pear', 'banana'] }]),
triple(iri(prefix.basket, 'id'), def.contains, list(prefix.basket, literals('contents', lang.en))),

```

--------------------------------

### Import debug functions from @triplyetl/etl/debug

Source: https://docs.triply.cc/triply-etl/generic/changelog

Example of importing logRecord, traceEnd, and traceStart from the debug module.

```javascript
import { logRecord, traceEnd, traceStart } from '@triplyetl/etl/debug'

```

--------------------------------

### Check current TriplyETL version with npm list

Source: https://docs.triply.cc/triply-etl/generic/maintenance

Prints the currently installed TriplyETL version.

```bash
npm list @triplyetl/etl

```

--------------------------------

### wkt.addPoint() example: resulting record of key '_point'

Source: https://docs.triply.cc/triply-etl/transform/ratt

The record of the key '_point' produced by the wkt.addPoint() example. It shows the WKT literal with its datatype and validation status.

```json
{
  "_point": {
    "termType": "Literal",
    "value": "Point (52.37308 4.89245)",
    "language": "",
    "datatype": {
      "termType": "NamedNode",
      "value": "http://www.opengis.net/ont/geosparql#wktLiteral",
      "validationStatus": "canonical"
    },
    "validationStatus": "canonical"
  }
}

```

--------------------------------

### list() example: resulting linked data (without collection notation)

Source: https://docs.triply.cc/triply-etl/assert/ratt/terms

The linked data produced by the list() example when not using collection notation, showing the explicit RDF list structure.

```text
basket:123 def:contains _:list1.
_:list1
  rdf:first 'apple'@en;
  rdf:rest _:list2.
_:list2
  rdf:first 'pear'@en;
  rdf:rest _:list3.
_:list3
  rdf:first 'banana'@en;
  rdf:rest rdf:nil.

```

--------------------------------

### triples() example with metadata and data graphs

Source: https://docs.triply.cc/triply-etl/assert/ratt/statements

Example usage of triples() to make multiple metadata assertions in the metadata graph and multiple data assertions in the data graph.

```text
triples(graph.metadata,
  [iri(prefix.dataset, str('flowers')), a, dcat.Dataset],
  ...
),
triples(graph.data,
  [iri(prefix.flower, '_id'), a, def.Flower],
  ...
),

```

--------------------------------

### Example: dynamic IRI prefix

Source: https://docs.triply.cc/triply-etl/transform/ratt

Shows how to use a dynamic IRI prefix from the data source record with addHashedIri().

```turtle
fromJson([
  {
    prefix: Iri('https://triplydb.com/my-account/my-dataset/id/person/'),
    name: 'John Doe',
  },
  {
    prefix: Iri('https://triplydb.com/my-account/my-dataset/id/product/'),
    name: '123',
  },
]),
addHashedIri({
  prefix: 'prefix',
  content: ['name'],
  key: '_subject',
}),
triple('_subject', a, owl.NamedIndividual),

```

```turtle
prefix person: <https://triplydb.com/my-account/my-dataset/id/person/>
prefix product: <https://triplydb.com/my-account/my-dataset/id/product/>

person:76f294ac311b99e65ec99f947f30e a owl:NamedIndividual.
product:9154deaa364b289c6b012e99f947f30e a owl:NamedIndividual.

```

--------------------------------

### quad() example: data and metadata

Source: https://docs.triply.cc/triply-etl/assert/ratt/statements

Example usage of quad() to make one statement in a metadata graph and one in a data graph, distinguishing data from metadata.

```text
quad(iri(prefix.dataset, 'flowers'), a, dcat.Dataset, graph.metadata),
quad(iri(prefix.flower, '_id'), a, def.Flower, graph.data),

```

--------------------------------

### XML source file example.xml

Source: https://docs.triply.cc/triply-etl/generic/record

The contents of the local XML file used as the source in the following example.

```XML
<?xml version="1.0"?>
<persons>
  <person>
    <id>123</id>
    <name>John</name>
  </person>
  <person>
    <id>456</id>
    <name>Jane</name>
  </person>
</persons>

```

--------------------------------

### Example JSON data with nested keys

Source: https://docs.triply.cc/triply-etl/extract/json

Example JSON data used to illustrate nested keys and path selectors. Contains nested metadata and data objects with arrays.

```json
{
  "metadata": {
    "title": {
      "name": "Data about countries."
    }
  },
  "data": {
    "countries": [
      {
        "country.id": "nl",
        "name": "The Netherlands"
      },
      {
        "country.id": "de",
        "name": "Germany"
      }
    ]
  }
}

```

--------------------------------

### Example record from Shapefile

Source: https://docs.triply.cc/triply-etl/extract/shapefile

Shows the structure of a record extracted from a Shapefile, including properties and geometry.

```json
{
  '$recordId': 1,
  '$environment': 'Development',
  '$fileName': 'nl_1km.shp',    
  type: 'Feature',
  properties: {
    CELLCODE: '1kmE3793N3217',
    EOFORIGIN: 3793000,       
    NOFORIGIN: 3217000        
  },
  geometry: {
    type: 'Polygon',
    coordinates: [
      [
        [ 3793000, 3217000 ],
        [ 3793000, 3218000 ],
        [ 3794000, 3218000 ],
        [ 3794000, 3217000 ],
        [ 3793000, 3217000 ]
      ]
    ]
  }
}

```

--------------------------------

### wkt.addPoint() example: fromJson, wkt.addPoint, triple

Source: https://docs.triply.cc/triply-etl/transform/ratt

Shows how to use wkt.addPoint() to create a WKT literal from latitude and longitude keys. The example uses fromJson to create data, wkt.addPoint to generate the WKT string, and triple to assert linked data.

```javascript
fromJson({ place: 'Amsterdam', lat: 52.37308, long: 4.89245 }),
wkt.addPoint({
  latitude: 'lat',
  longitude: 'long',
  key: '_point'
}),

triple(iri(prefix.city, 'place'), geo.asWKT, '_point'),

```

--------------------------------

### Example: Alternative labels using objects()

Source: https://docs.triply.cc/triply-etl/assert/ratt/statements

Asserts multiple alternative labels for a city using fromJson and objects(). The example uses a JSON input with name and alt1-alt4 fields, and asserts skos:altLabel for each alt value.

```javascript
fromJson([{
   name: 'Ney York',
   alt1: 'The Big Apple',
   alt2: 'The Capital of the World',
   alt3: 'The City of Dreams',
   alt4:  'The City That Never Sleeps',
}]),
objects(iri(prefix.city, 'name'), skos.altLabel,
  'alt1',
  'alt2',
  'alt3',
  'alt4',
),

```

--------------------------------

### addValue() example: adding an array to a record

Source: https://docs.triply.cc/triply-etl/transform/ratt

Starts with an empty source record and adds a 'data' key containing an array with a string and a number. The triple assertion extracts elements using 'data[0]' and 'data[1]'.

```triply
fromJson([{}]),
addValue({
  content: ['johndoe', 22],
  key: 'data',
}),
triple(iri(prefix.person, 'data[0]'), foaf.age, 'data[1]'),

```

--------------------------------

### Run SHACL SPARQL rule using external files

Source: https://docs.triply.cc/triply-etl/enrich/shacl/sparql-rules

Same TriplyETL script as Step 1C but loads instance data and information model from separate files (`static/instances.trig` and `static/model.trig`) instead of inline strings, keeping the script concise.

```typescript
import { logQuads } from '@triplyetl/etl/debug'
import { Etl, Source, loadRdf } from '@triplyetl/etl/generic'
import { executeRules } from '@triplyetl/etl/shacl'

export default async function (): Promise<Etl> {
  const etl = new Etl()
  etl.use(
    loadRdf(Source.file('static/instances.trig')),
    executeRules(Source.file('static/model.trig')),
    logQuads(),
  )
  return etl
}

```

--------------------------------

### addValue() with ifElse: adding a start date or 'unknown'

Source: https://docs.triply.cc/triply-etl/transform/ratt

Adds a '_startDate' key that either contains the start date from the source record or the value 'unknown' when the 'start' key is absent. Uses ifElse and addLiteral.

```triply
fromJson([
  { id: '123', start: '2022-02-12' },
  { id: '456' },
]),
ifElse({
  if: 'start',
  then: addLiteral({
    content: 'start',
    datatype: xsd.date,
    key: '_start',
  }),
}, {
  else: addValue({
    content: 'unknown',
    key: '_start',
  }),
}),
triple(iri(prefix.event, 'id'), sdo.startDate, '_start'),

```

--------------------------------

### Linked data output for geometry example

Source: https://docs.triply.cc/triply-etl/assert/ratt/statements

The linked data assertions generated by the geometry example.

```turtle
feature:1 geo:hasGeometry geometry:1.
geometry:1
  a geo:Geometry;
  geo:asWKT 'Point(1.1 2.2)'^^geo:wktLiteral.

```

--------------------------------

### Example run of TriplyETL Generator

Source: https://docs.triply.cc/triply-etl/generic/getting-started

Shows a possible interactive session with the generator, including hidden inputs and the final success message.

```text
? TriplyETL License Key: [hidden]
? Project name: my-etl
? Target folder: my-etl
? Dataset name: my-etl
? Create a new TriplyDB API Token? Yes
? Your TriplyDB URL: my-org.triply.cc
? Your TriplyDB email: my-account@my-organization.com
? Your TriplyDB password: [hidden]
🏁 Your project my-etl is ready for use in my-etl.

```

--------------------------------

### iris() example: resulting linked data

Source: https://docs.triply.cc/triply-etl/assert/ratt/terms

The linked data assertions produced by the iris() example.

```text
person:John sdo:children person:Joe, person:Jane.

```

--------------------------------

### Navigate to target folder

Source: https://docs.triply.cc/triply-etl/generic/getting-started

Change into the target folder you specified during project creation.

```bash
cd my-etl

```

--------------------------------

### Linked data output for unit of measure example

Source: https://docs.triply.cc/triply-etl/assert/ratt/statements

The linked data assertions generated by the unit of measure example.

```turtle
product:1
  sdo:height
    [ qudt:unit unit:CentiM;
      rdf:value 15 ].

```

--------------------------------

### padStart() example: Create year literals

Source: https://docs.triply.cc/triply-etl/transform/ratt

Pads the year component to at least 4 digits to create standards-conforming temporal literals. The transformation uses padStart() on the 'Year' key and then creates a triple with the padded value. The output shows the resulting linked data assertions.

```triply
padStart({
  content: 'Year',
  padString: '0',
  targetLength: 4,
  key: '_lexicalForm',
}),
triple(
  iri(prefix.id, 'Artifact'),
  dct.created,
  literal('_lexicalForm', xsd.gYear),
),

```

```turtle
id:0001 dct:created '0612'^^xsd:gYear.
id:0002 dct:created '1702'^^xsd:gYear.

```

--------------------------------

### iris() example: assert IRIs for children

Source: https://docs.triply.cc/triply-etl/assert/ratt/terms

Example usage of iris() to assert one IRI for each entry in the 'children' key.

```text
fromJson([{ parent: 'John', children: ['Joe', 'Jane'] }]),
triple(iri(prefix.person, 'parent'), sdo.children, iris(prefix.person, 'children')),

```

--------------------------------

### padStart() example: Fixed-length identifiers

Source: https://docs.triply.cc/triply-etl/transform/ratt

Processes identifiers of varying length and pads them with '0' to a target length of 6. The input is a JSON array with two records. The output shows the resulting records with the padded '_id' field.

```triply
fromJson([
  { id: '16784' },
  { id: '129' },
]),
padStart({
  content: 'id',
  padString: '0',
  targetLength: 6,
  key: '_id',
}),

```

```json
[
  {
    "id": "16784",
    "_id": "016784"
  },
  {
    "id": "129",
    "_id": "000129"
  }
]

```

--------------------------------

### quads() example: data and metadata

Source: https://docs.triply.cc/triply-etl/assert/ratt/statements

Example usage of quads() to make assertions in a metadata graph and a data graph, using arrays for each quad.

```text
quads(
  [iri(prefix.dataset, 'flowers'), a, dcat.Dataset, graph.metadata],
  ...,
),
quads(
  [iri(prefix.flower, '_id'), a, def.Flower, graph.data],
  ...,
),

```

--------------------------------

### CSV example with quoted fields and empty values

Source: https://docs.triply.cc/triply-etl/extract/csv

Example CSV snippet showing quoted fields with commas and an empty trailing cell.

```CSV
ID,Name,Age
1,"Doe, John",32
2,"D., Jane ",

```

--------------------------------

### Install dependencies with npm i

Source: https://docs.triply.cc/triply-etl/generic/cli

Run this command after pulling changes that include updates to `package.json` to effectuate dependency changes in your local copy.

```bash
npm i

```

--------------------------------

### Run ETL with TriplyETL Runner

Source: https://docs.triply.cc/triply-etl/generic/getting-started

Use this command to run the ETL project with the TriplyETL Runner.

```bash
npx etl

```

--------------------------------

### uppercase() example: resulting linked data assertion

Source: https://docs.triply.cc/triply-etl/transform/ratt

The linked data assertion produced by the uppercase() example. It shows the transformed value 'NL' as the object of the triple.

```turtle
city:Amsterdam geonames:countryCode "NL"

```

--------------------------------

### Use multiple TriplyDB instances with different tokens and URLs

Source: https://docs.triply.cc/triply-etl/publish

Configure two TriplyDB sources in one Etl pipeline, each with its own token and URL. The example uses a production instance for the data model and an acceptance instance for instance data, reading tokens from environment variables.

```javascript
const etl = new Etl({
  sources: {
    data_model:
      Source.TriplyDb.rdf(
        'my-account',
        'my-dataset',
        {
          triplyDb: {
            token: process.env['PRODUCTION_INSTANCE_TOKEN'],
            url: 'https://api.production.example.com'
          }
        }
      ),
    instance_data:
      Source.TriplyDb.rdf(
        'my-account',
        'my-dataset',
        {
          triplyDb: {
            token: process.env['ACCEPTANCE_INSTANCE_TOKEN'],
            url: 'https://api.acceptance.example.com'
          }
        }
      ),
  },
})
```

--------------------------------

### wkt.addPoint() example: resulting linked data assertion

Source: https://docs.triply.cc/triply-etl/transform/ratt

The linked data assertion produced by the wkt.addPoint() example. It shows the WKT literal as the object of the geo:asWKT property.

```turtle
city:Amstedam geo:asWKT "Point (52.37308 4.89245)"^^geo:wktLiteral

```

--------------------------------

### Using fromXml() with XSLT stylesheet

Source: https://docs.triply.cc/triply-etl/transform/xslt

Example of using fromXml() middleware in TriplyETL to load and transform XML to XML with a different structure, specifying the stylesheet parameter.

```javascript
fromXml(Source.file(xml), {
  selectors: 'rdf:RDF.sdo:Person',
  stylesheet: Source.file(stylesheet),
})

```

--------------------------------

### addValue() example: resulting linked data assertion

Source: https://docs.triply.cc/triply-etl/transform/ratt

The linked data assertion produced by the previous addValue() example, showing the person:johndoe foaf:age 22 triple.

```turtle
person:johndoe foaf:age 22.

```

--------------------------------

### XML example with nested keys and indexed arrays

Source: https://docs.triply.cc/triply-etl/extract/xml

Shows an XML document with nested keys and indexed arrays, used to illustrate path expressions.

```xml
<?xml version="1.0"?>
<root>
  <metadata>
    <title>
      <name>Data about countries.</name>
    </title>
  </metadata>
  <data>
    <country "country.id"="nl">
      <name>The Netherlands</name>
    </country>
    <country "country.id"="de">
      <name>Germany</name>
    </country>
  </data>
</root>

```
Tokens:
Raw