@nauticana/sail 1.1.9 → 1.1.10

package/src/service/rest_service.ts

@@ -6,18 +6,56 @@ import { RestURL } from "./rest_url";
 import { BaseAuthService } from "./auth.service";
 import { BaseRestService } from "./base_rest.service";
 
+/** keel's RFC 7807 error body (WriteError) — surfaced verbatim on SailApiError. */
+export interface ProblemDetail {
+    title?: string;
+    detail?: string;
+    status?: number;
+    [key: string]: unknown;
+}
+
+/**
+ * Typed error thrown by BackendService CRUD calls. Preserves the HTTP status
+ * and keel's ProblemDetail so consumers can branch on status codes and show
+ * field-level validation messages instead of a generic string.
+ */
+export class SailApiError extends Error {
+    readonly status: number;
+    readonly problem?: ProblemDetail;
+    readonly response: HttpErrorResponse;
+
+    constructor(response: HttpErrorResponse) {
+        const problem = (response.error && typeof response.error === 'object')
+            ? response.error as ProblemDetail
+            : undefined;
+        super(problem?.detail ?? problem?.title ?? response.message);
+        this.name = 'SailApiError';
+        this.status = response.status;
+        this.problem = problem;
+        this.response = response;
+    }
+}
+
 @Injectable({providedIn: 'root'})
 export class BackendService extends BaseRestService {
     private readonly auth = inject(BaseAuthService);
-    protected readonly prefix = this.url(RestURL.api_prefix);
 
-    protected handleError(error: HttpErrorResponse) {
+    /** Resolved per call so configureRestUrls() may run any time before the first request. */
+    protected get prefix(): string {
+        return this.url(RestURL.api_prefix);
+    }
+
+    protected handleError(error: unknown): Observable<never> {
+        if (!(error instanceof HttpErrorResponse)) {
+            // e.g. crudUrl's missing-version Error — already descriptive, pass through.
+            return throwError(() => error);
+        }
         if (error.status === 0) {
             console.error('an error occurred', error.error);
         } else {
-            console.error(`backend return error code: ${error.status} error body: ${error.error}`);
+            console.error(`backend returned error code ${error.status}`, error.error);
         }
-        return throwError(() => 'error occurred, see console log and try again');
+        return throwError(() => new SailApiError(error));
     }
 
     /** Free-form path under the API base — for custom endpoints (e.g. `rides/start`). CRUD methods use `crudUrl` instead. */
@@ -41,22 +79,22 @@ export class BackendService extends BaseRestService {
      * domain-specific actions.
      */
     protected request<T>(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, body?: unknown): Observable<T> {
-        return this.http.request<T>(method, this.apiUrl(path), { body }).pipe(catchError(this.handleError));
+        return this.http.request<T>(method, this.apiUrl(path), { body }).pipe(catchError((err) => this.handleError(err)));
     }
 
-    /** Build query params from a flat string-string map; skips undefined/null. */
+    /** Build query params from a flat string-string map; skips undefined/null values. */
     private toParams(filter?: {[key: string]: string}): HttpParams {
         let params = new HttpParams();
         if (!filter) return params;
         for (const key in filter) {
-            if (Object.prototype.hasOwnProperty.call(filter, key)) {
+            if (Object.prototype.hasOwnProperty.call(filter, key) && filter[key] != null) {
                 params = params.set(key, filter[key]);
             }
         }
         return params;
     }
 
-    /** Gates a CRUD call on appdata being loaded — `appData$` is a ReplaySubject(1) so this resolves synchronously once the cache is populated, and blocks the call (instead of throwing) when a component fires CRUD before loadAppData() finishes. */
+    /** Gates a CRUD call on appdata being loaded — `appData$` is a ReplaySubject(1) so this resolves synchronously once the cache is populated, and blocks the call (instead of throwing) while loadAppData() is in flight. A failed appdata load errors through here, so gated calls fail loudly instead of hanging. */
     private appDataReady(): Observable<ApplicationData> {
         return this.auth.getAppData().pipe(take(1));
     }
@@ -72,31 +110,37 @@ export class BackendService extends BaseRestService {
                 this.crudUrl(apiName, 'list'),
                 {params: this.toParams(filter)},
             )),
-            catchError(this.handleError),
+            catchError((err) => this.handleError(err)),
         );
     }
 
     get<T>(apiName: string, filter?: {[key: string]: string}) : Observable<T> {
         return this.appDataReady().pipe(
             switchMap(() => this.http.get<T>(this.crudUrl(apiName, 'get'), {params: this.toParams(filter)})),
-            catchError(this.handleError),
+            catchError((err) => this.handleError(err)),
         );
     }
 
     post<T>(apiName: string, items: T | T[]) : Observable<{message: string}> {
         return this.appDataReady().pipe(
             switchMap(() => this.http.post<{message: string}>(this.crudUrl(apiName, 'post'), items)),
-            catchError(this.handleError),
+            catchError((err) => this.handleError(err)),
         );
     }
 
     delete(apiName: string, filter?: {[key: string]: string}): Observable<{message: string}> {
         return this.appDataReady().pipe(
             switchMap(() => this.http.delete<{message: string}>(this.crudUrl(apiName, 'delete'), {params: this.toParams(filter)})),
-            catchError(this.handleError),
+            catchError((err) => this.handleError(err)),
         );
     }
 
+    /** GET a report endpoint (`{host}{api_prefix}{apiPath}`) — rows for TableReport. */
+    report<T = Record<string, unknown>>(apiPath: string, params?: {[key: string]: string}): Observable<T[]> {
+        return this.http.get<T[]>(this.apiUrl(apiPath), { params: this.toParams(params) })
+            .pipe(catchError((err) => this.handleError(err)));
+    }
+
     /**
      * Fire a TableAction button. `actionPath` is the resolved URL path
      * the keel REST engine pre-computed onto TableAction.method
@@ -106,6 +150,6 @@ export class BackendService extends BaseRestService {
      * primary key values; for table-level actions it is typically `{}`.
      */
     executeAction<T = unknown>(actionPath: string, body: Record<string, unknown> = {}): Observable<T> {
-        return this.http.post<T>(this.apiUrl(actionPath), body).pipe(catchError(this.handleError));
+        return this.http.post<T>(this.apiUrl(actionPath), body).pipe(catchError((err) => this.handleError(err)));
     }
 }

