From 0d8e772c64d90ab2f98523825270c8a3abfc1c74 Mon Sep 17 00:00:00 2001 From: Joachim Van Herwegen Date: Mon, 24 Aug 2020 13:32:28 +0200 Subject: [PATCH] feat: Update RepresentationMetadata to store triples --- bin/server.ts | 13 +- src/ldp/http/SimpleBodyParser.ts | 8 +- src/ldp/http/SimpleResponseWriter.ts | 3 +- src/ldp/http/SimpleSparqlUpdateBodyParser.ts | 11 +- .../representation/RepresentationMetadata.ts | 131 ++++++++++++++---- src/storage/FileResourceStore.ts | 49 ++++--- src/storage/RepresentationConvertingStore.ts | 6 +- src/storage/SimpleResourceStore.ts | 3 +- src/storage/conversion/ConversionUtil.ts | 5 +- .../conversion/QuadToTurtleConverter.ts | 4 +- .../conversion/TurtleToQuadConverter.ts | 4 +- .../patch/SimpleSparqlUpdatePatchHandler.ts | 10 +- src/util/InteractionController.ts | 6 +- src/util/MetadataTypes.ts | 9 ++ test/integration/Authorization.test.ts | 13 +- test/integration/RequestParser.test.ts | 9 +- test/unit/ldp/http/SimpleBodyParser.test.ts | 9 +- .../ldp/http/SimpleResponseWriter.test.ts | 16 +-- .../http/SimpleSparqlUpdateBodyParser.test.ts | 7 +- .../RepresentationMetadata.test.ts | 120 ++++++++++++++++ test/unit/storage/FileResourceStore.test.ts | 120 ++++++++++------ .../RepresentationConvertingStore.test.ts | 22 ++- .../storage/conversion/ConversionUtil.test.ts | 16 ++- .../conversion/QuadToTurtleConverter.test.ts | 13 +- .../conversion/TurtleToQuadConverter.test.ts | 20 +-- .../SimpleSparqlUpdatePatchHandler.test.ts | 5 +- 26 files changed, 451 insertions(+), 181 deletions(-) create mode 100644 src/util/MetadataTypes.ts create mode 100644 test/unit/ldp/representation/RepresentationMetadata.test.ts diff --git a/bin/server.ts b/bin/server.ts index 6408ddb748..dcfee41ff0 100644 --- a/bin/server.ts +++ b/bin/server.ts @@ -1,6 +1,7 @@ #!/usr/bin/env node import { DATA_TYPE_BINARY } from '../src/util/ContentTypes'; import streamifyArray from 'streamify-array'; +import { TYPE } from '../src/util/MetadataTypes'; import yargs from 'yargs'; import { AcceptPreferenceParser, @@ -13,6 +14,7 @@ import { QuadToTurtleConverter, Representation, RepresentationConvertingStore, + RepresentationMetadata, SimpleAclAuthorizer, SimpleBodyParser, SimpleCredentialsExtractor, @@ -114,16 +116,15 @@ const aclSetup = async(): Promise => { acl:mode acl:Control; acl:accessTo <${base}>; acl:default <${base}>.`; + const id = await aclManager.getAcl({ path: base }); + const metadata = new RepresentationMetadata(id.path); + metadata.add(TYPE, 'text/turtle'); await store.setRepresentation( - await aclManager.getAcl({ path: base }), + id, { dataType: DATA_TYPE_BINARY, data: streamifyArray([ acl ]), - metadata: { - raw: [], - profiles: [], - contentType: 'text/turtle', - }, + metadata, }, ); }; diff --git a/src/ldp/http/SimpleBodyParser.ts b/src/ldp/http/SimpleBodyParser.ts index cd794dc7ad..c00c70ca1c 100644 --- a/src/ldp/http/SimpleBodyParser.ts +++ b/src/ldp/http/SimpleBodyParser.ts @@ -1,5 +1,6 @@ import { BinaryRepresentation } from '../representation/BinaryRepresentation'; import { BodyParser } from './BodyParser'; +import { CONTENT_TYPE } from '../../util/MetadataTypes'; import { DATA_TYPE_BINARY } from '../../util/ContentTypes'; import { HttpRequest } from '../../server/HttpRequest'; import { RepresentationMetadata } from '../representation/RepresentationMetadata'; @@ -25,11 +26,8 @@ export class SimpleBodyParser extends BodyParser { const mediaType = contentType.split(';')[0]; - const metadata: RepresentationMetadata = { - raw: [], - profiles: [], - contentType: mediaType, - }; + const metadata = new RepresentationMetadata(); + metadata.add(CONTENT_TYPE, mediaType); return { dataType: DATA_TYPE_BINARY, diff --git a/src/ldp/http/SimpleResponseWriter.ts b/src/ldp/http/SimpleResponseWriter.ts index 410317f499..0cdb494583 100644 --- a/src/ldp/http/SimpleResponseWriter.ts +++ b/src/ldp/http/SimpleResponseWriter.ts @@ -1,3 +1,4 @@ +import { CONTENT_TYPE } from '../../util/MetadataTypes'; import { DATA_TYPE_BINARY } from '../../util/ContentTypes'; import { HttpError } from '../../util/errors/HttpError'; import { HttpResponse } from '../../server/HttpResponse'; @@ -30,7 +31,7 @@ export class SimpleResponseWriter extends ResponseWriter { } else { input.response.setHeader('location', input.result.identifier.path); if (input.result.body) { - const contentType = input.result.body.metadata.contentType ?? 'text/plain'; + const contentType = input.result.body.metadata.get(CONTENT_TYPE)?.value ?? 'text/plain'; input.response.setHeader('content-type', contentType); input.result.body.data.pipe(input.response); } diff --git a/src/ldp/http/SimpleSparqlUpdateBodyParser.ts b/src/ldp/http/SimpleSparqlUpdateBodyParser.ts index 0132041878..4f1c9543fd 100644 --- a/src/ldp/http/SimpleSparqlUpdateBodyParser.ts +++ b/src/ldp/http/SimpleSparqlUpdateBodyParser.ts @@ -1,8 +1,10 @@ import { BodyParser } from './BodyParser'; +import { CONTENT_TYPE } from '../../util/MetadataTypes'; import { DATA_TYPE_BINARY } from '../../util/ContentTypes'; import { HttpRequest } from '../../server/HttpRequest'; import { PassThrough } from 'stream'; import { readableToString } from '../../util/Util'; +import { RepresentationMetadata } from '../representation/RepresentationMetadata'; import { SparqlUpdatePatch } from './SparqlUpdatePatch'; import { translate } from 'sparqlalgebrajs'; import { UnsupportedHttpError } from '../../util/errors/UnsupportedHttpError'; @@ -34,16 +36,15 @@ export class SimpleSparqlUpdateBodyParser extends BodyParser { const sparql = await readableToString(toAlgebraStream); const algebra = translate(sparql, { quads: true }); + const metadata = new RepresentationMetadata(); + metadata.add(CONTENT_TYPE, 'application/sparql-update'); + // Prevent body from being requested again return { algebra, dataType: DATA_TYPE_BINARY, data: dataCopy, - metadata: { - raw: [], - profiles: [], - contentType: 'application/sparql-update', - }, + metadata, }; } catch (error) { throw new UnsupportedHttpError(error); diff --git a/src/ldp/representation/RepresentationMetadata.ts b/src/ldp/representation/RepresentationMetadata.ts index c675e83d30..12846f2397 100644 --- a/src/ldp/representation/RepresentationMetadata.ts +++ b/src/ldp/representation/RepresentationMetadata.ts @@ -1,47 +1,128 @@ -/** - * Contains metadata relevant to a representation. - */ -import { Quad } from 'rdf-js'; +import { Store } from 'n3'; +import { BlankNode, Literal, NamedNode, Quad, Term } from 'rdf-js'; +import { quad as createQuad, literal, namedNode } from '@rdfjs/data-model'; /** - * Metadata corresponding to a {@link Representation}. + * Stores the metadata triples and provides methods for easy access. */ -export interface RepresentationMetadata { +export class RepresentationMetadata { + private store: Store; + private id: NamedNode | BlankNode; + /** - * All metadata triples of the resource. + * @param identifier - Identifier of the resource relevant to this metadata. + * A blank node will be generated if none is provided. + * Strings will be converted to named nodes. + * @param quads - Quads to fill the metadata with. */ - raw: Quad[]; + public constructor(identifier?: NamedNode | BlankNode | string, quads?: Quad[]) { + this.store = new Store(quads); + if (identifier) { + if (typeof identifier === 'string') { + this.id = namedNode(identifier); + } else { + this.id = identifier; + } + } else { + this.id = this.store.createBlankNode(); + } + } + /** - * Optional metadata profiles. + * @returns All metadata quads. */ - profiles?: string[]; + public quads(): Quad[] { + return this.store.getQuads(null, null, null, null); + } + /** - * Optional size of the representation. + * Identifier of the resource this metadata is relevant to. + * Will update all relevant triples if this value gets changed. */ - byteSize?: number; + public get identifier(): NamedNode | BlankNode { + return this.id; + } + + public set identifier(id: NamedNode | BlankNode) { + const quads = this.quads().map((quad): Quad => { + if (quad.subject.equals(this.id)) { + return createQuad(id, quad.predicate, quad.object, quad.graph); + } + if (quad.object.equals(this.id)) { + return createQuad(quad.subject, quad.predicate, id, quad.graph); + } + return quad; + }); + this.store = new Store(quads); + this.id = id; + } + /** - * Optional content type of the representation. + * @param quads - Quads to add to the metadata. */ - contentType?: string; + public addQuads(quads: Quad[]): void { + this.store.addQuads(quads); + } + /** - * Optional encoding of the representation. + * @param quads - Quads to remove from the metadata. */ - encoding?: string; + public removeQuads(quads: Quad[]): void { + this.store.removeQuads(quads); + } + /** - * Optional language of the representation. + * Adds a value linked to the identifier. Strings get converted to literals. + * @param predicate - Predicate linking identifier to value. + * @param object - Value to add. */ - language?: string; + public add(predicate: NamedNode, object: NamedNode | Literal | string): void { + this.store.addQuad(this.id, predicate, typeof object === 'string' ? literal(object) : object); + } + /** - * Optional timestamp of the representation. + * Removes the given value from the metadata. Strings get converted to literals. + * @param predicate - Predicate linking identifier to value. + * @param object - Value to remove. */ - dateTime?: Date; + public remove(predicate: NamedNode, object: NamedNode | Literal | string): void { + this.store.removeQuad(this.id, predicate, typeof object === 'string' ? literal(object) : object); + } + /** - * Optional link relationships of the representation. + * Removes all values linked through the given predicate. + * @param predicate - Predicate to remove. */ - linkRel?: { [id: string]: Set }; + public removeAll(predicate: NamedNode): void { + this.removeQuads(this.store.getQuads(this.id, predicate, null, null)); + } + + /** + * @param predicate - Predicate to get the value for. + * + * @throws Error + * If there are multiple matching values. + * + * @returns The corresponding value. Undefined if there is no match + */ + public get(predicate: NamedNode): Term | undefined { + const quads = this.store.getQuads(this.id, predicate, null, null); + if (quads.length === 0) { + return; + } + if (quads.length > 1) { + throw new Error(`Multiple results for ${predicate.value}`); + } + return quads[0].object; + } + /** - * Optional slug of the representation. - * Used to suggest the URI for the resource created. + * Sets the value for the given predicate, removing all other instances. + * @param predicate - Predicate linking to the value. + * @param object - Value to set. */ - slug?: string; + public set(predicate: NamedNode, object: NamedNode | Literal | string): void { + this.removeAll(predicate); + this.add(predicate, object); + } } diff --git a/src/storage/FileResourceStore.ts b/src/storage/FileResourceStore.ts index 4df3b8543d..d0c6a18082 100644 --- a/src/storage/FileResourceStore.ts +++ b/src/storage/FileResourceStore.ts @@ -1,5 +1,6 @@ import arrayifyStream from 'arrayify-stream'; import { ConflictHttpError } from '../util/errors/ConflictHttpError'; +import { DataFactory } from 'n3'; import { contentType as getContentTypeFromExtension } from 'mime-types'; import { InteractionController } from '../util/InteractionController'; import { MetadataController } from '../util/MetadataController'; @@ -14,6 +15,7 @@ import { ResourceIdentifier } from '../ldp/representation/ResourceIdentifier'; import { ResourceStore } from './ResourceStore'; import streamifyArray from 'streamify-array'; import { UnsupportedMediaTypeHttpError } from '../util/errors/UnsupportedMediaTypeHttpError'; +import { BYTE_SIZE, CONTENT_TYPE, LAST_CHANGED, SLUG, TYPE } from '../util/MetadataTypes'; import { CONTENT_TYPE_QUADS, DATA_TYPE_BINARY, DATA_TYPE_QUAD } from '../util/ContentTypes'; import { createReadStream, createWriteStream, promises as fsPromises, Stats } from 'fs'; import { ensureTrailingSlash, trimTrailingSlashes } from '../util/Util'; @@ -60,16 +62,20 @@ export class FileResourceStore implements ResourceStore { // Get the path from the request URI, all metadata triples if any, and the Slug and Link header values. const path = this.parseIdentifier(container); - const { slug, raw } = representation.metadata; - const linkTypes = representation.metadata.linkRel?.type; + const slug = representation.metadata.get(SLUG)?.value; + const type = representation.metadata.get(TYPE)?.value; + + // Create a new container or resource in the parent container with a specific name based on the incoming headers. + const isContainer = this.interactionController.isContainer(slug, type); + const newIdentifier = this.interactionController.generateIdentifier(isContainer, slug); + let metadata; + // eslint-disable-next-line no-param-reassign + representation.metadata.identifier = DataFactory.namedNode(newIdentifier); + const raw = representation.metadata.quads(); if (raw.length > 0) { metadata = this.metadataController.generateReadableFromQuads(raw); } - - // Create a new container or resource in the parent container with a specific name based on the incoming headers. - const isContainer = this.interactionController.isContainer(slug, linkTypes); - const newIdentifier = this.interactionController.generateIdentifier(isContainer, slug); return isContainer ? this.createContainer(path, newIdentifier, path.endsWith('/'), metadata) : this.createFile(path, newIdentifier, representation.data, path.endsWith('/'), metadata); @@ -154,15 +160,17 @@ export class FileResourceStore implements ResourceStore { if ((typeof path !== 'string' || normalizePath(path) === '/') && typeof slug !== 'string') { throw new ConflictHttpError('Container with that identifier already exists (root).'); } - const { raw } = representation.metadata; - const linkTypes = representation.metadata.linkRel?.type; + // eslint-disable-next-line no-param-reassign + representation.metadata.identifier = DataFactory.namedNode(identifier.path); + const raw = representation.metadata.quads(); + const type = representation.metadata.get(TYPE)?.value; let metadata: Readable | undefined; if (raw.length > 0) { metadata = streamifyArray(raw); } // Create a new container or resource in the parent container with a specific name based on the incoming headers. - const isContainer = this.interactionController.isContainer(slug, linkTypes); + const isContainer = this.interactionController.isContainer(slug, type); const newIdentifier = this.interactionController.generateIdentifier(isContainer, slug); return isContainer ? await this.setDirectoryRepresentation(path, newIdentifier, metadata) : @@ -241,7 +249,8 @@ export class FileResourceStore implements ResourceStore { * * @returns The corresponding Representation. */ - private async getFileRepresentation(path: string, stats: Stats): Promise { + private async getFileRepresentation(path: string, stats: Stats): + Promise { const readStream = createReadStream(path); const contentType = getContentTypeFromExtension(extname(path)); let rawMetadata: Quad[] = []; @@ -251,13 +260,11 @@ export class FileResourceStore implements ResourceStore { } catch (_) { // Metadata file doesn't exist so lets keep `rawMetaData` an empty array. } - const metadata: RepresentationMetadata = { - raw: rawMetadata, - dateTime: stats.mtime, - byteSize: stats.size, - }; + const metadata = new RepresentationMetadata(this.mapFilepathToUrl(path), rawMetadata); + metadata.set(LAST_CHANGED, stats.mtime.toISOString()); + metadata.set(BYTE_SIZE, DataFactory.literal(stats.size)); if (contentType) { - metadata.contentType = contentType; + metadata.set(CONTENT_TYPE, contentType); } return { metadata, data: readStream, dataType: DATA_TYPE_BINARY }; } @@ -289,14 +296,14 @@ export class FileResourceStore implements ResourceStore { // Metadata file doesn't exist so lets keep `rawMetaData` an empty array. } + const metadata = new RepresentationMetadata(containerURI, rawMetadata); + metadata.set(LAST_CHANGED, stats.mtime.toISOString()); + metadata.set(CONTENT_TYPE, CONTENT_TYPE_QUADS); + return { dataType: DATA_TYPE_QUAD, data: streamifyArray(quads), - metadata: { - raw: rawMetadata, - dateTime: stats.mtime, - contentType: CONTENT_TYPE_QUADS, - }, + metadata, }; } diff --git a/src/storage/RepresentationConvertingStore.ts b/src/storage/RepresentationConvertingStore.ts index e34dfa507c..5fea627933 100644 --- a/src/storage/RepresentationConvertingStore.ts +++ b/src/storage/RepresentationConvertingStore.ts @@ -1,4 +1,5 @@ import { Conditions } from './Conditions'; +import { CONTENT_TYPE } from '../util/MetadataTypes'; import { matchingMediaType } from '../util/Util'; import { PassthroughStore } from './PassthroughStore'; import { Representation } from '../ldp/representation/Representation'; @@ -37,11 +38,12 @@ export class RepresentationConvertingStore extends PassthroughStore { if (!preferences.type) { return true; } + const contentType = representation.metadata.get(CONTENT_TYPE); return Boolean( - representation.metadata.contentType && + contentType && preferences.type.some((type): boolean => type.weight > 0 && - matchingMediaType(type.value, representation.metadata.contentType!)), + matchingMediaType(type.value, contentType.value)), ); } } diff --git a/src/storage/SimpleResourceStore.ts b/src/storage/SimpleResourceStore.ts index 5ba58c7c6c..fffdfc0004 100644 --- a/src/storage/SimpleResourceStore.ts +++ b/src/storage/SimpleResourceStore.ts @@ -3,6 +3,7 @@ import { DATA_TYPE_BINARY } from '../util/ContentTypes'; import { ensureTrailingSlash } from '../util/Util'; import { NotFoundHttpError } from '../util/errors/NotFoundHttpError'; import { Representation } from '../ldp/representation/Representation'; +import { RepresentationMetadata } from '../ldp/representation/RepresentationMetadata'; import { ResourceIdentifier } from '../ldp/representation/ResourceIdentifier'; import { ResourceStore } from './ResourceStore'; import streamifyArray from 'streamify-array'; @@ -27,7 +28,7 @@ export class SimpleResourceStore implements ResourceStore { '': { dataType: DATA_TYPE_BINARY, data: streamifyArray([]), - metadata: { raw: [], profiles: []}, + metadata: new RepresentationMetadata(base), }, }; } diff --git a/src/storage/conversion/ConversionUtil.ts b/src/storage/conversion/ConversionUtil.ts index 5f18c1b68e..74744e1c06 100644 --- a/src/storage/conversion/ConversionUtil.ts +++ b/src/storage/conversion/ConversionUtil.ts @@ -1,3 +1,4 @@ +import { CONTENT_TYPE } from '../../util/MetadataTypes'; import { matchingMediaType } from '../../util/Util'; import { RepresentationConverterArgs } from './RepresentationConverter'; import { RepresentationPreference } from '../../ldp/representation/RepresentationPreference'; @@ -34,11 +35,11 @@ RepresentationPreference[] => { */ export const checkRequest = (request: RepresentationConverterArgs, supportedIn: string[], supportedOut: string[]): void => { - const inType = request.representation.metadata.contentType; + const inType = request.representation.metadata.get(CONTENT_TYPE); if (!inType) { throw new UnsupportedHttpError('Input type required for conversion.'); } - if (!supportedIn.some((type): boolean => matchingMediaType(inType, type))) { + if (!supportedIn.some((type): boolean => matchingMediaType(inType.value, type))) { throw new UnsupportedHttpError(`Can only convert from ${supportedIn} to ${supportedOut}.`); } if (matchingTypes(request.preferences, supportedOut).length <= 0) { diff --git a/src/storage/conversion/QuadToTurtleConverter.ts b/src/storage/conversion/QuadToTurtleConverter.ts index 2e95baea61..fa4845c4d0 100644 --- a/src/storage/conversion/QuadToTurtleConverter.ts +++ b/src/storage/conversion/QuadToTurtleConverter.ts @@ -1,4 +1,5 @@ import { checkRequest } from './ConversionUtil'; +import { CONTENT_TYPE } from '../../util/MetadataTypes'; import { Representation } from '../../ldp/representation/Representation'; import { RepresentationMetadata } from '../../ldp/representation/RepresentationMetadata'; import { StreamWriter } from 'n3'; @@ -18,7 +19,8 @@ export class QuadToTurtleConverter extends RepresentationConverter { } private quadsToTurtle(quads: Representation): Representation { - const metadata: RepresentationMetadata = { ...quads.metadata, contentType: 'text/turtle' }; + const metadata = new RepresentationMetadata(quads.metadata.identifier, quads.metadata.quads()); + metadata.set(CONTENT_TYPE, 'text/turtle'); return { dataType: DATA_TYPE_BINARY, data: quads.data.pipe(new StreamWriter({ format: 'text/turtle' })), diff --git a/src/storage/conversion/TurtleToQuadConverter.ts b/src/storage/conversion/TurtleToQuadConverter.ts index 112d023f27..e3ab4b541c 100644 --- a/src/storage/conversion/TurtleToQuadConverter.ts +++ b/src/storage/conversion/TurtleToQuadConverter.ts @@ -1,4 +1,5 @@ import { checkRequest } from './ConversionUtil'; +import { CONTENT_TYPE } from '../../util/MetadataTypes'; import { PassThrough } from 'stream'; import { Representation } from '../../ldp/representation/Representation'; import { RepresentationMetadata } from '../../ldp/representation/RepresentationMetadata'; @@ -20,7 +21,8 @@ export class TurtleToQuadConverter extends RepresentationConverter { } private turtleToQuads(turtle: Representation, baseIRI: string): Representation { - const metadata: RepresentationMetadata = { ...turtle.metadata, contentType: CONTENT_TYPE_QUADS }; + const metadata = new RepresentationMetadata(turtle.metadata.identifier, turtle.metadata.quads()); + metadata.set(CONTENT_TYPE, CONTENT_TYPE_QUADS); // Catch parsing errors and emit correct error // Node 10 requires both writableObjectMode and readableObjectMode diff --git a/src/storage/patch/SimpleSparqlUpdatePatchHandler.ts b/src/storage/patch/SimpleSparqlUpdatePatchHandler.ts index e39cb7efcb..4e672bb819 100644 --- a/src/storage/patch/SimpleSparqlUpdatePatchHandler.ts +++ b/src/storage/patch/SimpleSparqlUpdatePatchHandler.ts @@ -1,9 +1,11 @@ import { Algebra } from 'sparqlalgebrajs'; import { BaseQuad } from 'rdf-js'; +import { CONTENT_TYPE } from '../../util/MetadataTypes'; import { defaultGraph } from '@rdfjs/data-model'; import { PatchHandler } from './PatchHandler'; import { Readable } from 'stream'; import { Representation } from '../../ldp/representation/Representation'; +import { RepresentationMetadata } from '../../ldp/representation/RepresentationMetadata'; import { ResourceIdentifier } from '../../ldp/representation/ResourceIdentifier'; import { ResourceLocker } from '../ResourceLocker'; import { ResourceStore } from '../ResourceStore'; @@ -65,14 +67,12 @@ export class SimpleSparqlUpdatePatchHandler extends PatchHandler { }); store.removeQuads(deletes); store.addQuads(inserts); + const metadata = new RepresentationMetadata(input.identifier.path); + metadata.set(CONTENT_TYPE, CONTENT_TYPE_QUADS); const representation: Representation = { data: store.match() as Readable, dataType: DATA_TYPE_QUAD, - metadata: { - raw: [], - profiles: [], - contentType: CONTENT_TYPE_QUADS, - }, + metadata, }; await this.source.setRepresentation(input.identifier, representation); diff --git a/src/util/InteractionController.ts b/src/util/InteractionController.ts index e37c2553e4..ced23b162f 100644 --- a/src/util/InteractionController.ts +++ b/src/util/InteractionController.ts @@ -8,11 +8,11 @@ export class InteractionController { * @param slug - Incoming slug header. * @param link - Incoming link header. */ - public isContainer(slug?: string, link?: Set): boolean { + public isContainer(slug?: string, link?: string): boolean { if (!slug || !slug.endsWith('/')) { - return Boolean(link?.has(LINK_TYPE_LDPC)) || Boolean(link?.has(LINK_TYPE_LDP_BC)); + return Boolean(link === LINK_TYPE_LDPC) || Boolean(link === LINK_TYPE_LDP_BC); } - return !link || link.has(LINK_TYPE_LDPC) || link.has(LINK_TYPE_LDP_BC); + return !link || link === LINK_TYPE_LDPC || link === LINK_TYPE_LDP_BC; } /** diff --git a/src/util/MetadataTypes.ts b/src/util/MetadataTypes.ts new file mode 100644 index 0000000000..a8f10ffc6d --- /dev/null +++ b/src/util/MetadataTypes.ts @@ -0,0 +1,9 @@ +import { namedNode } from '@rdfjs/data-model'; +import { NamedNode } from 'rdf-js'; + +export const TYPE: NamedNode = namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'); +export const CONTENT_TYPE: NamedNode = namedNode('http://www.w3.org/ns/ma-ont#format'); +export const SLUG: NamedNode = namedNode('http://example.com/slug'); +export const LAST_CHANGED: NamedNode = namedNode('http://example.com/lastChanged'); +export const BYTE_SIZE: NamedNode = namedNode('http://example.com/byteSize'); +export const ACL_RESOURCE: NamedNode = namedNode('http://example.com/acl'); diff --git a/test/integration/Authorization.test.ts b/test/integration/Authorization.test.ts index d47df48a52..70307ff6f2 100644 --- a/test/integration/Authorization.test.ts +++ b/test/integration/Authorization.test.ts @@ -4,12 +4,14 @@ import { BasePermissionsExtractor } from '../../src/ldp/permissions/BasePermissi import { BodyParser } from '../../src/ldp/http/BodyParser'; import { call } from '../util/Util'; import { CompositeAsyncHandler } from '../../src/util/CompositeAsyncHandler'; +import { CONTENT_TYPE } from '../../src/util/MetadataTypes'; import { DATA_TYPE_BINARY } from '../../src/util/ContentTypes'; import { MockResponse } from 'node-mocks-http'; import { Operation } from '../../src/ldp/operations/Operation'; import { PermissionSet } from '../../src/ldp/permissions/PermissionSet'; import { QuadToTurtleConverter } from '../../src/storage/conversion/QuadToTurtleConverter'; import { RepresentationConvertingStore } from '../../src/storage/RepresentationConvertingStore'; +import { RepresentationMetadata } from '../../src/ldp/representation/RepresentationMetadata'; import { ResourceStore } from '../../src/storage/ResourceStore'; import { ResponseDescription } from '../../src/ldp/operations/ResponseDescription'; import { SimpleAclAuthorizer } from '../../src/authorization/SimpleAclAuthorizer'; @@ -59,17 +61,16 @@ const setAcl = async(store: ResourceStore, id: string, permissions: PermissionSe acl.push('.'); + const aclId = { path: `${id}.acl` }; + const metadata = new RepresentationMetadata(id); + metadata.set(CONTENT_TYPE, 'text/turtle'); const representation = { data: streamifyArray(acl), dataType: DATA_TYPE_BINARY, - metadata: { - raw: [], - profiles: [], - contentType: 'text/turtle', - }, + metadata, }; - return store.setRepresentation({ path: `${id}.acl` }, representation); + return store.setRepresentation(aclId, representation); }; describe('A server with authorization', (): void => { diff --git a/test/integration/RequestParser.test.ts b/test/integration/RequestParser.test.ts index 5a006218a0..f54e672e76 100644 --- a/test/integration/RequestParser.test.ts +++ b/test/integration/RequestParser.test.ts @@ -1,8 +1,10 @@ import { AcceptPreferenceParser } from '../../src/ldp/http/AcceptPreferenceParser'; import arrayifyStream from 'arrayify-stream'; +import { CONTENT_TYPE } from '../../src/util/MetadataTypes'; import { DATA_TYPE_BINARY } from '../../src/util/ContentTypes'; import { HttpRequest } from '../../src/server/HttpRequest'; import { Readable } from 'stream'; +import { RepresentationMetadata } from '../../src/ldp/representation/RepresentationMetadata'; import { SimpleBodyParser } from '../../src/ldp/http/SimpleBodyParser'; import { SimpleRequestParser } from '../../src/ldp/http/SimpleRequestParser'; import { SimpleTargetExtractor } from '../../src/ldp/http/SimpleTargetExtractor'; @@ -36,13 +38,10 @@ describe('A SimpleRequestParser with simple input parsers', (): void => { body: { data: expect.any(Readable), dataType: DATA_TYPE_BINARY, - metadata: { - contentType: 'text/turtle', - profiles: [], - raw: [], - }, + metadata: expect.any(RepresentationMetadata), }, }); + expect(result.body?.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle'); await expect(arrayifyStream(result.body!.data)).resolves.toEqual( [ ' .' ], diff --git a/test/unit/ldp/http/SimpleBodyParser.test.ts b/test/unit/ldp/http/SimpleBodyParser.test.ts index 86eec302aa..2e74e942dc 100644 --- a/test/unit/ldp/http/SimpleBodyParser.test.ts +++ b/test/unit/ldp/http/SimpleBodyParser.test.ts @@ -1,7 +1,9 @@ import arrayifyStream from 'arrayify-stream'; +import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes'; import { DATA_TYPE_BINARY } from '../../../../src/util/ContentTypes'; import { HttpRequest } from '../../../../src/server/HttpRequest'; import { Readable } from 'stream'; +import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata'; import { SimpleBodyParser } from '../../../../src/ldp/http/SimpleBodyParser'; import streamifyArray from 'streamify-array'; import 'jest-rdf'; @@ -24,12 +26,9 @@ describe('A SimpleBodyparser', (): void => { expect(result).toEqual({ data: expect.any(Readable), dataType: DATA_TYPE_BINARY, - metadata: { - contentType: 'text/turtle', - profiles: [], - raw: [], - }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle'); await expect(arrayifyStream(result.data)).resolves.toEqual( [ ' .' ], ); diff --git a/test/unit/ldp/http/SimpleResponseWriter.test.ts b/test/unit/ldp/http/SimpleResponseWriter.test.ts index 91be497cee..fa67102e7e 100644 --- a/test/unit/ldp/http/SimpleResponseWriter.test.ts +++ b/test/unit/ldp/http/SimpleResponseWriter.test.ts @@ -1,5 +1,6 @@ +import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes'; import { EventEmitter } from 'events'; -import { Quad } from 'rdf-js'; +import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata'; import { ResponseDescription } from '../../../../src/ldp/operations/ResponseDescription'; import { SimpleResponseWriter } from '../../../../src/ldp/http/SimpleResponseWriter'; import streamifyArray from 'streamify-array'; @@ -33,10 +34,7 @@ describe('A SimpleResponseWriter', (): void => { const body = { data: streamifyArray([ ' .' ]), dataType: DATA_TYPE_BINARY, - metadata: { - raw: [] as Quad[], - profiles: [] as string[], - }, + metadata: new RepresentationMetadata(), }; response.on('end', (): void => { @@ -51,14 +49,12 @@ describe('A SimpleResponseWriter', (): void => { }); it('responds with a content-type if the metadata has it.', async(done): Promise => { + const metadata = new RepresentationMetadata(); + metadata.add(CONTENT_TYPE, 'text/turtle'); const body = { data: streamifyArray([ ' .' ]), dataType: DATA_TYPE_BINARY, - metadata: { - raw: [] as Quad[], - profiles: [] as string[], - contentType: 'text/turtle', - }, + metadata, }; response.on('end', (): void => { diff --git a/test/unit/ldp/http/SimpleSparqlUpdateBodyParser.test.ts b/test/unit/ldp/http/SimpleSparqlUpdateBodyParser.test.ts index 3981ae1fef..625de70d13 100644 --- a/test/unit/ldp/http/SimpleSparqlUpdateBodyParser.test.ts +++ b/test/unit/ldp/http/SimpleSparqlUpdateBodyParser.test.ts @@ -1,5 +1,6 @@ import { Algebra } from 'sparqlalgebrajs'; import arrayifyStream from 'arrayify-stream'; +import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes'; import { DATA_TYPE_BINARY } from '../../../../src/util/ContentTypes'; import { HttpRequest } from '../../../../src/server/HttpRequest'; import { SimpleSparqlUpdateBodyParser } from '../../../../src/ldp/http/SimpleSparqlUpdateBodyParser'; @@ -35,11 +36,7 @@ describe('A SimpleSparqlUpdateBodyParser', (): void => { namedNode('http://test.com/o'), ) ]); expect(result.dataType).toBe(DATA_TYPE_BINARY); - expect(result.metadata).toEqual({ - raw: [], - profiles: [], - contentType: 'application/sparql-update', - }); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('application/sparql-update'); // Workaround for Node 10 not exposing objectMode expect((await arrayifyStream(result.data)).join('')).toEqual( diff --git a/test/unit/ldp/representation/RepresentationMetadata.test.ts b/test/unit/ldp/representation/RepresentationMetadata.test.ts new file mode 100644 index 0000000000..2180e54693 --- /dev/null +++ b/test/unit/ldp/representation/RepresentationMetadata.test.ts @@ -0,0 +1,120 @@ +import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata'; +import { Literal, NamedNode, Quad } from 'rdf-js'; +import { literal, namedNode, quad } from '@rdfjs/data-model'; + +describe('A RepresentationMetadata', (): void => { + let metadata: RepresentationMetadata; + const identifier = namedNode('http://example.com/id'); + const inputQuads = [ + quad(identifier, namedNode('has'), literal('data')), + quad(identifier, namedNode('has'), literal('moreData')), + quad(identifier, namedNode('hasOne'), literal('otherData')), + quad(namedNode('otherNode'), namedNode('linksTo'), identifier), + quad(namedNode('otherNode'), namedNode('has'), literal('otherData')), + ]; + + describe('constructor', (): void => { + it('creates a blank node if no identifier was given.', async(): Promise => { + metadata = new RepresentationMetadata(); + expect(metadata.identifier.termType).toEqual('BlankNode'); + expect(metadata.quads()).toHaveLength(0); + }); + + it('stores the given identifier if given.', async(): Promise => { + metadata = new RepresentationMetadata(namedNode('identifier')); + expect(metadata.identifier).toEqualRdfTerm(namedNode('identifier')); + }); + + it('converts identifier strings to named nodes.', async(): Promise => { + metadata = new RepresentationMetadata('identifier'); + expect(metadata.identifier).toEqualRdfTerm(namedNode('identifier')); + }); + + it('stores input quads.', async(): Promise => { + metadata = new RepresentationMetadata(identifier, inputQuads); + expect(metadata.quads()).toBeRdfIsomorphic(inputQuads); + }); + }); + + describe('instantiated', (): void => { + beforeEach(async(): Promise => { + metadata = new RepresentationMetadata(identifier, inputQuads); + }); + + it('can change the stored identifier.', async(): Promise => { + const newIdentifier = namedNode('newNode'); + metadata.identifier = newIdentifier; + const newQuads = inputQuads.map((triple): Quad => { + if (triple.subject.equals(identifier)) { + return quad(newIdentifier, triple.predicate, triple.object); + } + if (triple.object.equals(identifier)) { + return quad(triple.subject, triple.predicate, newIdentifier); + } + return triple; + }); + expect(metadata.identifier).toEqualRdfTerm(newIdentifier); + expect(metadata.quads()).toBeRdfIsomorphic(newQuads); + }); + + it('can add quads.', async(): Promise => { + const newQuads: Quad[] = [ + quad(namedNode('random'), namedNode('new'), namedNode('triple')), + ]; + metadata.addQuads(newQuads); + expect(metadata.quads()).toBeRdfIsomorphic(newQuads.concat(inputQuads)); + }); + + it('can remove quads.', async(): Promise => { + metadata.removeQuads([ inputQuads[0] ]); + expect(metadata.quads()).toBeRdfIsomorphic(inputQuads.slice(1)); + }); + + it('can add a single value for a predicate.', async(): Promise => { + const newQuad = quad(identifier, namedNode('new'), namedNode('triple')); + metadata.add(newQuad.predicate as NamedNode, newQuad.object as NamedNode); + expect(metadata.quads()).toBeRdfIsomorphic([ newQuad ].concat(inputQuads)); + }); + + it('can add single values as string.', async(): Promise => { + const newQuad = quad(identifier, namedNode('new'), literal('triple')); + metadata.add(newQuad.predicate as NamedNode, newQuad.object.value); + expect(metadata.quads()).toBeRdfIsomorphic([ newQuad ].concat(inputQuads)); + }); + + it('can remove a single value for a predicate.', async(): Promise => { + metadata.remove(inputQuads[0].predicate as NamedNode, inputQuads[0].object as Literal); + expect(metadata.quads()).toBeRdfIsomorphic(inputQuads.slice(1)); + }); + + it('can remove single values as string.', async(): Promise => { + metadata.remove(inputQuads[0].predicate as NamedNode, inputQuads[0].object.value); + expect(metadata.quads()).toBeRdfIsomorphic(inputQuads.slice(1)); + }); + + it('can remove all values for a predicate.', async(): Promise => { + const pred = namedNode('has'); + metadata.removeAll(pred); + const updatedNodes = inputQuads.filter((triple): boolean => + !triple.subject.equals(identifier) || !triple.predicate.equals(pred)); + expect(metadata.quads()).toBeRdfIsomorphic(updatedNodes); + }); + + it('can get the single value for a predicate.', async(): Promise => { + expect(metadata.get(namedNode('hasOne'))).toEqualRdfTerm(literal('otherData')); + }); + + it('returns undefined if getting an undefined predicate.', async(): Promise => { + expect(metadata.get(namedNode('doesntExist'))).toBeUndefined(); + }); + + it('errors if there are multiple values when getting a value.', async(): Promise => { + expect((): any => metadata.get(namedNode('has'))).toThrow(Error); + }); + + it('can set the value of predicate.', async(): Promise => { + metadata.set(namedNode('has'), literal('singleValue')); + expect(metadata.get(namedNode('has'))).toEqualRdfTerm(literal('singleValue')); + }); + }); +}); diff --git a/test/unit/storage/FileResourceStore.test.ts b/test/unit/storage/FileResourceStore.test.ts index d88128cbe5..7f70e60961 100644 --- a/test/unit/storage/FileResourceStore.test.ts +++ b/test/unit/storage/FileResourceStore.test.ts @@ -12,11 +12,12 @@ import { Readable } from 'stream'; import { RepresentationMetadata } from '../../../src/ldp/representation/RepresentationMetadata'; import streamifyArray from 'streamify-array'; import { UnsupportedMediaTypeHttpError } from '../../../src/util/errors/UnsupportedMediaTypeHttpError'; +import { BYTE_SIZE, CONTENT_TYPE, LAST_CHANGED, SLUG, TYPE } from '../../../src/util/MetadataTypes'; import { CONTENT_TYPE_QUADS, DATA_TYPE_BINARY, DATA_TYPE_QUAD } from '../../../src/util/ContentTypes'; import fs, { promises as fsPromises, Stats, WriteStream } from 'fs'; import { LDP, RDF, STAT, TERMS, XML } from '../../../src/util/Prefixes'; import { LINK_TYPE_LDP_BC, LINK_TYPE_LDPR } from '../../../src/util/LinkTypes'; -import { literal, namedNode, quad as quadRDF, triple } from '@rdfjs/data-model'; +import { literal, namedNode, quad as quadRDF } from '@rdfjs/data-model'; const { join: joinPath } = posix; @@ -37,11 +38,6 @@ describe('A FileResourceStore', (): void => { let stats: Stats; let writeStream: WriteStream; const rawData = 'lorem ipsum dolor sit amet consectetur adipiscing'; - const quad = triple( - namedNode('http://test.com/s'), - namedNode('http://test.com/p'), - namedNode('http://test.com/o'), - ); fs.createReadStream = jest.fn(); @@ -53,13 +49,14 @@ describe('A FileResourceStore', (): void => { representation = { data: streamifyArray([ rawData ]), dataType: DATA_TYPE_BINARY, - metadata: { raw: [], linkRel: { type: new Set() }} as RepresentationMetadata, + metadata: new RepresentationMetadata(), }; stats = { isDirectory: jest.fn((): any => false) as Function, isFile: jest.fn((): any => false) as Function, mtime: new Date(), + size: 5, } as jest.Mocked; // Mock the fs functions for the createDataFile function. @@ -129,7 +126,8 @@ describe('A FileResourceStore', (): void => { (fs.createReadStream as jest.Mock).mockImplementationOnce((): any => new Error('Metadata file does not exist.')); // Write container (POST) - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDP_BC ]) }, slug: 'myContainer/', raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDP_BC); + representation.metadata.add(SLUG, 'myContainer/'); const identifier = await store.addResource({ path: base }, representation); expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(root, 'myContainer/'), { recursive: true }); expect(identifier.path).toBe(`${base}myContainer/`); @@ -139,12 +137,10 @@ describe('A FileResourceStore', (): void => { expect(result).toEqual({ dataType: DATA_TYPE_QUAD, data: expect.any(Readable), - metadata: { - raw: [], - dateTime: stats.mtime, - contentType: CONTENT_TYPE_QUADS, - }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString()); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(CONTENT_TYPE_QUADS); await expect(arrayifyStream(result.data)).resolves.toBeDefined(); }); @@ -153,7 +149,8 @@ describe('A FileResourceStore', (): void => { (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDP_BC ]) }, slug: 'myContainer/', raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDP_BC); + representation.metadata.add(SLUG, 'myContainer/'); await expect(store.addResource({ path: `${base}foo` }, representation)).rejects.toThrow(MethodNotAllowedHttpError); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'foo')); }); @@ -169,17 +166,19 @@ describe('A FileResourceStore', (): void => { (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDP_BC ]) }, slug: 'myContainer/', raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDP_BC); + representation.metadata.add(SLUG, 'myContainer/'); await expect(store.addResource({ path: `${base}doesnotexist` }, representation)) .rejects.toThrow(MethodNotAllowedHttpError); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'doesnotexist')); - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDPR ]) }, slug: 'file.txt', raw: []}; + representation.metadata.set(TYPE, LINK_TYPE_LDPR); + representation.metadata.set(SLUG, 'file.txt'); await expect(store.addResource({ path: `${base}doesnotexist` }, representation)) .rejects.toThrow(MethodNotAllowedHttpError); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'doesnotexist')); - representation.metadata = { linkRel: { type: new Set() }, slug: 'file.txt', raw: []}; + representation.metadata.removeAll(TYPE); await expect(store.addResource({ path: `${base}existingresource` }, representation)) .rejects.toThrow(MethodNotAllowedHttpError); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'existingresource')); @@ -209,13 +208,11 @@ describe('A FileResourceStore', (): void => { expect(result).toEqual({ dataType: DATA_TYPE_BINARY, data: expect.any(Readable), - metadata: { - raw: [], - dateTime: stats.mtime, - byteSize: stats.size, - contentType: 'text/plain; charset=utf-8', - }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString()); + expect(result.metadata.get(BYTE_SIZE)?.value).toEqual(`${stats.size}`); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/plain; charset=utf-8'); await expect(arrayifyStream(result.data)).resolves.toEqual([ rawData ]); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'file.txt')); expect(fs.createReadStream as jest.Mock).toBeCalledWith(joinPath(root, 'file.txt')); @@ -250,7 +247,8 @@ describe('A FileResourceStore', (): void => { (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDPR ]) }, slug: 'file.txt', raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDPR); + representation.metadata.add(SLUG, 'file.txt'); const identifier = await store.addResource({ path: `${base}doesnotexistyet/` }, representation); expect(identifier.path).toBe(`${base}doesnotexistyet/file.txt`); expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(root, 'doesnotexistyet/'), { recursive: true }); @@ -274,13 +272,12 @@ describe('A FileResourceStore', (): void => { (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDPR ]) }, raw: [ quad ]}; + representation.metadata.add(TYPE, LINK_TYPE_LDPR); representation.data = readableMock; await store.addResource({ path: `${base}foo/` }, representation); expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(root, 'foo/'), { recursive: true }); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'foo/')); - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDPR ]) }, raw: [ quad ]}; await store.setRepresentation({ path: `${base}foo/file.txt` }, representation); expect(fs.createWriteStream as jest.Mock).toBeCalledTimes(4); }); @@ -361,12 +358,10 @@ describe('A FileResourceStore', (): void => { expect(result).toEqual({ dataType: DATA_TYPE_QUAD, data: expect.any(Readable), - metadata: { - raw: [], - dateTime: stats.mtime, - contentType: CONTENT_TYPE_QUADS, - }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString()); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(CONTENT_TYPE_QUADS); await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray(quads); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'foo/')); expect(fsPromises.readdir as jest.Mock).toBeCalledWith(joinPath(root, 'foo/')); @@ -374,7 +369,7 @@ describe('A FileResourceStore', (): void => { expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'foo', '.nonresource')); }); - it('can overwrite representation with PUT.', async(): Promise => { + it('can overwrite representation and its metadata with PUT.', async(): Promise => { // Mock the fs functions. stats.isFile = jest.fn((): any => true); (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); @@ -384,9 +379,9 @@ describe('A FileResourceStore', (): void => { (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDPR ]) }, raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDPR); await store.setRepresentation({ path: `${base}alreadyexists.txt` }, representation); - expect(fs.createWriteStream as jest.Mock).toBeCalledTimes(1); + expect(fs.createWriteStream as jest.Mock).toBeCalledTimes(2); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'alreadyexists.txt')); expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(root, { recursive: true }); }); @@ -400,7 +395,7 @@ describe('A FileResourceStore', (): void => { await expect(store.setRepresentation({ path: `${base}alreadyexists` }, representation)).rejects .toThrow(ConflictHttpError); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'alreadyexists')); - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDP_BC ]) }, raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDP_BC); await expect(store.setRepresentation({ path: `${base}alreadyexists/` }, representation)).rejects .toThrow(ConflictHttpError); expect(fsPromises.access as jest.Mock).toBeCalledTimes(1); @@ -414,7 +409,7 @@ describe('A FileResourceStore', (): void => { (fsPromises.mkdir as jest.Mock).mockReturnValueOnce(true); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDP_BC ]) }, raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDP_BC); await store.setRepresentation({ path: `${base}foo/` }, representation); expect(fsPromises.mkdir as jest.Mock).toBeCalledTimes(1); expect(fsPromises.access as jest.Mock).toBeCalledTimes(1); @@ -443,7 +438,8 @@ describe('A FileResourceStore', (): void => { (fsPromises.unlink as jest.Mock).mockReturnValueOnce(true); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDPR ]) }, slug: 'file.txt', raw: [ quad ]}; + representation.metadata.add(TYPE, LINK_TYPE_LDPR); + representation.metadata.add(SLUG, 'file.txt'); await expect(store.addResource({ path: base }, representation)).rejects.toThrow(Error); expect(fs.createWriteStream as jest.Mock).toBeCalledWith(joinPath(root, 'file.txt.metadata')); expect(fs.createWriteStream as jest.Mock).toBeCalledWith(joinPath(root, 'file.txt')); @@ -459,7 +455,8 @@ describe('A FileResourceStore', (): void => { (fsPromises.rmdir as jest.Mock).mockReturnValueOnce(true); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDP_BC ]) }, slug: 'foo/', raw: [ quad ]}; + representation.metadata.add(TYPE, LINK_TYPE_LDP_BC); + representation.metadata.add(SLUG, 'foo/'); await expect(store.addResource({ path: base }, representation)).rejects.toThrow(Error); expect(fsPromises.rmdir as jest.Mock).toBeCalledWith(joinPath(root, 'foo/')); }); @@ -470,7 +467,7 @@ describe('A FileResourceStore', (): void => { (fsPromises.mkdir as jest.Mock).mockReturnValueOnce(true); // Tests - representation.metadata = { slug: 'myContainer/', raw: []}; + representation.metadata.add(SLUG, 'myContainer/'); const identifier = await store.addResource({ path: base }, representation); expect(identifier.path).toBe(`${base}myContainer/`); expect(fsPromises.mkdir as jest.Mock).toBeCalledTimes(1); @@ -488,12 +485,10 @@ describe('A FileResourceStore', (): void => { expect(result).toEqual({ dataType: DATA_TYPE_BINARY, data: expect.any(Readable), - metadata: { - raw: [], - dateTime: stats.mtime, - byteSize: stats.size, - }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString()); + expect(result.metadata.get(BYTE_SIZE)?.value).toEqual(`${stats.size}`); }); it('errors when performing a PUT on the root path.', async(): Promise => { @@ -512,7 +507,6 @@ describe('A FileResourceStore', (): void => { (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); // Tests - representation.metadata = { raw: []}; await store.setRepresentation({ path: `${base}file.txt` }, representation); expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(root, { recursive: true }); expect(fs.createWriteStream as jest.Mock).toBeCalledTimes(1); @@ -527,10 +521,44 @@ describe('A FileResourceStore', (): void => { (fsPromises.mkdir as jest.Mock).mockReturnValue(true); // Tests - representation.metadata = { linkRel: { type: new Set([ LINK_TYPE_LDP_BC ]) }, slug: 'bar', raw: []}; + representation.metadata.add(TYPE, LINK_TYPE_LDP_BC); + representation.metadata.add(SLUG, 'bar'); const identifier = await store.addResource({ path: `${base}foo` }, representation); expect(identifier.path).toBe(`${base}foo/bar/`); expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, 'foo')); expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(root, 'foo', 'bar/'), { recursive: false }); }); + + it('generates a new URI when adding without a slug.', async(): Promise => { + // Mock the fs functions. + // Post + (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); + (fsPromises.mkdir as jest.Mock).mockReturnValue(true); + stats.isDirectory = jest.fn((): any => true); + (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); + + // Mock: Get + stats.isFile = jest.fn((): any => true); + (fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats); + (fs.createReadStream as jest.Mock).mockReturnValueOnce(streamifyArray([ rawData ])); + (fs.createReadStream as jest.Mock).mockImplementationOnce((): any => new Error('Metadata file does not exist.')); + + // Tests + await store.addResource({ path: base }, representation); + const filePath: string = (fs.createWriteStream as jest.Mock).mock.calls[0][0]; + expect(filePath.startsWith(root)).toBeTruthy(); + const name = filePath.slice(root.length); + const result = await store.getRepresentation({ path: `${base}${name}` }); + expect(result).toEqual({ + dataType: DATA_TYPE_BINARY, + data: expect.any(Readable), + metadata: expect.any(RepresentationMetadata), + }); + expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString()); + expect(result.metadata.get(BYTE_SIZE)?.value).toEqual(`${stats.size}`); + await expect(arrayifyStream(result.data)).resolves.toEqual([ rawData ]); + expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(root, name)); + expect(fs.createReadStream as jest.Mock).toBeCalledWith(joinPath(root, name)); + expect(fs.createReadStream as jest.Mock).toBeCalledWith(joinPath(root, `${name}.metadata`)); + }); }); diff --git a/test/unit/storage/RepresentationConvertingStore.test.ts b/test/unit/storage/RepresentationConvertingStore.test.ts index 4d6fd32c75..991bfa623d 100644 --- a/test/unit/storage/RepresentationConvertingStore.test.ts +++ b/test/unit/storage/RepresentationConvertingStore.test.ts @@ -1,5 +1,7 @@ +import { CONTENT_TYPE } from '../../../src/util/MetadataTypes'; import { RepresentationConverter } from '../../../src/storage/conversion/RepresentationConverter'; import { RepresentationConvertingStore } from '../../../src/storage/RepresentationConvertingStore'; +import { RepresentationMetadata } from '../../../src/ldp/representation/RepresentationMetadata'; import { ResourceStore } from '../../../src/storage/ResourceStore'; describe('A RepresentationConvertingStore', (): void => { @@ -7,10 +9,12 @@ describe('A RepresentationConvertingStore', (): void => { let source: ResourceStore; let handleSafeFn: jest.Mock, []>; let converter: RepresentationConverter; + const metadata = new RepresentationMetadata(); + metadata.add(CONTENT_TYPE, 'text/turtle'); beforeEach(async(): Promise => { source = { - getRepresentation: jest.fn(async(): Promise => ({ data: 'data', metadata: { contentType: 'text/turtle' }})), + getRepresentation: jest.fn(async(): Promise => ({ data: 'data', metadata })), } as unknown as ResourceStore; handleSafeFn = jest.fn(async(): Promise => 'converter'); @@ -20,12 +24,14 @@ describe('A RepresentationConvertingStore', (): void => { }); it('returns the Representation from the source if no changes are required.', async(): Promise => { - await expect(store.getRepresentation({ path: 'path' }, { type: [ + const result = await store.getRepresentation({ path: 'path' }, { type: [ { value: 'text/*', weight: 0 }, { value: 'text/turtle', weight: 1 }, - ]})).resolves.toEqual({ + ]}); + expect(result).toEqual({ data: 'data', - metadata: { contentType: 'text/turtle' }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle'); expect(source.getRepresentation).toHaveBeenCalledTimes(1); expect(source.getRepresentation).toHaveBeenLastCalledWith( { path: 'path' }, { type: [{ value: 'text/*', weight: 0 }, { value: 'text/turtle', weight: 1 }]}, undefined, @@ -34,10 +40,12 @@ describe('A RepresentationConvertingStore', (): void => { }); it('returns the Representation from the source if there are no preferences.', async(): Promise => { - await expect(store.getRepresentation({ path: 'path' }, {})).resolves.toEqual({ + const result = await store.getRepresentation({ path: 'path' }, {}); + expect(result).toEqual({ data: 'data', - metadata: { contentType: 'text/turtle' }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle'); expect(source.getRepresentation).toHaveBeenCalledTimes(1); expect(source.getRepresentation).toHaveBeenLastCalledWith( { path: 'path' }, {}, undefined, @@ -53,7 +61,7 @@ describe('A RepresentationConvertingStore', (): void => { expect(handleSafeFn).toHaveBeenCalledTimes(1); expect(handleSafeFn).toHaveBeenLastCalledWith({ identifier: { path: 'path' }, - representation: { data: 'data', metadata: { contentType: 'text/turtle' }}, + representation: { data: 'data', metadata }, preferences: { type: [{ value: 'text/plain', weight: 1 }, { value: 'text/turtle', weight: 0 }]}, }); }); diff --git a/test/unit/storage/conversion/ConversionUtil.test.ts b/test/unit/storage/conversion/ConversionUtil.test.ts index a3f0e5c251..7da16b6c3f 100644 --- a/test/unit/storage/conversion/ConversionUtil.test.ts +++ b/test/unit/storage/conversion/ConversionUtil.test.ts @@ -1,35 +1,43 @@ +import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes'; import { Representation } from '../../../../src/ldp/representation/Representation'; +import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata'; import { RepresentationPreferences } from '../../../../src/ldp/representation/RepresentationPreferences'; import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceIdentifier'; import { checkRequest, matchingTypes } from '../../../../src/storage/conversion/ConversionUtil'; describe('A ConversionUtil', (): void => { const identifier: ResourceIdentifier = { path: 'path' }; + let representation: Representation; + let metadata: RepresentationMetadata; + + beforeEach(async(): Promise => { + metadata = new RepresentationMetadata(); + representation = { metadata } as Representation; + }); describe('#checkRequest', (): void => { it('requires an input type.', async(): Promise => { - const representation = { metadata: {}} as Representation; const preferences: RepresentationPreferences = {}; expect((): any => checkRequest({ identifier, representation, preferences }, [ '*/*' ], [ '*/*' ])) .toThrow('Input type required for conversion.'); }); it('requires a matching input type.', async(): Promise => { - const representation = { metadata: { contentType: 'a/x' }} as Representation; + metadata.add(CONTENT_TYPE, 'a/x'); const preferences: RepresentationPreferences = { type: [{ value: 'b/x', weight: 1 }]}; expect((): any => checkRequest({ identifier, representation, preferences }, [ 'c/x' ], [ '*/*' ])) .toThrow('Can only convert from c/x to */*.'); }); it('requires a matching output type.', async(): Promise => { - const representation = { metadata: { contentType: 'a/x' }} as Representation; + metadata.add(CONTENT_TYPE, 'a/x'); const preferences: RepresentationPreferences = { type: [{ value: 'b/x', weight: 1 }]}; expect((): any => checkRequest({ identifier, representation, preferences }, [ '*/*' ], [ 'c/x' ])) .toThrow('Can only convert from */* to c/x.'); }); it('succeeds with a valid input and output type.', async(): Promise => { - const representation = { metadata: { contentType: 'a/x' }} as Representation; + metadata.add(CONTENT_TYPE, 'a/x'); const preferences: RepresentationPreferences = { type: [{ value: 'b/x', weight: 1 }]}; expect(checkRequest({ identifier, representation, preferences }, [ '*/*' ], [ '*/*' ])) .toBeUndefined(); diff --git a/test/unit/storage/conversion/QuadToTurtleConverter.test.ts b/test/unit/storage/conversion/QuadToTurtleConverter.test.ts index 7f2677a928..181f953804 100644 --- a/test/unit/storage/conversion/QuadToTurtleConverter.test.ts +++ b/test/unit/storage/conversion/QuadToTurtleConverter.test.ts @@ -1,7 +1,9 @@ import arrayifyStream from 'arrayify-stream'; +import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes'; import { QuadToTurtleConverter } from '../../../../src/storage/conversion/QuadToTurtleConverter'; import { Readable } from 'stream'; import { Representation } from '../../../../src/ldp/representation/Representation'; +import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata'; import { RepresentationPreferences } from '../../../../src/ldp/representation/RepresentationPreferences'; import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceIdentifier'; import streamifyArray from 'streamify-array'; @@ -11,9 +13,11 @@ import { namedNode, triple } from '@rdfjs/data-model'; describe('A QuadToTurtleConverter', (): void => { const converter = new QuadToTurtleConverter(); const identifier: ResourceIdentifier = { path: 'path' }; + const metadata = new RepresentationMetadata(); + metadata.add(CONTENT_TYPE, CONTENT_TYPE_QUADS); it('can handle quad to turtle conversions.', async(): Promise => { - const representation = { metadata: { contentType: CONTENT_TYPE_QUADS }} as Representation; + const representation = { metadata } as Representation; const preferences: RepresentationPreferences = { type: [{ value: 'text/turtle', weight: 1 }]}; await expect(converter.canHandle({ identifier, representation, preferences })).resolves.toBeUndefined(); }); @@ -25,17 +29,16 @@ describe('A QuadToTurtleConverter', (): void => { namedNode('http://test.com/p'), namedNode('http://test.com/o'), ) ]), - metadata: { contentType: CONTENT_TYPE_QUADS }, + metadata, } as Representation; const preferences: RepresentationPreferences = { type: [{ value: 'text/turtle', weight: 1 }]}; const result = await converter.handle({ identifier, representation, preferences }); expect(result).toEqual({ data: expect.any(Readable), dataType: DATA_TYPE_BINARY, - metadata: { - contentType: 'text/turtle', - }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle'); await expect(arrayifyStream(result.data)).resolves.toContain( ' ', ); diff --git a/test/unit/storage/conversion/TurtleToQuadConverter.test.ts b/test/unit/storage/conversion/TurtleToQuadConverter.test.ts index af92ed4491..2a93988db0 100644 --- a/test/unit/storage/conversion/TurtleToQuadConverter.test.ts +++ b/test/unit/storage/conversion/TurtleToQuadConverter.test.ts @@ -1,6 +1,8 @@ import arrayifyStream from 'arrayify-stream'; +import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes'; import { Readable } from 'stream'; import { Representation } from '../../../../src/ldp/representation/Representation'; +import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata'; import { RepresentationPreferences } from '../../../../src/ldp/representation/RepresentationPreferences'; import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceIdentifier'; import streamifyArray from 'streamify-array'; @@ -12,9 +14,11 @@ import { namedNode, triple } from '@rdfjs/data-model'; describe('A TurtleToQuadConverter', (): void => { const converter = new TurtleToQuadConverter(); const identifier: ResourceIdentifier = { path: 'path' }; + const metadata = new RepresentationMetadata(); + metadata.add(CONTENT_TYPE, 'text/turtle'); it('can handle turtle to quad conversions.', async(): Promise => { - const representation = { metadata: { contentType: 'text/turtle' }} as Representation; + const representation = { metadata } as Representation; const preferences: RepresentationPreferences = { type: [{ value: CONTENT_TYPE_QUADS, weight: 1 }]}; await expect(converter.canHandle({ identifier, representation, preferences })).resolves.toBeUndefined(); }); @@ -22,17 +26,16 @@ describe('A TurtleToQuadConverter', (): void => { it('converts turtle to quads.', async(): Promise => { const representation = { data: streamifyArray([ ' .' ]), - metadata: { contentType: 'text/turtle' }, + metadata, } as Representation; const preferences: RepresentationPreferences = { type: [{ value: CONTENT_TYPE_QUADS, weight: 1 }]}; const result = await converter.handle({ identifier, representation, preferences }); expect(result).toEqual({ data: expect.any(Readable), dataType: DATA_TYPE_QUAD, - metadata: { - contentType: CONTENT_TYPE_QUADS, - }, + metadata: expect.any(RepresentationMetadata), }); + expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(CONTENT_TYPE_QUADS); await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray([ triple( namedNode('http://test.com/s'), namedNode('http://test.com/p'), @@ -43,17 +46,16 @@ describe('A TurtleToQuadConverter', (): void => { it('throws an UnsupportedHttpError on invalid triple data.', async(): Promise => { const representation = { data: streamifyArray([ ' { expect(setParams[0]).toEqual({ path: 'path' }); expect(setParams[1]).toEqual(expect.objectContaining({ dataType: DATA_TYPE_QUAD, - metadata: { raw: [], profiles: [], contentType: CONTENT_TYPE_QUADS }, + metadata: expect.any(RepresentationMetadata), })); + expect(setParams[1].metadata.get(CONTENT_TYPE)?.value).toEqual(CONTENT_TYPE_QUADS); await expect(arrayifyStream(setParams[1].data)).resolves.toBeRdfIsomorphic(quads); };