@prefix ldp: <http://www.w3.org/ns/ldp#> .
@prefix dcterms: <http://purl.org/dc/terms/> .

<http://example.org/alice/> a ldp:Container, ldp:BasicContainer ;
    dcterms:title "Alice’s data storage on the Web" .

<.../thesis/123-456> <...rdf-schema#type> <...byoth#ThesisContainer> .
<.../thesis/123-456> <...byoth#hasThesis> <.../thesis/123-456> .
<.../thesis/123-456> <...dct/creator> <.../person/user1> .

// frame
{
    "@context": {
        "byoth": "http://purl.org/byoth#",
        "dct": "http://purl.org/dc/terms/",
        "@base": "http://your.ldp.com/rest/phd/",
        "hasThesis": {
            "@id": "byoth:hasThesis"
        }
    },
    "@type": "byoth:ThesisContainer",
    "hasThesis": { "@default": null }
}

// framed document
{
  "@context": {
    "byoth": "http://purl.org/byoth#",
    "dct": "http://purl.org/dc/terms/",
    "@base": "http://your.ldp.com/rest/phd/",
    "hasThesis": {
      "@id": "byoth:hasThesis"
    }
  },
  "@graph": [
    {
      "@id": "thesis/123-456",
      "@type": "byoth:ThesisContainer",
      "hasThesis": {
        "@id": "thesis/123-456"
      },
      "dct:creator": {
        "@id": "person/user1"
      }
    }
  ]
}

// frame with '@explicit: true'
{
    "@context": {
        "byoth": "http://purl.org/byoth#",
        "dct": "http://purl.org/dc/terms/",
        "@base": "http://your.ldp.com/rest/phd/",
        "hasThesis": {
            "@id": "byoth:hasThesis"
        }
    },
    "@type": "byoth:ThesisContainer",
    "hasThesis": { "@default": null },
    "@explicit": true
}

// original document
{
  "@context": {
    "byoth": "http://purl.org/byoth#",
    "dct": "http://purl.org/dc/terms/",
    "@base": "http://your.ldp.com/rest/phd/",
    "hasThesis": {
      "@id": "byoth:hasThesis"
    }
  },
  "@id": "thesis/123-456",
  "@type": "byoth:ThesisContainer",
  "hasThesis": {
    "@id": "thesis/123-456"
  },
  "dct:creator": {
    "@id": "person/WRONG_USER"
  }
}

import { prefixes } from './prefixes';

const TYPE = 'byoth:Person';

const CONTEXT: JsonLdContext = {
    ...prefixes,
    givenName: { '@id': 'schema:givenName' },
    familyName: { '@id': 'schema:familyName' },
    email: { '@id': 'schema:email' },
    birthDate: { '@id': 'dbo:birthDate', '@type': 'xsd:date' },
    orcid: { '@id': 'dbo:orcidId' },
    gender: { '@id': 'schema:gender' }
}

export const CANDIDATE_FRAME: JsonLdFrame = {
    '@context': CONTEXT,
    '@type': TYPE,
    '@explicit': true,
    givenName: defaultEmptyString,
    familyName: defaultEmptyString,
    email: defaultEmptyString,
    birthDate: defaultNull,
    orcid: defaultNull,
    gender: defaultNull,
};

export const ORDER_FRAME: JsonLdFrame = {
    '@type': 'byoth:Order',
    '@context': CONTEXT,
    '@explicit': true,
    // ...
    delivery: {
        '@type': 'schema:ParcelDelivery',
        '@explicit': true,
        description: defaultNull,
        address: {
            '@type': 'schema:PostalAddress',
            '@explicit': true,
            postalCode: defaultNull,
            // ...
        }
    },
    // ...
}

export interface AddressProperties {
    postalCode: string,
    // ...
}

export interface Address extends AddressProperties {
    '@type': string,
    '@id': string,
}


export interface Delivery {
    '@type': string,
    '@id': string,
    description?: string,
    address?: Address
}

export class LdpClient { 
    // ...
 
    async exists(path: string): Promise<boolean> { /* ... */ }

    async get(path: string, model: DocumentModel): Promise<CompactedDocument>
    { /* */ }

    async update(path: string, 
                 model: DocumentModel,
                 doc: CompactedDocument): Promise<CompactedDocument> 
    { /* ... */ }

}

