@noeldemartin/solid-utils 0.2.0 → 0.3.0-next.a444b642b5ee2c1d412a667cb87b853b85115b98

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@noeldemartin/solid-utils",
-  "version": "0.2.0",
+  "version": "0.3.0-next.a444b642b5ee2c1d412a667cb87b853b85115b98",
   "description": "My JavaScript utilities for Solid",
   "main": "dist/noeldemartin-solid-utils.cjs.js",
   "module": "dist/noeldemartin-solid-utils.esm.js",
   "browser": "dist/noeldemartin-solid-utils.umd.js",
   "types": "dist/noeldemartin-solid-utils.d.ts",
+  "sideEffects": false,
   "scripts": {
     "build": "rm dist -rf && npm run build:js && npm run build:types",
     "build:js": "noeldemartin-build-javascript",
@@ -30,8 +31,9 @@
   "homepage": "https://github.com/noeldemartin/solid-utils",
   "dependencies": {
     "@babel/runtime": "^7.14.0",
-    "@noeldemartin/solid-utils-external": "^0.1.0",
-    "@noeldemartin/utils": "^0.3.0",
+    "@noeldemartin/faker": "^7.6.0",
+    "@noeldemartin/solid-utils-external": "^0.1.1",
+    "@noeldemartin/utils": "^0.4.0",
     "@types/rdf-js": "^4.0.1",
     "core-js": "^3.12.1",
     "jest-diff": "^26.6.2",

package/src/helpers/auth.ts

@@ -9,7 +9,7 @@ import type { Fetch } from './io';
 
 export interface SolidUserProfile {
     webId: string;
-    storageUrls: string[];
+    storageUrls: [string, ...string[]];
     cloaked: boolean;
     writableProfileUrl: string | null;
     name?: string;
@@ -106,11 +106,15 @@ async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUser
         parentUrl = urlParentDirectory(parentUrl);
     }
 
+    if (storageUrls.length === 0) {
+        throw new Error(`Could not find any storage for ${webId}.`);
+    }
+
     return {
         webId,
         cloaked,
         writableProfileUrl,
-        storageUrls: arrayUnique(storageUrls),
+        storageUrls: arrayUnique(storageUrls) as [string, ...string[]],
         ...objectWithoutEmpty({
             name:
                 store.statement(webId, 'vcard:fn')?.object.value ??
@@ -125,8 +129,20 @@ async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUser
     };
 }
 
-export async function fetchLoginUserProfile(loginUrl: string, fetch?: Fetch): Promise<SolidUserProfile | null> {
-    const fetchProfile = silenced(url => fetchUserProfile(url, fetch));
+export interface FetchLoginUserProfileOptions {
+    required?: boolean;
+    fetch?: Fetch;
+}
+
+export async function fetchLoginUserProfile(
+    loginUrl: string,
+    options: FetchLoginUserProfileOptions = {},
+): Promise<SolidUserProfile | null> {
+    if (options.required) {
+        return fetchUserProfile(loginUrl, options.fetch);
+    }
+
+    const fetchProfile = silenced(url => fetchUserProfile(url, options.fetch));
 
     return await fetchProfile(loginUrl)
         ?? await fetchProfile(loginUrl.replace(/\/$/, '').concat('/profile/card#me'))

package/src/main.ts

@@ -2,3 +2,4 @@ export * from './errors/index';
 export * from './helpers/index';
 export * from './models/index';
 export * from './plugins/index';
+export * from './testing/index';

package/src/testing/ResponseStub.ts

@@ -0,0 +1,46 @@
+export default class ResponseStub implements Response {
+
+    private rawBody: string;
+
+    public readonly body!: ReadableStream<Uint8Array> | null;
+    public readonly bodyUsed!: boolean;
+    public readonly headers: Headers;
+    public readonly ok!: boolean;
+    public readonly redirected!: boolean;
+    public readonly status: number;
+    public readonly statusText!: string;
+    public readonly trailer!: Promise<Headers>;
+    public readonly type!: ResponseType;
+    public readonly url!: string;
+
+    public constructor(rawBody: string = '', headers: Record<string, string> = {}, status: number = 200) {
+        this.rawBody = rawBody;
+        this.headers = new Headers(headers);
+        this.status = status;
+    }
+
+    public async arrayBuffer(): Promise<ArrayBuffer> {
+        throw new Error('ResponseStub.arrayBuffer is not implemented');
+    }
+
+    public async blob(): Promise<Blob> {
+        throw new Error('ResponseStub.blob is not implemented');
+    }
+
+    public async formData(): Promise<FormData> {
+        throw new Error('ResponseStub.formData is not implemented');
+    }
+
+    public async json(): Promise<unknown> {
+        return JSON.parse(this.rawBody);
+    }
+
+    public async text(): Promise<string> {
+        return this.rawBody;
+    }
+
+    public clone(): Response {
+        return { ...this };
+    }
+
+}

package/src/testing/faking.ts

@@ -0,0 +1,36 @@
+import { faker } from '@noeldemartin/faker';
+import { stringToSlug } from '@noeldemartin/utils';
+
+export interface ContainerOptions {
+    baseUrl: string;
+}
+
+export interface DocumentOptions extends ContainerOptions {
+    containerUrl: string;
+    name: string;
+}
+
+export interface ResourceOptions extends DocumentOptions {
+    documentUrl: string;
+    hash: string;
+}
+
+export function fakeContainerUrl(options: Partial<ContainerOptions> = {}): string {
+    const baseUrl = options.baseUrl ?? faker.internet.url();
+
+    return baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
+}
+
+export function fakeDocumentUrl(options: Partial<DocumentOptions> = {}): string {
+    const containerUrl = options.containerUrl ?? fakeContainerUrl(options);
+    const name = options.name ?? faker.random.word();
+
+    return containerUrl + stringToSlug(name);
+}
+
+export function fakeResourceUrl(options: Partial<ResourceOptions> = {}): string {
+    const documentUrl = options.documentUrl ?? fakeDocumentUrl(options);
+    const hash = options.hash ?? 'it';
+
+    return documentUrl + '#' + hash;
+}

package/src/testing/index.ts

@@ -0,0 +1,3 @@
+export * from './faking';
+export * from './mocking';
+export { default as ResponseStub } from './ResponseStub';

package/src/testing/mocking.ts

@@ -0,0 +1,34 @@
+import { fail } from '@noeldemartin/utils';
+import type { GetClosureArgs, GetClosureResult } from '@noeldemartin/utils';
+
+import type { Fetch } from '@/helpers/io';
+
+import ResponseStub from './ResponseStub';
+
+export interface FetchMockMethods {
+    mockResponse(body?: string, headers?: Record<string, string>, status?: number): void;
+    mockNotFoundResponse(): void;
+}
+
+export type FetchMock = jest.Mock<GetClosureResult<Fetch>, GetClosureArgs<Fetch>> & Fetch & FetchMockMethods;
+
+export function mockFetch(): FetchMock {
+    const responses: ResponseStub[] = [];
+    const methods: FetchMockMethods = {
+        mockResponse(body, headers, status) {
+            responses.push(new ResponseStub(body, headers, status));
+        },
+        mockNotFoundResponse() {
+            responses.push(new ResponseStub('', {}, 404));
+        },
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const fetchMock = jest.fn(async (...args: GetClosureArgs<Fetch>) => {
+        return responses.shift() ?? fail<Response>('fetch mock called without response');
+    });
+
+    Object.assign(fetchMock, methods);
+
+    return fetchMock as FetchMock;
+}