package/src/service/rest_url.ts

@@ -44,7 +44,11 @@ export const RestURL = {
   profilePhoneConfirmURL: '/api/user/profile/phone/confirm',
   pushRegisterURL:     '/api/push/register',
   pushRevokeURL:       '/api/push/revoke',
-  // Payout — keel/payout endpoints.
+  // Payout — keel/payout endpoints. keel mounts PayoutHandler.Routes(prefix)
+  // under the app's REST prefix; these defaults assume the conventional
+  // '/api/v1'. Payout routes are not in the Apis dictionary, so the version
+  // cannot be derived at runtime — apps mounting elsewhere MUST override
+  // these via configureRestUrls.
   payoutOnboardStartURL: '/api/v1/payout/onboard/start',
   payoutReusableURL:     '/api/v1/payout/reusable',
   payoutReusableLinkURL: '/api/v1/payout/reusable/link',
@@ -62,6 +66,17 @@ export function configureRestUrls(httpHost: string, overrides?: Partial<typeof R
   if (overrides) {
     Object.assign(RestURL, overrides);
   }
+  // A trailing slash would make url() produce host//api/... while the
+  // interceptor matchers look for host/api/... — normalize once here.
+  if (RestURL.httpHost.endsWith('/')) {
+    RestURL.httpHost = RestURL.httpHost.slice(0, -1);
+  }
+}
+
+/** Configured host without a trailing slash, so `host + '/api/'` never yields `//api/`. */
+function normalizedHost(): string {
+  const host = RestURL.httpHost;
+  return host.endsWith('/') ? host.slice(0, -1) : host;
 }
 
 /**
@@ -70,17 +85,18 @@ export function configureRestUrls(httpHost: string, overrides?: Partial<typeof R
  * a third-party origin that merely happens to contain `/api/` in its path.
  */
 export function isKeelApiUrl(url: string): boolean {
-  const host = RestURL.httpHost;
+  const host = normalizedHost();
   return host ? url.startsWith(host + '/api/') : url.startsWith('/api/');
 }
 
 /**
- * True when `url` targets the keel backend at all (`/api/` or `/public/`).
- * Used to scope the response interceptor's envelope-unwrapping so third-party
- * responses pass through untouched.
+ * True when `url` targets the keel backend's API surface (`/api/` or
+ * `/public/`). Used to scope the response interceptor's envelope-unwrapping so
+ * third-party responses — and non-API fetches from the backend host (assets,
+ * health checks) — pass through untouched.
  */
 export function isKeelUrl(url: string): boolean {
-  const host = RestURL.httpHost;
-  if (host) return url.startsWith(host + '/');
+  const host = normalizedHost();
+  if (host) return url.startsWith(host + '/api/') || url.startsWith(host + '/public/');
   return url.startsWith('/api/') || url.startsWith('/public/');
 }

package/src/service/script_loader.ts

@@ -15,17 +15,27 @@ export function loadScript(src: string): Promise<void> {
       return;
     }
     const prior = document.querySelector<HTMLScriptElement>(`script[src="${src}"]`);
-    if (prior) { resolve(); return; }
+    if (prior) {
+      // A tag we (or the host page) already inserted may still be loading —
+      // resolve on its load event, not on mere presence in the DOM.
+      if (prior.dataset['sailLoaded']) { resolve(); return; }
+      prior.addEventListener('load', () => resolve());
+      prior.addEventListener('error', () => reject(new Error(`Failed to load ${src}`)));
+      return;
+    }
 
     const el = document.createElement('script');
     el.src = src;
     el.async = true;
     el.defer = true;
-    el.onload = () => resolve();
+    el.onload = () => { el.dataset['sailLoaded'] = 'true'; resolve(); };
     el.onerror = () => reject(new Error(`Failed to load ${src}`));
     document.head.appendChild(el);
   });
 
   cache.set(src, p);
