typedrest 0.5.0 → 0.6.0

package/endpoints/generic/CollectionEndpoint.test.ts

@@ -1,215 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { CollectionEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpHeader, HttpStatusCode, HttpMethod } from '../../http';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: CollectionEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new CollectionEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('getById', () => {
-    expect(endpoint.get('x/y').uri).toEqual(new URL('http://localhost/endpoint/x%2Fy'));
-});
-
-test('getByIdWithLinkHeaderRelative', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<children{?id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children?id=1'));
-});
-
-test('getByIdWithLinkHeaderAbsolute', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<http://localhost/children{?id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children?id=1'));
-});
-
-test('getByEntity', () => {
-    expect(endpoint.get(new MockEntity(1, 'test')).uri).toEqual(new URL('http://localhost/endpoint/1'));
-});
-
-test('getByEntityWithLinkHeaderRelative', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<children/{id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children/1'));
-});
-
-test('getByEntityWithLinkHeaderAbsolute', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<http://localhost/children/{id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children/1'));
-});
-
-test('readAll', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[{"id":5,"name":"test1"}, {"id":6,"name":"test2"}]'
-    );
-
-    const result = await endpoint.readAll();
-    expect(result).toEqual([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-});
-
-test('readAllCache', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[{"id":5,"name":"test1"}, {"id":6,"name":"test2"}]',
-        {
-            headers: {
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    const result1 = await endpoint.readAll();
-    expect(result1).toEqual([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfNoneMatch)).toBe('"123abc"');
-            return { status: HttpStatusCode.NotModified };
-        }
-    );
-    const result2 = await endpoint.readAll();
-    expect(result2).toEqual([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-
-    expect(result2).not.toBe(result1); // Should cache response, not deserialized object
-});
-
-test('create', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":0,"name":"test"}');
-            return { body: '{"id":5,"name":"test"}' };
-        }
-    );
-
-    const element = (await endpoint.create(new MockEntity(0, 'test')))!;
-    expect(element!.response).toEqual(new MockEntity(5, 'test'));
-    expect(element.uri).toEqual(new URL('http://localhost/endpoint/5'));
-});
-
-test('createLocation', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":0,"name":"test"}');
-            return {
-                body: '{"id":5,"name":"test"}',
-                headers: {
-                    [HttpHeader.Location]: '/endpoint/new'
-                }
-            };
-        }
-    );
-
-    const element = (await endpoint.create(new MockEntity(0, 'test')))!;
-    expect(element.response).toEqual(new MockEntity(5, 'test'));
-    expect(element.uri).toEqual(new URL('http://localhost/endpoint/new'));
-});
-
-test('createUndefined', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":0,"name":"test"}');
-            return { status: HttpStatusCode.Accepted };
-        }
-    );
-
-    const element = (await endpoint.create(new MockEntity(0, 'test')));
-    expect(element).toBeUndefined();
-});
-
-test('createAll', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Patch && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('[{"id":5,"name":"test1"},{"id":6,"name":"test2"}]');
-            return {};
-        }
-    );
-
-    await endpoint.createAll([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-});
-
-test('setAll', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('[{"id":5,"name":"test1"},{"id":6,"name":"test2"}]');
-            return {};
-        }
-    );
-
-    await endpoint.setAll([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-});
-
-test('setAllETag', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[{"id":5,"name":"test1"}, {"id":6,"name":"test2"}]',
-        {
-            headers: { [HttpHeader.ETag]: '"123abc"' }
-        });
-    const result = await endpoint.readAll();
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"123abc"');
-            expect(await req.text()).toBe('[{"id":5,"name":"test1"},{"id":6,"name":"test2"}]');
-            return {};
-        }
-    );
-    await endpoint.setAll(result);
-});

package/endpoints/generic/ElementEndpoint.test.ts