async update(path: string, 
             model: DocumentModel,
             doc: CompactedDocument): Promise<CompactedDocument> {
    let lock;

    try {
        lock = await this.redlock.lock(this.root + path, 2000);
    } catch (err) {
        throw new LockError(err.message);
    }

    try {
        // perform update
        // ...
    } finally {
        await lock.unlock().catch(console.error);
    }
}

// perform update

const oldTriples = await this.getTriples(this.root + path)
            .then(triples => Ldp.filterTriples(triples, model.frame))
            .then(triples => this.removeReadonlyTriples(triples));

// ...

const oldTriples = await this.getTriples(this.root + path)
    .then(triples => Ldp.filterTriples(triples, model.frame))
    .then(triples => this.removeReadonlyTriples(triples));

let newTriples;

try {
    newTriples = await Ldp.filterJsonLdToTriples(doc, model.frame)
        .then(triples => this.removeReadonlyTriples(triples));

    if (!newTriples) {
        throw new FramingError('Document not compatible with model', 422);
    }
} catch (err) {
    if (err instanceof FramingError) {
        err.status = 422;
    }
    throw err;
}

// ...

const oldTriples = await this.getTriples(this.root + path)
    .then(triples => Ldp.filterTriples(triples, model.frame))
    .then(triples => this.removeReadonlyTriples(triples));

let newTriples;

try {
    newTriples = await Ldp.filterJsonLdToTriples(doc, model.frame)
        .then(triples => this.removeReadonlyTriples(triples));

    if (!newTriples) {
        throw new FramingError('Document not compatible with model', 422);
    }
} catch (err) {
    if (err instanceof FramingError) {
        err.status = 422;
    }
    throw err;
}

const query = `DELETE {\n${oldTriples}}\nINSERT {\n${newTriples}}\nWHERE {}`;

// ...

// ...

try {
    await axios.patch(this.root + path, query,
        { headers: { ...Ldp.patchHeaders, authorization: this.authorization } });
} catch (err) {
    throw convertAxiosError(err);
}

const updatedTriples = await this.getTriples(this.root + path);
return Ldp.createLdDocument(updatedTriples, model.frame);

async updateFileMetadata(
    path: string,
    model: DocumentModel,
    doc: CompactedDocument): Promise<CompactedDocument> {
    return this.update(path + '/' + this.metadataSuffix, model, doc);
}

router = express.Router();

router.get('/api/container/:id', (req, res, next) => {
    data = adapter.getData(req.param.id);

    if (!data) {
        next(Error('Could not get data'));
    }

    res.json(data);
});

import * as asyncHandler from 'express-async-handler';

router = express.Router();

router.get('/api/container/:id', asyncHandler(async (req, res, next) => {
    data = await adapter.getData(req.param.id);

    if (!data) {
        next(Error('Could not get data'));
    }

    res.json(data);
}));

export function decodeParam(key: string) {
    return function(req: Request, res: Response, next: NextFunction) {
        if (typeof req.params[key] === 'string') {
            req.params[key] = base64url.decode(req.params[key]);
        }
        next();
    };
}

export function containerApi(container: ThesisContainerAdapter,
                             printshop: PrintShopAdapter,
                             isbnHandler: ISBNHandler): Router {
    const router = express.Router();

    router.use('/', ensureAuthenticated());

    // ...

    router.route('/:id/:property')
    .all(decodeParam('id'))
    .all(asyncHandler(ensureContainerOwner(container, 'id')));
    .get(asyncHandler(async (req, res, next) => {
        const data 
            = await container.getProperty(req.params.id, req.params.property, req);
        res.json(data);
    }))
    .put(asyncHandler(async (req, res, next) => {
        const result 
            = await container.putProperty(req.params.id, req.params.property, req.body, req);
        res.json(result);
    }));

    // ...

    return router;
}

import * as express from 'express';
import * as http from 'http';
import { containerApi } from './routes/container';

app = express();

// get config somehow
const host = config.get( /* ... */ );
const port = config.get( /* ... */ );

app.set('host', host);

// init LdpClient, ThesisContainerAdapter, authentication
// ...

app.use(containerApi(containerAdapter, auth));

const server = http.createServer(app);

server.listen(port,
    () => console.log(`Application listenting on http://${host}:${port}`));

const subject = new Subject<string>(null);

const subscription = 
    subject.subscribe(value => console.log(value));

subject.next('foo');
subject.next('bar');

setTimeout(() => subscription.unsubscribe(), 1);

// Output:
// foo
// bar

const subject = new Subject<string>(null);
const upperCaseObservable = subject.pipe(
    map(value => value.toUpperCase())
);

