# rdf-string

> Convenience functions for creating and serializing RDF terms and quads

Latest version **2.0.1** (published 2025-01-08) · MIT license · 0 weekly downloads

## Install

```sh
npm install rdf-string
pnpm add rdf-string
yarn add rdf-string
bun add rdf-string
```

## Health

**Score 45/100 (D)** — status: stable.

Positive: has types; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support.

Negative: stale.

## Facts

| | |
|---|---|
| Version | 2.0.1 |
| Published | 2025-01-08 |
| First published | 2017-12-14 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 1 |
| Unpacked size | 37.8 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 4 |
| Author | Ruben Taelman |
| Maintainers | rubensworks |
| Keywords | rdf, rdfjs, term, quad, triple |

## Links

- npm: https://www.npmjs.com/package/rdf-string
- Repository: https://github.com/rubensworks/rdf-string.js
- Homepage: https://github.com/rubensworks/rdf-string.js#readme
- Issues: https://github.com/rubensworks/rdf-string.js/issues
- Funding: https://github.com/sponsors/rubensworks/
- npm.io page: https://npm.io/package/rdf-string

## Dependencies (1)

- [rdf-data-factory](https://npm.io/package/rdf-data-factory.md) ^2.0.0

## Alternatives

- [localforage](https://npm.io/package/localforage.md) — 6.2M weekly downloads
- [localforage-observable](https://npm.io/package/localforage-observable.md) — 30.8K weekly downloads
- [@y/y](https://npm.io/package/@y/y.md) — 30.1K weekly downloads
- [@metaobjectsdev/render](https://npm.io/package/@metaobjectsdev/render.md) — 3.5K weekly downloads
- [@ledgerhq/coin-algorand](https://npm.io/package/@ledgerhq/coin-algorand.md) — 1.1K weekly downloads

## Recent versions

- 2.0.1 (latest) — 2025-01-08
- 2.0.0 — 2025-01-08
- 1.6.3 — 2023-02-19
- 1.6.2 — 2022-11-28
- 1.6.1 — 2022-07-13
- 1.6.0 — 2021-08-11
- 1.5.0 — 2020-08-28
- 1.4.2 — 2020-04-22
- 1.4.1 — 2020-04-20
- 1.4.0 — 2020-04-20
- 1.3.1 — 2018-11-08
- 1.3.0 — 2018-11-08
- 1.2.0 — 2018-08-06
- 1.1.1 — 2018-02-09
- 1.1.0 — 2018-01-18
- … 2 more at https://npm.io/package/rdf-string/versions

## README

# RDF String

[![Build status](https://github.com/rubensworks/rdf-string.js/workflows/CI/badge.svg)](https://github.com/rubensworks/rdf-string.js/actions?query=workflow%3ACI)
[![Coverage Status](https://coveralls.io/repos/github/rubensworks/rdf-string.js/badge.svg?branch=master)](https://coveralls.io/github/rubensworks/rdf-string.js?branch=master)
[![npm version](https://badge.fury.io/js/rdf-string.svg)](https://www.npmjs.com/package/rdf-string)

This package contains utility functions to convert between the string-based
and [RDFJS](https://github.com/rdfjs/representation-task-force/) representations of RDF terms, quads and triples.

_If you are looking for a Turtle-based string syntax, have a look at [RDF String Turtle](https://github.com/rubensworks/rdf-string-ttl.js)_

This allows for convenient and compact interaction with RDF terms and quads,
as they can be serialized as plain JSON.

This string-based representation is based on the
[*old* triple representation of N3.js](https://github.com/rdfjs/N3.js/tree/v0.11.0#triple-representation).
Namely, quads are represented as follows:
```
{
  subject:   'http://example.org/cartoons#Tom',
  predicate: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
  object:    'http://example.org/cartoons#Cat'
  graph:     'http://example.org/myGraph'
}
```
Different terms types in quads are represented as follows:
* **URLs, URIs and IRIs are simple strings**: `'http://example.org/cartoons#Tom'`
* **Literals are represented as double quoted strings**: `'"Tom"'`, `'"Tom"@en-gb'`, `'"Tom"@en-gb--ltr'`, `'"1"^^http://www.w3.org/2001/XMLSchema#integer'`
* **Variables are prefixed by `?`**: `'?variableName'`

## Usage

The following examples assume the following imports:
```javascript
import * as RdfDataModel from "rdf-data-model";
import * as RdfString from "rdf-string";
```

### Term to string

Convert an RDFJS term to the string-based representation.

```javascript
// Prints http://example.org
console.log(RdfString.termToString(RdfDataModel.namedNode('http://example.org')));

// Prints _:b1
console.log(RdfString.termToString(RdfDataModel.blankNode('b1')));

// Prints "abc"
console.log(RdfString.termToString(RdfDataModel.literal('abc')));

// Prints "abc"@en-us
console.log(RdfString.termToString(RdfDataModel.literal('abc', 'en-us')));

// Prints "abc"@en-us--ltr
console.log(RdfString.termToString(RdfDataModel.literal('abc', { language: 'en-us', direction: 'ltr' })));

// Prints "abc"^^http://example.org/
console.log(RdfString.termToString(RdfDataModel.literal('abc', namedNode('http://example.org/'))));

// Prints ?v1
console.log(RdfString.termToString(RdfDataModel.variable('v1')));

// Prints empty string
console.log(RdfString.termToString(RdfDataModel.defaultGraph()));
```

### String to term

Convert an string-based term to the RDFJS representation.

_Optionally, a custom RDFJS DataFactory can be provided as second argument to create terms instead of the built-in DataFactory._

```javascript
// Outputs a named node
RdfString.stringToTerm('http://example.org');

// Outputs a blank node
RdfString.stringToTerm('_:b1');

// Outputs a literal
RdfString.stringToTerm('"abc"');

// Outputs a literal with a language tag
RdfString.stringToTerm('"abc"@en-us');

// Outputs a literal with a language tag and direction
RdfString.stringToTerm('"abc"@en-us--ltr');

// Outputs a literal with a datatype
RdfString.stringToTerm('"abc"^^http://example.org/');

// Outputs a variable
RdfString.stringToTerm('?v1');

// Outputs a default graph
RdfString.stringToTerm('');
```

### Quad to string-based quad

Convert an RDFJS quad to a string-based quad.

```javascript
// Prints { subject: 'http://example.org', predicate: 'http://example.org', object: '"abc"', graph: '' }
console.log(RdfString.quadToStringQuad(RdfDataModel.triple(
  namedNode('http://example.org'),
  namedNode('http://example.org'),
  literal('abc'),
)));
```

### String-based quad to quad

Converts a string-based quad to an RDFJS quad.

_Optionally, a custom RDFJS DataFactory can be provided as second argument to create quads and terms instead of the built-in DataFactory._

```javascript
// Outputs a quad
RdfString.stringQuadToQuad({
  subject: 'http://example.org',
  predicate: 'http://example.org',
  object: '"abc"',
  graph: '',
});
```

## License
This software is written by [Ruben Taelman](http://rubensworks.net/).
These utility functions are inspired by the implementation of [N3.js](https://github.com/RubenVerborgh/N3.js).

This code is released under the [MIT license](http://opensource.org/licenses/MIT).

---
_Source: https://npm.io/package/rdf-string · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._