@@ -1,262 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { ElementEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpStatusCode, HttpMethod, HttpHeader } from '../../http';
-import { ConcurrencyError } from '../../errors';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: ElementEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new ElementEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('read', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: { [HttpHeader.ContentType]: 'application/json' }
-        });
-
-    const result = await endpoint.read();
-    expect(result).toEqual(new MockEntity(5, 'test'));
-});
-
-test('readCache', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    const result1 = await endpoint.read();
-    expect(result1).toEqual(new MockEntity(5, 'test'));
-
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get('If-None-Match')).toBe('"123abc"');
-            return { status: HttpStatusCode.NotModified };
-        }
-    );
-    const result2 = await endpoint.read();
-    expect(result2).toEqual(new MockEntity(5, 'test'));
-
-    expect(result2).not.toBe(result1); // Should cache response, not deserialized object
-});
-
-test('existsTrue', async () => {
-    fetchMock.mockOnceIf(req => req.method === HttpMethod.Head && req.url === 'http://localhost/endpoint');
-
-    const result = await endpoint.exists();
-    expect(result).toBe(true);
-});
-
-test('existsFalse', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Head && req.url === 'http://localhost/endpoint',
-        async () => {
-            return { status: HttpStatusCode.NotFound };
-        }
-    );
-
-    const result = await endpoint.exists();
-    expect(result).toBe(false);
-});
-
-test('setResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {
-                headers: { [HttpHeader.ContentType]: 'application/json' },
-                body: '{"id":5,"name":"testXXX"}'
-            };
-        }
-    );
-
-    const result = await endpoint.set(new MockEntity(5, 'test'));
-    expect(result).toEqual(new MockEntity(5, 'testXXX'));
-});
-
-test('setNoResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {};
-        }
-    );
-
-    const result = await endpoint.set(new MockEntity(5, 'test'));
-    expect(result).toBeUndefined();
-});
-
-test('setETag', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    const result = await endpoint.read();
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"123abc"');
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {};
-
-        }
-    );
-    await endpoint.set(result);
-});
-
-test('updateRetry', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        async req => {
-            return {
-                headers: {
-                    [HttpHeader.ContentType]: 'application/json',
-                    [HttpHeader.ETag]: '"1"'
-                },
-                body: '{"id":5,"name":"test1"}'
-            };
-        }
-    ).mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"1"');
-            expect(await req.text()).toBe('{"id":5,"name":"testX"}');
-            return { status: HttpStatusCode.PreconditionFailed };
-        }
-    ).mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        async req => {
-            return {
-                headers: {
-                    [HttpHeader.ContentType]: 'application/json',
-                    [HttpHeader.ETag]: '"2"'
-                },
-                body: '{"id":5,"name":"test2"}'
-            };
-        }
-    ).mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"2"');
-            expect(await req.text()).toBe('{"id":5,"name":"testX"}');
-            return {
-                headers: { [HttpHeader.ContentType]: 'application/json' },
-                body: '{"id":5,"name":"testX"}'
-            };
-        }
-    );
-
-    await endpoint.update(x => x.name = 'testX');
-});
-
-test('updateFail', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        '{"id":5,"name":"test1"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"1"'
-            }
-        }
-    );
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"1"');
-            expect(await req.text()).toBe('{"id":5,"name":"testX"}');
-            return { status: HttpStatusCode.PreconditionFailed };
-        }
-    );
-
-    let errorThrown = false;
-    try {
-        await endpoint.update(x => x.name = 'testX', 0);
-    } catch (err) {
-        errorThrown = err instanceof ConcurrencyError;
-    }
-    expect(errorThrown).toBe(true);
-});
-
-test('mergeResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Patch && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {
-                headers: { [HttpHeader.ContentType]: 'application/json' },
-                body: '{"id":5,"name":"testXXX"}'
-            };
-        }
-    );
-
-    const result = await endpoint.merge(new MockEntity(5, 'test'));
-    expect(result).toEqual(new MockEntity(5, 'testXXX'));
-});
-
-test('mergeNoResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Patch && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {};
-        }
-    );
-
-    const result = await endpoint.merge(new MockEntity(5, 'test'));
-    expect(result).toBeUndefined();
-});
-
-test('delete', async () => {
-    fetchMock.mockOnceIf(req => req.method === HttpMethod.Delete && req.url === 'http://localhost/endpoint');
-    await endpoint.delete();
-});
-
-test('deleteETag', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    await endpoint.read();
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Delete && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"123abc"');
-            return {};
-        }
-    );
-    await endpoint.delete();
-});

package/endpoints/generic/GenericCollectionEndpoint.test.ts

