@nauticana/sail 0.5.0

package/src/service/rest_service.ts

@@ -0,0 +1,94 @@
+import { HttpClient, HttpErrorResponse, HttpParams } from "@angular/common/http";
+import { inject, Injectable } from "@angular/core";
+import { catchError, map, Observable, throwError } from "rxjs";
+import { PaginatedList } from "../model/appdata";
+import { RestURL } from "./rest_url";
+
+@Injectable({providedIn: 'root'})
+export class BackendService {
+    protected readonly prefix = RestURL.httpHost + RestURL.api_prefix;
+    protected readonly http = inject(HttpClient);
+
+    protected handleError(error: HttpErrorResponse) {
+        if (error.status === 0) {
+            console.error('an error occurred', error.error);
+        } else {
+            console.error(`backend return error code: ${error.status} error body: ${error.error}`);
+        }
+        return throwError(() => 'error occurred, see console log and try again');
+    }
+
+    /**
+     * Build a fully-qualified URL under the configured API base. Use for
+     * endpoints that don't fit the metadata-driven `/api/{name}/{op}`
+     * shape — e.g. domain-specific actions like `rides/start`. Strips any
+     * leading slash on `path` so callers can pass either form.
+     *
+     * For metadata-driven CRUD use list/get/post/delete instead — they
+     * already build the URL.
+     */
+    protected apiUrl(path: string): string {
+        const trimmed = path.startsWith('/') ? path.slice(1) : path;
+        return this.prefix + trimmed;
+    }
+
+    /**
+     * Generic typed HTTP request for endpoints that don't fit the
+     * list/get/post/delete pattern. Subclasses use this for
+     * domain-specific actions:
+     *
+     *   class RideService extends BackendService {
+     *     startRide(req: StartRideReq) {
+     *       return this.request<RideResponse>('POST', 'rides/start', req);
+     *     }
+     *   }
+     *
+     * Errors are routed through handleError so callers see the same
+     * "see console log and try again" envelope as CRUD methods.
+     */
+    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));
+    }
+
+    /** Build query params from a flat string-string map; skips undefined/null. */
+    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)) {
+                params = params.set(key, filter[key]);
+            }
+        }
+        return params;
+    }
+
+    /**
+     * keel list endpoints return `{items, limit, offset, total}`. This method
+     * unwraps to the array — most callers only need the records. Use
+     * `listPaginated()` to access the total + offset. Pass `_limit` / `_offset`
+     * in `filter` to control paging (defaults: 100 / 0).
+     */
+    list<T>(apiName: string, filter?: {[key: string]: string}) : Observable<T[]> {
+        return this.listPaginated<T>(apiName, filter).pipe(map((page) => page.items));
+    }
+
+    /** Paginated list — returns `{items, limit, offset, total}`. */
+    listPaginated<T>(apiName: string, filter?: {[key: string]: string}) : Observable<PaginatedList<T>> {
+        return this.http.get<PaginatedList<T>>(
+            this.apiUrl(apiName + '/list'),
+            {params: this.toParams(filter)},
+        ).pipe(catchError(this.handleError));
+    }
+
+    get<T>(apiName: string, filter?: {[key: string]: string}) : Observable<T> {
+        return this.http.get<T>(this.apiUrl(apiName + '/get'), {params: this.toParams(filter)}).pipe(catchError(this.handleError));
+    }
+
+    post<T>(apiName: string, items: T | T[]) : Observable<{message: string}> {
+        return this.http.post<{message: string}>(this.apiUrl(apiName + '/post'), items).pipe(catchError(this.handleError));
+    }
+
+    delete(apiName: string, filter?: {[key: string]: string}): Observable<{message: string}> {
+        return this.http.delete<{message: string}>(this.apiUrl(apiName + '/delete'), {params: this.toParams(filter)}).pipe(catchError(this.handleError));
+    }
+}

package/src/service/rest_url.ts

@@ -0,0 +1,42 @@
+export const RestURL = {
+  httpHost: '',
+  api_prefix: '/api/',
+  appdataURL: '/api/config/appdata',
+  loginURL: '/public/login/local',
+  loginGoogleURL: '/public/login/google',
+  registerURL: '/public/register',
+  chpassURL: '/public/login/chpass',
+  confirmRegisterURL: '/public/confirm/register',
+  plansURL: '/public/plans',
+  confirmChpassURL: '/public/confirm/password',
+  twoFactorSetupURL: '/api/user/2fa/setup',
+  twoFactorVerifyURL: '/api/user/2fa/verify',          // authenticated — confirms setup
+  twoFactorDisableURL: '/api/user/2fa/disable',
+  twoFactorLoginVerifyURL: '/public/2fa/verify',        // public — login-time TOTP verify
+  twoFactorBackupVerifyURL: '/public/2fa/backup-verify', // public — login-time backup verify
+  trustedDeviceListURL: '/api/user/trusted-device/list',
+  trustedDeviceRegisterURL: '/api/user/trusted-device/register',
+  trustedDeviceRevokeURL: '/api/user/trusted-device/revoke',
+  checkoutURL:       '/api/billing/checkout',
+  subscriptionURL:   '/api/billing/subscription',
+  cancelSubURL:      '/api/billing/subscription/cancel',
+  invoicesURL:       '/api/billing/invoices',
+  paymentMethodsURL: '/api/billing/payment-methods',
+  // OTP / social / push / account-lifecycle endpoints
+  otpSendURL:          '/public/otp/send',
+  otpVerifyURL:        '/public/otp/verify',
+  otpResendURL:        '/public/otp/resend',
+  loginSocialURL:      '/public/login/social',
+  logoutEverywhereURL: '/api/user/logout-everywhere',
+  deleteAccountURL:    '/api/user/account',
+  pushRegisterURL:     '/api/push/register',
+  pushRevokeURL:       '/api/push/revoke',
+};
+
+/** Call this at app startup to set the backend host URL */
+export function configureRestUrls(httpHost: string, overrides?: Partial<typeof RestURL>) {
+  RestURL.httpHost = httpHost;
+  if (overrides) {
+    Object.assign(RestURL, overrides);
+  }
+}

package/src/service/script_loader.ts

@@ -0,0 +1,31 @@
+/**
+ * Dynamic external <script> loader. Used by SocialLoginComponent to bring
+ * in Google Identity Services / Apple JS on demand instead of bundling them.
+ * Caches by URL — subsequent calls for the same URL resolve immediately.
+ */
+const cache = new Map<string, Promise<void>>();
+
+export function loadScript(src: string): Promise<void> {
+  const existing = cache.get(src);
+  if (existing) return existing;
+
+  const p = new Promise<void>((resolve, reject) => {
+    if (typeof document === 'undefined') {
+      reject(new Error('loadScript: no document (SSR?)'));
+      return;
+    }
+    const prior = document.querySelector<HTMLScriptElement>(`script[src="${src}"]`);
+    if (prior) { resolve(); return; }
+
+    const el = document.createElement('script');
+    el.src = src;
+    el.async = true;
+    el.defer = true;
+    el.onload = () => resolve();
+    el.onerror = () => reject(new Error(`Failed to load ${src}`));
+    document.head.appendChild(el);
+  });
+
+  cache.set(src, p);
+  return p;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "dom"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}