+  // Evict failures so a transient network error doesn't disable the feature
+  // (e.g. social login) for the rest of the page's lifetime.
+  p.catch(() => cache.delete(src));
   return p;
 }

package/src/util/errors.ts

@@ -0,0 +1,20 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { SailApiError } from '../service/rest_service';
+
+/**
+ * Human-readable message from any sail error shape — SailApiError (BackendService),
+ * raw HttpErrorResponse (direct HttpClient calls), or plain Error.
+ */
+export function errorDetail(err: unknown, fallback: string): string {
+  if (err instanceof SailApiError) {
+    return err.problem?.detail ?? err.problem?.title ?? err.message ?? fallback;
+  }
+  if (err instanceof HttpErrorResponse) {
+    const body = err.error as { detail?: string; message?: string } | null;
+    return body?.detail ?? body?.message ?? fallback;
+  }
+  if (err instanceof Error && err.message) {
+    return err.message;
+  }
+  return fallback;
+}

package/src/util/money.ts

@@ -13,17 +13,29 @@ export function formatCurrency(amount: number, currency: string): string {
   }
 }
 
+/** PERIOD_TYPE code vocabulary — the single source for cycle labels/durations. */
+export const PERIOD_TYPE_INFO: Record<string, { label: string; noun: string; suffix: string; months: number }> = {
+  D: { label: 'Daily',     noun: 'day',     suffix: '/day', months: 1 / 30 },
+  W: { label: 'Weekly',    noun: 'week',    suffix: '/wk',  months: 7 / 30 },
+  M: { label: 'Monthly',   noun: 'month',   suffix: '/mo',  months: 1 },
+  Q: { label: 'Quarterly', noun: 'quarter', suffix: '/qtr', months: 3 },
+  A: { label: 'Annual',    noun: 'year',    suffix: '/yr',  months: 12 },
+};
+
 /**
- * "From" price teaser for a plan card / dropdown — the lowest priced offer,
- * currency-formatted, prefixed "from " when the plan sells more than one priced
- * offer. Returns '' when the plan has no priced offers (free/trial), so callers
- * can omit the price line entirely. The exact offer is chosen later via
- * `<sail-price-selector>`.
+ * "From" price teaser for a plan card / dropdown — the cheapest offer once
+ * normalized per month (a $2 daily offer must not undercut a $30 monthly one),
+ * compared within one currency, rendered with its cycle ("from $30.00/mo").
+ * Returns '' when the plan has no priced offers (free/trial). The exact offer
+ * is chosen later via `<sail-price-selector>`.
  */
 export function fromPriceLabel(prices: PlanPrice[] | undefined): string {
   const priced = (prices ?? []).filter((p) => p.amount > 0);
   if (priced.length === 0) return '';
-  const lowest = priced.reduce((a, b) => (b.amount < a.amount ? b : a));
-  const formatted = formatCurrency(lowest.amount, lowest.currency);
+  const currency = priced[0].currency;
+  const comparable = priced.filter((p) => p.currency === currency);
+  const perMonth = (p: PlanPrice) => p.amount / (PERIOD_TYPE_INFO[p.billingCycle]?.months ?? 1);
+  const lowest = comparable.reduce((a, b) => (perMonth(b) < perMonth(a) ? b : a));
+  const formatted = formatCurrency(lowest.amount, lowest.currency) + (PERIOD_TYPE_INFO[lowest.billingCycle]?.suffix ?? '');
   return priced.length > 1 ? `from ${formatted}` : formatted;
 }