@@ -1,123 +0,0 @@
-/**
- * NOTE: The jsdom environment strips the "Range" request header, so these tests need the node environment.
- * @jest-environment node
- */
-
-import fetchMock from 'jest-fetch-mock';
-import { CollectionEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpHeader, HttpStatusCode, HttpContentRange } from '../../http';
-import { RangeNotSatisfiableError } from '../../errors';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: CollectionEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new CollectionEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('readRange', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.Range)).toBe('elements=1-2');
-            return {
-                body: '[{"id":6,"name":"test2"}, {"id":7,"name":"test3"}]',
-                status: HttpStatusCode.PartialContent,
-                headers: {
-                    [HttpHeader.ContentRange]: 'elements 1-2/3'
-                }
-            };
-        }
-    );
-
-    const result = await endpoint.readRange(1, 2);
-    expect(result.elements).toEqual([new MockEntity(6, 'test2'), new MockEntity(7, 'test3')]);
-    expect(result.range).toEqual(new HttpContentRange('elements', 1, 2, 3));
-    expect(result.endReached).toBe(true);
-});
-
-test('readRangeOffset', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.Range)).toBe('elements=1-');
-            return {
-                body: '[{"id":6,"name":"test2"}]',
-                status: HttpStatusCode.PartialContent,
-                headers: {
-                    [HttpHeader.ContentRange]: 'elements 1-1/*'
-                }
-            };
-        }
-    );
-
-    const result = await endpoint.readRange(1);
-    expect(result.elements).toEqual([new MockEntity(6, 'test2')]);
-    expect(result.range).toEqual(new HttpContentRange('elements', 1, 1, undefined));
-    expect(result.endReached).toBe(false);
-});
-
-test('readRangeTail', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.Range)).toBe('elements=-1');
-            return {
-                body: '[{"id":6,"name":"test2"}]',
-                status: HttpStatusCode.PartialContent
-            };
-        }
-    );
-
-    const result = await endpoint.readRange(undefined, 1);
-    expect(result.elements).toEqual([new MockEntity(6, 'test2')]);
-    expect(result.range).toBeUndefined();
-    expect(result.endReached).toBe(true);
-});
-
-test('readRangeNotSatisfiable', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async () => ({ status: HttpStatusCode.RangeNotSatisfiable })
-    );
-
-    await expect(endpoint.readRange(1)).rejects.toThrow(RangeNotSatisfiableError);
-});
-
-test('readRangeAllowed', async () => {
-    expect(endpoint.readRangeAllowed).toBeUndefined();
-
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.AcceptRanges]: 'elements'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.readRangeAllowed).toBe(true);
-});
-
-test('readRangeNotAllowed', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.AcceptRanges]: 'none'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.readRangeAllowed).toBe(false);
-});

package/endpoints/generic/IndexerEndpoint.test.ts

@@ -1,12 +0,0 @@
-import { IndexerEndpoint, ElementEndpoint } from '.';
-import { EntryEndpoint } from '..';
-
-let endpoint: IndexerEndpoint<ElementEndpoint<{}>>;
-
-beforeEach(() => {
-    endpoint = new IndexerEndpoint<ElementEndpoint<{}>>(new EntryEndpoint('http://localhost/'), 'endpoint', ElementEndpoint);
-});
-
-test('getById', () => {
-    expect(endpoint.get('x/y').uri).toEqual(new URL('http://localhost/endpoint/x%2Fy'));
-});

package/endpoints/generic/PartialResponse.ts

@@ -1,28 +0,0 @@
-import { HttpContentRange } from "../../http";
-
-/**
- * Represents a subset of a set of elements.
- * @typeParam TEntity The type of element the response contains.
- */
-export class PartialResponse<TEntity> {
-    /**
-     * Creates a new partial response.
-     * @param elements The returned elements.
-     * @param range The range the `elements` come from.
-     */
-    constructor(public readonly elements: TEntity[], public readonly range?: HttpContentRange) {
-    }
-
-    /**
-     * Indicates whether the response reaches the end of the elements available on the server.
-     */
-    get endReached(): boolean {
-        // No range specified, must be complete response
-        if (this.range?.to === undefined) return true;
-
-        // No length specified, can't be the end
-        if (this.range.length === undefined) return false;
-
-        return this.range.to === this.range.length - 1;
-    }
-}

package/endpoints/raw/BlobEndpoint.test.ts

@@ -1,52 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { BlobEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpMethod, HttpHeader } from '../../http';
-
-fetchMock.enableMocks();
-let endpoint: BlobEndpoint;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new BlobEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('probe', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Options && req.url === 'http://localhost/endpoint',
-        async () => {
-            return {
-                headers: {
-                    [HttpHeader.Allow]: HttpMethod.Put
-                }
-            };
-        }
-    );
-    await endpoint.probe();
-
-    expect(endpoint.downloadAllowed).toBe(false);
-    expect(endpoint.uploadAllowed).toBe(true);
-});
-
-test('download', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        'data'
-    );
-
-    await endpoint.download();
-});
-
-test('uploadFrom', async () => {
-    const data = new Blob([new Uint8Array([1, 2, 3])], { type: 'mock/type' });
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('mock/type');
-            return {};
-        }
-    );
-
-    await endpoint.uploadFrom(data);
-});