@fabriktor/client 0.0.13 → 0.0.15

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

@@ -0,0 +1,2 @@
+export type TokenProvider = () => Promise<string>;
+export declare function requiredToken(getToken?: TokenProvider): Promise<string>;

package/dist/src/core/auth.js

@@ -0,0 +1,16 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// 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 errAuthTokenProviderMissing();
+    }
+    const out = await getToken();
+    if (!out) {
+        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/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./core/auth.js";
 export * from "./core/err.js";
 export * from "./core/http.js";
 export * from "./core/path.js";

package/dist/src/index.js

@@ -1,3 +1,4 @@
+export * from "./core/auth.js";
 export * from "./core/err.js";
 export * from "./core/http.js";
 export * from "./core/path.js";

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

@@ -1,20 +1,21 @@
 import type { PLUsersSendCode, PLUsersVerifyCode } from "@fabriktor/schema";
+import type { TokenProvider } from "../core/auth.js";
 import type { HTTPDoer } from "../core/http.js";
-export type SendPhoneVerificationOptions = {
-    base_url: string;
-} & PLUsersSendCode;
-export type VerifyPhoneOptions = {
-    base_url: string;
-} & PLUsersVerifyCode;
+export type SendPhoneVerificationOptions = PLUsersSendCode;
+export type VerifyPhoneOptions = PLUsersVerifyCode;
 export interface TmpPhonesOperator {
     send(opts: SendPhoneVerificationOptions): Promise<void>;
     verify(opts: VerifyPhoneOptions): Promise<void>;
 }
 export type TmpPhonesClientOptions = {
     http: HTTPDoer;
+    base_url: string;
+    get_token?: TokenProvider;
 };
 export declare class TmpPhonesClient implements TmpPhonesOperator {
     private http;
+    private base_url;
+    private get_token?;
     constructor(opts: TmpPhonesClientOptions);
     send(opts: SendPhoneVerificationOptions): Promise<void>;
     verify(opts: VerifyPhoneOptions): Promise<void>;

package/dist/src/users/tmp_phones.js

@@ -4,27 +4,36 @@
 // 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 { ColUsersTmpPhones, HTTPMethodPost, PathUsersSend, PathUsersVerify, SvcUsers, } from "@fabriktor/schema";
+import { requiredToken } from "../core/auth.js";
 import { buildPath } from "../core/path.js";
 export class TmpPhonesClient {
     http;
+    base_url;
+    get_token;
     constructor(opts) {
         this.http = opts.http;
+        this.base_url = opts.base_url;
+        this.get_token = opts.get_token;
     }
     async send(opts) {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: tmpPhonePath(PathUsersSend),
             method: HTTPMethodPost,
+            token,
             body: {
                 phone: opts.phone,
             },
         });
     }
     async verify(opts) {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: tmpPhonePath(PathUsersVerify),
             method: HTTPMethodPost,
+            token,
             body: {
                 phone: opts.phone,
                 code: opts.code,

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

@@ -1,8 +1,7 @@
 import type { PLUsersUsername } from "@fabriktor/schema";
+import type { TokenProvider } from "../core/auth.js";
 import type { HTTPDoer, Op } from "../core/http.js";
-export type VerifyUsernameOptions = {
-    base_url: string;
-} & PLUsersUsername;
+export type VerifyUsernameOptions = PLUsersUsername;
 export type UsernameVerification = {
     username: string;
     suggestions: string[];
@@ -12,9 +11,13 @@ export interface TmpUsernamesOperator {
 }
 export type TmpUsernamesClientOptions = {
     http: HTTPDoer;
+    base_url: string;
+    get_token?: TokenProvider;
 };
 export declare class TmpUsernamesClient implements TmpUsernamesOperator {
     private http;
+    private base_url;
+    private get_token?;
     constructor(opts: TmpUsernamesClientOptions);
     verify(opts: VerifyUsernameOptions): Promise<Op<UsernameVerification>>;
 }

package/dist/src/users/tmp_usernames.js

@@ -4,17 +4,24 @@
 // 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 { ColUsersTmpUsernames, HTTPMethodPost, PathUsersVerify, SvcUsers, } from "@fabriktor/schema";
+import { requiredToken } from "../core/auth.js";
 import { buildPath } from "../core/path.js";
 export class TmpUsernamesClient {
     http;
+    base_url;
+    get_token;
     constructor(opts) {
         this.http = opts.http;
+        this.base_url = opts.base_url;
+        this.get_token = opts.get_token;
     }
     async verify(opts) {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: tmpUsernamePath(PathUsersVerify),
             method: HTTPMethodPost,
+            token,
             body: {
                 words: opts.words,
                 to_validate: opts.to_validate,

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

@@ -1,56 +1,48 @@
 import type { InUser, OperationResult, PLUsersContactList, PLUsersForgotPassword, PLUsersResolveUsername, PLUsersSignInLink, UpsertResult, User } from "@fabriktor/schema";
+import type { TokenProvider } from "../core/auth.js";
 import type { HTTPDoer, Op } from "../core/http.js";
-export type AuthOptions = {
-    base_url: string;
-    token: string;
-};
-export type BootstrapOptions = AuthOptions & {
+export type BootstrapOptions = {
     in: InUser;
 };
-export type ResolveUsernameOptions = {
-    base_url: string;
-} & PLUsersResolveUsername;
-export type ForgotPasswordOptions = {
-    base_url: string;
-} & PLUsersForgotPassword;
-export type SendSignInLinkOptions = {
-    base_url: string;
-} & PLUsersSignInLink;
-export type MatchOptions = AuthOptions & PLUsersContactList;
-export type MatchResult = {
-    users: User[];
-};
-export type SearchOptions = AuthOptions & {
+export type ResolveUsernameOptions = PLUsersResolveUsername;
+export type ForgotPasswordOptions = PLUsersForgotPassword;
+export type SendSignInLinkOptions = PLUsersSignInLink;
+export type MatchOptions = PLUsersContactList;
+export type SearchOptions = {
     q: string;
     limit?: number;
 };
-export type GetByUIDOptions = AuthOptions & {
+export type GetByUIDOptions = {
     uid: string;
 };
 export interface UsersOperator {
     bootstrap(opts: BootstrapOptions): Promise<Op<UpsertResult>>;
-    sync(opts: AuthOptions): Promise<OperationResult>;
-    sendEmailVerification(opts: AuthOptions): Promise<void>;
+    sync(): Promise<OperationResult>;
+    sendEmailVerification(): Promise<void>;
     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>>;
 }
 export type UsersClientOptions = {
     http: HTTPDoer;
+    base_url: string;
+    get_token?: TokenProvider;
 };
 export declare class UsersClient implements UsersOperator {
     private http;
+    private base_url;
+    private get_token?;
     constructor(opts: UsersClientOptions);
     bootstrap(opts: BootstrapOptions): Promise<Op<UpsertResult>>;
-    sync(opts: AuthOptions): Promise<OperationResult>;
-    sendEmailVerification(opts: AuthOptions): Promise<void>;
+    sync(): Promise<OperationResult>;
+    sendEmailVerification(): Promise<void>;
     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/dist/src/users/users.js

@@ -4,40 +4,48 @@
 // 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 { ColUsersUsers, HTTPMethodGet, HTTPMethodPost, PathSearch, PathUsersBootstrap, PathUsersForgotPassword, PathUsersMatch, PathUsersResolveUsername, PathUsersSendEmailVerification, PathUsersSendSignInLink, PathUsersSync, SvcUsers, } from "@fabriktor/schema";
+import { requiredToken } from "../core/auth.js";
 import { buildPath } from "../core/path.js";
 export class UsersClient {
     http;
+    base_url;
+    get_token;
     constructor(opts) {
         this.http = opts.http;
+        this.base_url = opts.base_url;
+        this.get_token = opts.get_token;
     }
     async bootstrap(opts) {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathUsersBootstrap),
             method: HTTPMethodPost,
-            token: opts.token,
+            token,
             body: opts.in,
         });
     }
-    async sync(opts) {
+    async sync() {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathUsersSync),
             method: HTTPMethodPost,
-            token: opts.token,
+            token,
         });
     }
-    async sendEmailVerification(opts) {
+    async sendEmailVerification() {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathUsersSendEmailVerification),
             method: HTTPMethodPost,
-            token: opts.token,
+            token,
         });
     }
     async forgotPassword(opts) {
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathUsersForgotPassword),
             method: HTTPMethodPost,
             body: {
@@ -47,7 +55,7 @@ export class UsersClient {
     }
     async sendSignInLink(opts) {
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathUsersSendSignInLink),
             method: HTTPMethodPost,
             body: {
@@ -57,7 +65,7 @@ export class UsersClient {
     }
     async resolveUsername(opts) {
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathUsersResolveUsername),
             method: HTTPMethodPost,
             body: {
@@ -66,31 +74,37 @@ export class UsersClient {
         });
     }
     async match(opts) {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathUsersMatch),
             method: HTTPMethodPost,
-            token: opts.token,
+            token,
             body: {
                 contacts: opts.contacts,
             },
         });
     }
     async search(opts) {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: userPath(PathSearch),
             method: HTTPMethodPost,
-            token: opts.token,
-            body: opts,
+            token,
+            body: {
+                q: opts.q,
+                limit: opts.limit,
+            },
         });
     }
     async getByUID(opts) {
+        const token = await requiredToken(this.get_token);
         return await this.http.do({
-            base_url: opts.base_url,
+            base_url: this.base_url,
             path: `${collectionPath()}?uid=${encodeURIComponent(opts.uid)}`,
             method: HTTPMethodGet,
-            token: opts.token,
+            token,
         });
     }
 }

package/package.json

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