@nauticana/sail 0.9.0 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nauticana/sail",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Metadata-driven Angular component library for CRUD admin frontends backed by the keel Go backend. Tables, forms, navigation, OTP/2FA/social auth, billing, payout onboarding.",
   "main": "src/index.ts",
   "files": [

package/src/component/table/table_lookup.ts

@@ -46,7 +46,7 @@ export class TableLookup extends BaseView implements OnInit {
                     for (const api in data.Apis) {
                         const entry = data.Apis[api];
                         if (entry.Table.TableName === tableName) {
-                            this.apiName.set(entry.Version ? entry.Version + '/' + api : api);
+                            this.apiName.set(api); // bare RestUri; BackendService.crudUrl resolves the version
                             break;
                         }
                     }

package/src/service/auth.service.ts

@@ -557,7 +557,7 @@ export abstract class BaseAuthService extends BaseRestService {
                     if (!page.ItemId) continue;
                     const restUri = page.RestUri ?? '';
                     const api = apis?.[restUri];
-                    const apiName = api?.Version ? api.Version + '/' + restUri : restUri;
+                    const apiName = restUri; // bare RestUri; BackendService.crudUrl resolves the version
                     const tableName = api?.Table?.TableName ?? restUri;
 
                     const overrideComponent = this.getRouteOverride(restUri);

package/src/service/rest_service.ts

@@ -1,12 +1,14 @@
 import { HttpErrorResponse, HttpParams } from "@angular/common/http";
-import { Injectable } from "@angular/core";
-import { catchError, map, Observable, throwError } from "rxjs";
-import { PaginatedList } from "../model/appdata";
+import { inject, Injectable } from "@angular/core";
+import { catchError, map, Observable, switchMap, take, throwError } from "rxjs";
+import { ApplicationData, PaginatedList } from "../model/appdata";
 import { RestURL } from "./rest_url";
+import { BaseAuthService } from "./auth.service";
 import { BaseRestService } from "./base_rest.service";
 
 @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) {
@@ -18,33 +20,25 @@ export class BackendService extends BaseRestService {
         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.
-     */
+    /** Free-form path under the API base — for custom endpoints (e.g. `rides/start`). CRUD methods use `crudUrl` instead. */
     protected apiUrl(path: string): string {
         const trimmed = path.startsWith('/') ? path.slice(1) : path;
         return this.prefix + trimmed;
     }
 
+    /** CRUD URL versioned from the backend (Apis[apiName].Version); throws rather than assume a version. */
+    private crudUrl(apiName: string, action: string): string {
+        const version = this.auth.getApiDictionary(apiName)?.Version;
+        if (!version) {
+            throw new Error(`sail: no backend version for API "${apiName}"; refusing to assume one.`);
+        }
+        return `${this.prefix}${version}/${apiName}/${action}`;
+    }
+
     /**
      * 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.
+     * 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));
@@ -62,34 +56,45 @@ export class BackendService extends BaseRestService {
         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).
-     */
+    /** 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. */
+    private appDataReady(): Observable<ApplicationData> {
+        return this.auth.getAppData().pipe(take(1));
+    }
+
+    /** Unwraps `{items, limit, offset, total}` to the items array. 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));
+        return this.appDataReady().pipe(
+            switchMap(() => this.http.get<PaginatedList<T>>(
+                this.crudUrl(apiName, 'list'),
+                {params: this.toParams(filter)},
+            )),
+            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));
+        return this.appDataReady().pipe(
+            switchMap(() => this.http.get<T>(this.crudUrl(apiName, 'get'), {params: this.toParams(filter)})),
+            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));
+        return this.appDataReady().pipe(
+            switchMap(() => this.http.post<{message: string}>(this.crudUrl(apiName, 'post'), items)),
+            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));
+        return this.appDataReady().pipe(
+            switchMap(() => this.http.delete<{message: string}>(this.crudUrl(apiName, 'delete'), {params: this.toParams(filter)})),
+            catchError(this.handleError),
+        );
     }
 
     /**