const subscription = 
    upperCaseObservable.subscribe(value => console.log(value));

subject.next('foo');
subject.next('bar');

setTimeout(() => subscription.unsubscribe(), 1);

// Output:
// FOO
// BAR

/** A service that can be used to access, update and persist a document */
export interface DocumentService<T extends CompactedDocument> {
    /** Observable for the document */
    valueChanges: Observable<T>;

    /** Get an instant value of the document */
    value: T;

    /** Set the value of the document */
    setValue(document: T): void;

    /** Get the document once */
    get(): Observable<T>;

    /** Persist the document */
    save(): Observable<T>;

    /** Reset to null document */
    reset();
}

export class ContainerService {
    /** Service for the container's candidate */
    candidate: DocumentService<Candidate>;

    /** Service for the container's defense */
    defense: DocumentService<Defense>;

    // ...

    private properties: DocumentService<CompactedDocument>[];

    // ...

    save(): Observable<any> {
        return forkJoin(this.properties.map(property => property.save()));
    }
}

export class FormHandler {
    subscription: Subscription;

    constructor(protected form: FormGroup,
                protected service: DocumentService<CompactedDocument>) {
        // init with latest value from server
        this.service.get()
        .subscribe(doc => this.patchForm(doc));

        // listen for value changes from other events
        this.subscription = this.service.valueChanges
        .subscribe(doc => this.patchForm(doc));

        // listen for value changes to form
        this.subscription.add(
            this.form.valueChanges
            .subscribe(value => this.patchDocument(value))
        );
    }

    // stop listening when form is destroyed (avoid memory leaks)
    destroy() {
        this.subscription.unsubscribe();
    }

    // ...
}

export class FormHandler {
    // ...

    patchForm(document: CompactedDocument) {
        if (document) {
            this.form.patchValue(document, {emitEvent: false});
        }
    }

    patchDocument(formValue: any) {
        const doc = this.service.value;
        Object.assign(doc, formValue);
        this.service.setValue(doc);
    }
}

@Component({
    selector: 'app-candidate',
    templateUrl: './candidate.component.html',
    styleUrls: ['./candidate.component.css']
})
export class CandidateComponent extends BaseFormComponent {
    form: FormGroup;

    constructor(
        private container: ContainerService,
        private fb: FormBuilder) {
        super();
        this.form = this.fb.group({
            givenName: ['', Validators.required ],
            familyName: ['', Validators.required ],
            email: ['', [ Validators.required, Validators.email ] ]
        });

        this.addFormHandler(
            new FormHandler(this.form, this.container.candidate)
        );
    }
}

@Component({
    selector: 'app-press-release-form',
    templateUrl: './press-release-form.component.html',
})
export class PressReleaseFormComponent implements OnInit {
    steps = [
        { label: { en: 'Candidate', nb: 'Personalia' }, type: CandidateComponent },
        { label: { en: 'Defense', nb: 'Disputas' }, type: EventsComponent }
    ];
    
    // ...
}

<!-- press-release.component.html -->
<app-form-stepper [steps]="steps" [saveFunction]="saveFunction">
</app-form-stepper>

describe('LdpClient', () => {
    describe('exists()', () => {
        it('should return true if backend finds uri', async () => {
            mockAxios.onHead().reply(200);

            await expect(ldp.exists('foo')).to.eventually.be.true;
        });
    });
});

// code to test
export class LdpClient {
    async exists(path: string): Promise<boolean> {
        try {
            const response = await axios.head(this.root + path, 
               { headers: { authorization: this.authorization } });
            return response.status === 200;
        } catch (err) {
            // ...
        }
    }
}

     describe('/api/container/[:id]', () => {
        const path = '/api/container';
        
        it('should deny unauthenticated POST requests', async () => {
            await request(server).post(path).expect(401);
        });

        it('should allow authenticated user to POST container', async () => {
            sandbox.stub(_helpers, 'isAuthenticated').yields(null);
            let id: string;

            await request(server).post(path)
            .expect(201)
            .expect('Location', /^\w+$/)
            .then(res => {
                id = res.header.location;
                expect(id).to.equal(base64url.encode(res.body['@id']), 
                    'Location header id is base64url-encoded version of body id');
                expect(res.body.creator).to.contain(user.id);
            });
        });
    });

# start test-db
cd server/integration-tests
docker compose up
cd ../..

# run all tests
npm run test

# alternatives
npm run test:server
npm run test:server:integration
npm run test:server:unit
npm run test:client
npm run e2e # nothing there yet