@fabriktor/client 0.0.14 → 0.0.15

package/dist/src/core/auth.js

@@ -3,13 +3,14 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { errAuthTokenEmpty, errAuthTokenProviderMissing } from "./err.js";
 export async function requiredToken(getToken) {
     if (!getToken) {
-        throw new Error("Authenticated client method requires a token provider.");
+        throw errAuthTokenProviderMissing();
     }
     const out = await getToken();
     if (!out) {
-        throw new Error("Authenticated client method received an empty token.");
+        throw errAuthTokenEmpty();
     }
     return out;
 }

package/dist/src/core/err.d.ts

@@ -1,13 +1,36 @@
 import type { HTTPErr, WrenchErr } from "@fabriktor/schema";
+export declare const ClientErrKind: {
+    readonly AuthTokenProviderMissing: "auth_token_provider_missing";
+    readonly AuthTokenEmpty: "auth_token_empty";
+    readonly HTTPError: "http_error";
+    readonly HTTPRequestFailed: "http_request_failed";
+    readonly HTTPResponseInvalid: "http_response_invalid";
+    readonly Unknown: "unknown";
+};
+export type ClientErrKind = (typeof ClientErrKind)[keyof typeof ClientErrKind];
 export type ClientErrOptions = {
-    code: number;
+    kind: ClientErrKind;
     msg: string;
+    status?: number;
     app_err?: WrenchErr;
+    cause?: unknown;
 };
 export declare class ClientErr extends Error {
-    code: number;
-    app_err?: WrenchErr;
+    readonly kind: ClientErrKind;
+    readonly status?: number;
+    readonly app_err?: WrenchErr;
+    readonly cause?: unknown;
     constructor(opts: ClientErrOptions);
 }
-export declare function newClientErr(opts: ClientErrOptions): ClientErr;
-export declare function newClientErrFromHTTP(err: HTTPErr): ClientErr;
+export declare function errClient(opts: ClientErrOptions): ClientErr;
+export declare function errFromHTTP(err: HTTPErr): ClientErr;
+export declare function errAuthTokenProviderMissing(): ClientErr;
+export declare function errAuthTokenEmpty(): ClientErr;
+export declare function errHTTPRequestFailed(cause: unknown): ClientErr;
+export declare function errHTTPResponseInvalid(cause?: unknown): ClientErr;
+export declare function errUnknown(cause: unknown): ClientErr;
+export declare function isClientErr(err: unknown): err is ClientErr;
+export declare function isHTTPClientErr(err: unknown): err is ClientErr;
+export declare function isUnauthorizedClientErr(err: unknown): boolean;
+export declare function isNotFoundClientErr(err: unknown): boolean;
+export declare function clientErrMessage(err: unknown): string;

package/dist/src/core/err.js

@@ -3,23 +3,101 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+const msgUnknownClientErr = "Unknown client error.";
+export const ClientErrKind = {
+    AuthTokenProviderMissing: "auth_token_provider_missing",
+    AuthTokenEmpty: "auth_token_empty",
+    HTTPError: "http_error",
+    HTTPRequestFailed: "http_request_failed",
+    HTTPResponseInvalid: "http_response_invalid",
+    Unknown: "unknown",
+};
 export class ClientErr extends Error {
-    code;
+    kind;
+    status;
     app_err;
+    cause;
     constructor(opts) {
         super(opts.msg);
         this.name = new.target.name;
-        this.code = opts.code;
+        this.kind = opts.kind;
+        this.status = opts.status;
         this.app_err = opts.app_err;
+        this.cause = opts.cause;
     }
 }
