Mirroristas/CommunitySolidServer
2
0
Fork 0
mirror of https://github.com/CommunitySolidServer/CommunitySolidServer.git synced 2024-10-03 14:55:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

change: Make RepresentationMetadata accept a ResourceIdentifier.

Browse Source 
Closes https://github.com/solid/community-server/issues/388
This commit is contained in:
Ruben Verborgh 2020-12-10 16:24:38 +00:00 committed by Joachim Van Herwegen
parent 6ee56a6d67
commit accfc2e58d
13 changed files with 53 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/init/AclInitializer.ts
View File

@ -66,7 +66,7 @@ export class AclInitializer extends Initializer {
acl:mode acl:Control;
acl:accessTo <${this.baseUrl}>;
acl:default <${this.baseUrl}>.`;
const metadata = new RepresentationMetadata(rootAcl.path, { [CONTENT_TYPE]: TEXT_TURTLE });
const metadata = new RepresentationMetadata(rootAcl, { [CONTENT_TYPE]: TEXT_TURTLE });
this.logger.debug(`Installing root ACL document at ${rootAcl.path}`);
await this.store.setRepresentation(
rootAcl,

11
src/ldp/representation/RepresentationMetadata.ts
View File

@ -2,7 +2,10 @@ import { DataFactory, Store } from 'n3';
import type { BlankNode, Literal, NamedNode, Quad, Term } from 'rdf-js';
import { getLoggerFor } from '../../logging/LogUtil';
import { toObjectTerm, toNamedNode, isTerm } from '../../util/UriUtil';
import type { ResourceIdentifier } from './ResourceIdentifier';
import { isResourceIdentifier } from './ResourceIdentifier';
export type MetadataIdentifier = ResourceIdentifier | NamedNode | BlankNode;
export type MetadataOverrideValue = NamedNode | Literal | string | (NamedNode | Literal | string)[];
/**
@ -23,7 +26,7 @@ export class RepresentationMetadata {
*
* `@ignored` tag is necessary for Components-Generator.js
*/
public constructor(identifier?: NamedNode | BlankNode | string, overrides?: Record<string, MetadataOverrideValue>);
public constructor(identifier?: MetadataIdentifier, overrides?: Record<string, MetadataOverrideValue>);
/**
* @param metadata - Starts as a copy of the input metadata.
@ -38,12 +41,12 @@ export class RepresentationMetadata {
public constructor(overrides?: Record<string, MetadataOverrideValue>);
public constructor(
input?: NamedNode | BlankNode | string | RepresentationMetadata | Record<string, MetadataOverrideValue>,
input?: MetadataIdentifier | RepresentationMetadata | Record<string, MetadataOverrideValue>,
overrides?: Record<string, MetadataOverrideValue>,
) {
this.store = new Store();
if (typeof input === 'string') {
this.id = DataFactory.namedNode(input);
if (isResourceIdentifier(input)) {
this.id = DataFactory.namedNode(input.path);
} else if (isTerm(input)) {
this.id = input;
} else if (input instanceof RepresentationMetadata) {

7
src/ldp/representation/ResourceIdentifier.ts
View File

@ -7,3 +7,10 @@ export interface ResourceIdentifier {
*/
path: string;
}
/**
* Determines whether the object is a `ResourceIdentifier`.
*/
export const isResourceIdentifier = function(object: any): object is ResourceIdentifier {
return object && (typeof object.path === 'string');
};

4
src/pods/generate/TemplatedResourcesGenerator.ts
View File

@ -51,7 +51,7 @@ export class TemplatedResourcesGenerator implements ResourcesGenerator {
representation: {
binary: true,
data: guardedStreamFrom([]),
metadata: new RepresentationMetadata(link.identifier.path),
metadata: new RepresentationMetadata(link.identifier),
},
};
@ -74,7 +74,7 @@ export class TemplatedResourcesGenerator implements ResourcesGenerator {
private async generateDocument(filePath: string, mapper: FileIdentifierMapper, options: Dict<string>):
Promise<Resource> {
const link = await mapper.mapFilePathToUrl(filePath, false);
const metadata = new RepresentationMetadata(link.identifier.path);
const metadata = new RepresentationMetadata(link.identifier);
metadata.contentType = link.contentType;
const raw = await fsPromises.readFile(filePath, 'utf8');

2
src/storage/DataAccessorBasedStore.ts
View File

@ -370,7 +370,7 @@ export class DataAccessorBasedStore implements ResourceStore {
return {
binary: true,
data: guardedStreamFrom([]),
metadata: new RepresentationMetadata(container.path),
metadata: new RepresentationMetadata(container),
};
}
}

2
src/storage/accessors/FileDataAccessor.ts
View File

@ -246,7 +246,7 @@ export class FileDataAccessor implements DataAccessor {
*/
private async getBaseMetadata(link: ResourceLink, stats: Stats, isContainer: boolean):
Promise<RepresentationMetadata> {
const metadata = new RepresentationMetadata(link.identifier.path)
const metadata = new RepresentationMetadata(link.identifier)
.addQuads(await this.getRawMetadata(link.identifier));
metadata.addQuads(generateResourceQuads(metadata.identifier as NamedNode, isContainer));
metadata.addQuads(this.generatePosixQuads(metadata.identifier as NamedNode, stats));

2
src/storage/accessors/InMemoryDataAccessor.ts
View File

@ -28,7 +28,7 @@ export class InMemoryDataAccessor implements DataAccessor {
public constructor(base: string) {
this.base = ensureTrailingSlash(base);
const metadata = new RepresentationMetadata(this.base);
const metadata = new RepresentationMetadata({ path: this.base });
metadata.addQuads(generateResourceQuads(DataFactory.namedNode(this.base), true));
this.store = { entries: {}, metadata };
}

2
src/storage/accessors/SparqlDataAccessor.ts
View File

@ -94,7 +94,7 @@ export class SparqlDataAccessor implements DataAccessor {
throw new NotFoundHttpError();
}
const metadata = new RepresentationMetadata(identifier.path).addQuads(quads);
const metadata = new RepresentationMetadata(identifier).addQuads(quads);
if (!isContainerIdentifier(identifier)) {
metadata.contentType = INTERNAL_QUADS;
}

2
src/storage/patch/SparqlUpdatePatchHandler.ts
View File

@ -108,7 +108,7 @@ export class SparqlUpdatePatchHandler extends PatchHandler {
this.logger.debug(`${store.size} quads will be stored to ${identifier.path}.`);
// Write the result
const metadata = new RepresentationMetadata(identifier.path, { [CONTENT_TYPE]: INTERNAL_QUADS });
const metadata = new RepresentationMetadata(identifier, { [CONTENT_TYPE]: INTERNAL_QUADS });
const representation: Representation = {
binary: false,
data: guardStream(store.match() as Readable),

8
test/unit/ldp/representation/RepresentationMetadata.test.ts
View File

@ -28,12 +28,12 @@ describe('A RepresentationMetadata', (): void => {
});
it('converts identifier strings to named nodes.', async(): Promise<void> => {
metadata = new RepresentationMetadata('identifier');
metadata = new RepresentationMetadata({ path: 'identifier' });
expect(metadata.identifier).toEqualRdfTerm(namedNode('identifier'));
});
it('copies an other metadata object.', async(): Promise<void> => {
const other = new RepresentationMetadata('otherId', { 'test:pred': 'objVal' });
const other = new RepresentationMetadata({ path: 'otherId' }, { 'test:pred': 'objVal' });
metadata = new RepresentationMetadata(other);
expect(metadata.identifier).toEqualRdfTerm(namedNode('otherId'));
expect(metadata.quads()).toBeRdfIsomorphic([
@ -59,7 +59,7 @@ describe('A RepresentationMetadata', (): void => {
});
it('can combine overrides with other metadata.', async(): Promise<void> => {
const other = new RepresentationMetadata('otherId', { 'test:pred': 'objVal' });
const other = new RepresentationMetadata({ path: 'otherId' }, { 'test:pred': 'objVal' });
metadata = new RepresentationMetadata(other, { 'test:pred': 'objVal2' });
expect(metadata.quads()).toBeRdfIsomorphic([
quad(namedNode('otherId'), namedNode('test:pred'), literal('objVal2')) ]);
@ -101,7 +101,7 @@ describe('A RepresentationMetadata', (): void => {
});
it('updates its identifier when copying metadata.', async(): Promise<void> => {
const other = new RepresentationMetadata('otherId', { 'test:pred': 'objVal' });
const other = new RepresentationMetadata({ path: 'otherId' }, { 'test:pred': 'objVal' });
metadata.setMetadata(other);
// `setMetadata` should have the same result as the following

11
test/unit/storage/accessors/FileDataAccessor.test.ts
View File

@ -119,7 +119,7 @@ describe('A FileDataAccessor', (): void => {
const childQuads = metadata.quads().filter((quad): boolean =>
quad.subject.value === `${base}container/resource`);
const childMetadata = new RepresentationMetadata(`${base}container/resource`).addQuads(childQuads);
const childMetadata = new RepresentationMetadata({ path: `${base}container/resource` }).addQuads(childQuads);
expect(childMetadata.get(RDF.type)?.value).toBe(LDP.Resource);
expect(childMetadata.get(POSIX.size)).toEqualRdfTerm(toTypedLiteral('data'.length, XSD.integer));
expect(childMetadata.get(DCTERMS.modified)).toEqualRdfTerm(toTypedLiteral(now.toISOString(), XSD.dateTime));
@ -160,7 +160,8 @@ describe('A FileDataAccessor', (): void => {
});
it('writes metadata to the corresponding metadata file.', async(): Promise<void> => {
metadata = new RepresentationMetadata(`${base}res.ttl`, { [CONTENT_TYPE]: 'text/turtle', likes: 'apples' });
metadata = new RepresentationMetadata({ path: `${base}res.ttl` },
{ [CONTENT_TYPE]: 'text/turtle', likes: 'apples' });
await expect(accessor.writeDocument({ path: `${base}res.ttl` }, data, metadata)).resolves.toBeUndefined();
expect(cache.data['res.ttl']).toBe('data');
expect(cache.data['res.ttl.meta']).toMatch(`<${base}res.ttl> <likes> "apples".`);
@ -266,21 +267,21 @@ describe('A FileDataAccessor', (): void => {
});
it('writes metadata to the corresponding metadata file.', async(): Promise<void> => {
metadata = new RepresentationMetadata(`${base}container/`, { likes: 'apples' });
metadata = new RepresentationMetadata({ path: `${base}container/` }, { likes: 'apples' });
await expect(accessor.writeContainer({ path: `${base}container/` }, metadata)).resolves.toBeUndefined();
expect(cache.data.container).toEqual({ '.meta': expect.stringMatching(`<${base}container/> <likes> "apples".`) });
});
it('overwrites existing metadata.', async(): Promise<void> => {
cache.data.container = { '.meta': `<${base}container/> <likes> "pears".` };
metadata = new RepresentationMetadata(`${base}container/`, { likes: 'apples' });
metadata = new RepresentationMetadata({ path: `${base}container/` }, { likes: 'apples' });
await expect(accessor.writeContainer({ path: `${base}container/` }, metadata)).resolves.toBeUndefined();
expect(cache.data.container).toEqual({ '.meta': expect.stringMatching(`<${base}container/> <likes> "apples".`) });
});
it('does not write metadata that is stored by the file system.', async(): Promise<void> => {
metadata = new RepresentationMetadata(
`${base}container/`,
{ path: `${base}container/` },
{ [RDF.type]: [ toNamedNode(LDP.BasicContainer), toNamedNode(LDP.Resource) ]},
);
await expect(accessor.writeContainer({ path: `${base}container/` }, metadata)).resolves.toBeUndefined();

23
test/unit/storage/accessors/InMemoryDataAccessor.test.ts
View File

@ -86,9 +86,10 @@ describe('An InMemoryDataAccessor', (): void => {
});
it('adds stored metadata when requesting document metadata.', async(): Promise<void> => {
const inputMetadata = new RepresentationMetadata(`${base}resource`, { [RDF.type]: toNamedNode(LDP.Resource) });
await accessor.writeDocument({ path: `${base}resource` }, data, inputMetadata);
metadata = await accessor.getMetadata({ path: `${base}resource` });
const identifier = { path: `${base}resource` };
const inputMetadata = new RepresentationMetadata(identifier, { [RDF.type]: toNamedNode(LDP.Resource) });
await accessor.writeDocument(identifier, data, inputMetadata);
metadata = await accessor.getMetadata(identifier);
expect(metadata.identifier.value).toBe(`${base}resource`);
const quads = metadata.quads();
expect(quads).toHaveLength(1);
@ -96,10 +97,11 @@ describe('An InMemoryDataAccessor', (): void => {
});
it('adds stored metadata when requesting container metadata.', async(): Promise<void> => {
const inputMetadata = new RepresentationMetadata(`${base}container/`, { [RDF.type]: toNamedNode(LDP.Container) });
await accessor.writeContainer({ path: `${base}container/` }, inputMetadata);
const identifier = { path: `${base}container/` };
const inputMetadata = new RepresentationMetadata(identifier, { [RDF.type]: toNamedNode(LDP.Container) });
await accessor.writeContainer(identifier, inputMetadata);
metadata = await accessor.getMetadata({ path: `${base}container/` });
metadata = await accessor.getMetadata(identifier);
expect(metadata.identifier.value).toBe(`${base}container/`);
const quads = metadata.quads();
expect(quads).toHaveLength(1);
@ -107,8 +109,9 @@ describe('An InMemoryDataAccessor', (): void => {
});
it('can overwrite the metadata of an existing container without overwriting children.', async(): Promise<void> => {
const inputMetadata = new RepresentationMetadata(`${base}container/`, { [RDF.type]: toNamedNode(LDP.Container) });
await accessor.writeContainer({ path: `${base}container/` }, inputMetadata);
const identifier = { path: `${base}container/` };
const inputMetadata = new RepresentationMetadata(identifier, { [RDF.type]: toNamedNode(LDP.Container) });
await accessor.writeContainer(identifier, inputMetadata);
const resourceMetadata = new RepresentationMetadata();
await accessor.writeDocument(
{ path: `${base}container/resource` }, data, resourceMetadata,
@ -116,9 +119,9 @@ describe('An InMemoryDataAccessor', (): void => {
const newMetadata = new RepresentationMetadata(inputMetadata);
newMetadata.add(RDF.type, toNamedNode(LDP.BasicContainer));
await accessor.writeContainer({ path: `${base}container/` }, newMetadata);
await accessor.writeContainer(identifier, newMetadata);
metadata = await accessor.getMetadata({ path: `${base}container/` });
metadata = await accessor.getMetadata(identifier);
expect(metadata.identifier.value).toBe(`${base}container/`);
const quads = metadata.quads();
expect(quads).toHaveLength(3);

16
test/unit/storage/accessors/SparqlDataAccessor.test.ts
View File

@ -152,7 +152,7 @@ describe('A SparqlDataAccessor', (): void => {
});
it('overwrites the metadata when writing a container and updates parent.', async(): Promise<void> => {
metadata = new RepresentationMetadata('http://test.com/container/',
metadata = new RepresentationMetadata({ path: 'http://test.com/container/' },
{ [RDF.type]: [ toNamedNode(LDP.Resource), toNamedNode(LDP.Container) ]});
await expect(accessor.writeContainer({ path: 'http://test.com/container/' }, metadata)).resolves.toBeUndefined();
@ -171,7 +171,7 @@ describe('A SparqlDataAccessor', (): void => {
});
it('overwrites the data and metadata when writing a resource and updates parent.', async(): Promise<void> => {
metadata = new RepresentationMetadata('http://test.com/container/resource',
metadata = new RepresentationMetadata({ path: 'http://test.com/container/resource' },
{ [RDF.type]: [ toNamedNode(LDP.Resource) ]});
await expect(accessor.writeDocument({ path: 'http://test.com/container/resource' }, data, metadata))
.resolves.toBeUndefined();
@ -190,7 +190,7 @@ describe('A SparqlDataAccessor', (): void => {
});
it('overwrites the data and metadata when writing an empty resource.', async(): Promise<void> => {
metadata = new RepresentationMetadata('http://test.com/container/resource',
metadata = new RepresentationMetadata({ path: 'http://test.com/container/resource' },
{ [RDF.type]: [ toNamedNode(LDP.Resource) ]});
const empty = guardedStreamFrom([]);
await expect(accessor.writeDocument({ path: 'http://test.com/container/resource' }, empty, metadata))
@ -209,7 +209,7 @@ describe('A SparqlDataAccessor', (): void => {
});
it('removes all references when deleting a resource.', async(): Promise<void> => {
metadata = new RepresentationMetadata('http://test.com/container/',
metadata = new RepresentationMetadata({ path: 'http://test.com/container/' },
{ [RDF.type]: [ toNamedNode(LDP.Resource), toNamedNode(LDP.Container) ]});
await expect(accessor.deleteResource({ path: 'http://test.com/container/' })).resolves.toBeUndefined();
@ -246,14 +246,14 @@ describe('A SparqlDataAccessor', (): void => {
});
it('errors when the SPARQL endpoint fails during writing.', async(): Promise<void> => {
const path = 'http://test.com/container/';
metadata = new RepresentationMetadata(path);
const identifier = { path: 'http://test.com/container/' };
metadata = new RepresentationMetadata(identifier);
updateError = 'error';
await expect(accessor.writeContainer({ path }, metadata)).rejects.toBe(updateError);
await expect(accessor.writeContainer(identifier, metadata)).rejects.toBe(updateError);
updateError = new Error();
await expect(accessor.writeContainer({ path }, metadata)).rejects.toThrow(updateError);
await expect(accessor.writeContainer(identifier, metadata)).rejects.toThrow(updateError);
updateError = undefined;
});