-export function newClientErr(opts) {
+export function errClient(opts) {
     return new ClientErr(opts);
 }
-export function newClientErrFromHTTP(err) {
-    return newClientErr({
-        code: err.code,
+export function errFromHTTP(err) {
+    return errClient({
+        kind: ClientErrKind.HTTPError,
+        status: err.code,
         msg: err.msg,
         app_err: err.app_err,
     });
 }
+export function errAuthTokenProviderMissing() {
+    return errClient({
+        kind: ClientErrKind.AuthTokenProviderMissing,
+        msg: "Authenticated client method requires a token provider.",
+    });
+}
+export function errAuthTokenEmpty() {
+    return errClient({
+        kind: ClientErrKind.AuthTokenEmpty,
+        msg: "Authenticated client method received an empty token.",
+    });
+}
+export function errHTTPRequestFailed(cause) {
+    return errClient({
+        kind: ClientErrKind.HTTPRequestFailed,
+        msg: "HTTP request failed.",
+        cause,
+    });
+}
+export function errHTTPResponseInvalid(cause) {
+    return errClient({
+        kind: ClientErrKind.HTTPResponseInvalid,
+        msg: "HTTP response is invalid.",
+        cause,
+    });
+}
+export function errUnknown(cause) {
+    if (isClientErr(cause)) {
+        return cause;
+    }
+    if (cause instanceof Error) {
+        return errClient({
+            kind: ClientErrKind.Unknown,
+            msg: cause.message,
+            cause,
+        });
+    }
+    return errClient({
+        kind: ClientErrKind.Unknown,
+        msg: msgUnknownClientErr,
+        cause,
+    });
+}
+export function isClientErr(err) {
+    return err instanceof ClientErr;
+}
+export function isHTTPClientErr(err) {
+    return isClientErr(err) && err.kind === ClientErrKind.HTTPError;
+}
+export function isUnauthorizedClientErr(err) {
+    return isClientErr(err) && err.status === 401;
+}
+export function isNotFoundClientErr(err) {
+    return isClientErr(err) && err.status === 404;
+}
+export function clientErrMessage(err) {
+    if (isClientErr(err)) {
+        return err.message;
+    }
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return msgUnknownClientErr;
+}

package/dist/src/core/http.js

@@ -4,7 +4,7 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 import { MimeJSON, } from "@fabriktor/schema";
-import { newClientErrFromHTTP } from "./err.js";
+import { errFromHTTP, errHTTPRequestFailed, errHTTPResponseInvalid, } from "./err.js";
 const headerAuthorization = "authorization";
 const headerContentType = "content-type";
 const prefixBearer = "Bearer";
@@ -19,18 +19,29 @@ export class HTTPClient {
         this.fetcher = opts.fetcher;
     }
     async do(opts) {
-        const res = await this.fetcher.fetch(url(opts.base_url, opts.path), {
-            method: opts.method,
-            headers: headers(opts),
-            body: body(opts.body),
-        });
+        let res;
+        try {
+            res = await this.fetcher.fetch(url(opts.base_url, opts.path), {
+                method: opts.method,
+                headers: headers(opts),
+                body: body(opts.body),
+            });
+        }
+        catch (err) {
+            throw errHTTPRequestFailed(err);
+        }
         if (!res.ok) {
             return await fail(res);
         }
         if (res.body === null) {
             return undefined;
         }
-        return (await res.json());
+        try {
+            return (await res.json());
+        }
+        catch (err) {
+            throw errHTTPResponseInvalid(err);
+        }
     }
 }
 export function newHTTPClient(opts) {
@@ -55,16 +66,25 @@ function body(v) {
     return v === undefined ? undefined : JSON.stringify(v);
 }
 async function fail(res) {
-    const txt = await res.text();
-    let out;
+    const txt = await text(res);
+    throw errFromHTTP(httpErr(res, txt));
+}
+async function text(res) {
+    try {
+        return await res.text();
+    }
+    catch (err) {
+        throw errHTTPResponseInvalid(err);
+    }
+}
+function httpErr(res, txt) {
     try {
-        out = JSON.parse(txt);
+        return JSON.parse(txt);
     }
     catch {
-        out = {
+        return {
             code: res.status,
             msg: txt || res.statusText || res.status.toString(),
         };
     }
-    throw newClientErrFromHTTP(out);
 }

package/dist/src/users/users.d.ts

@@ -8,9 +8,6 @@ export type ResolveUsernameOptions = PLUsersResolveUsername;
 export type ForgotPasswordOptions = PLUsersForgotPassword;
 export type SendSignInLinkOptions = PLUsersSignInLink;
 export type MatchOptions = PLUsersContactList;
-export type MatchResult = {
-    users: User[];
-};
 export type SearchOptions = {
     q: string;
     limit?: number;
@@ -25,7 +22,7 @@ export interface UsersOperator {
     forgotPassword(opts: ForgotPasswordOptions): Promise<void>;
     sendSignInLink(opts: SendSignInLinkOptions): Promise<void>;
     resolveUsername(opts: ResolveUsernameOptions): Promise<Op<string>>;
-    match(opts: MatchOptions): Promise<Op<MatchResult>>;
+    match(opts: MatchOptions): Promise<Op<User[]>>;
     search(opts: SearchOptions): Promise<Op<User[]>>;
     getByUID(opts: GetByUIDOptions): Promise<Op<User>>;
 }
@@ -45,7 +42,7 @@ export declare class UsersClient implements UsersOperator {
     forgotPassword(opts: ForgotPasswordOptions): Promise<void>;
     sendSignInLink(opts: SendSignInLinkOptions): Promise<void>;
     resolveUsername(opts: ResolveUsernameOptions): Promise<Op<string>>;
-    match(opts: MatchOptions): Promise<Op<MatchResult>>;
+    match(opts: MatchOptions): Promise<Op<User[]>>;
     search(opts: SearchOptions): Promise<Op<User[]>>;
     getByUID(opts: GetByUIDOptions): Promise<Op<User>>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/client",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {