@nutin/cli 2.1.0 → 3.0.0

package/templates/base/src/core/services/http-client/http-client.ts.hbs

@@ -1,35 +1,42 @@
-import { Service } from "../../index.js";
-import { HttpBuilder, HttpMethod, IRequestConfig } from "./helpers/http-builder.helper.js";
-import { HttpManager } from "./helpers/http-manager.helper.js";
+import { Service } from "../../base-classes/service/service.js";
+import * as HttpBuilder from "./helpers/http-builder.helper.js";
+import * as HttpManager from "./helpers/http-manager.helper.js";
 
-export type IHttpClient = InstanceType<typeof HttpClient>;
+export { path } from "./helpers/http-builder.helper.js";
+export { HttpError } from "./helpers/http-manager.helper.js";
 
 export class HttpClient extends Service<HttpClient> {
   private _baseUrl: string;
   private _defaultHeaders: Record<string, string>;
+  private _trustedAPIs: string[];
 
   private _requestInterceptors: Array<(url: string, options: RequestInit) => void> = [];
   private _responseInterceptors: Array<(response: Response) => void> = [];
 
-  constructor(baseUrl: string = '', defaultHeaders: Record<string, string> = {}) {
+  constructor(
+    baseUrl: string = '',
+    defaultHeaders: Record<string, string> = {},
+    options: Nutin.HttpClientOptions = {}
+  ) {
     super();
     this._baseUrl = baseUrl;
-    this._defaultHeaders = { 'Content-Type': 'application/json', ...defaultHeaders };
+    this._defaultHeaders = { ...defaultHeaders };
+    this._trustedAPIs = [...(options.trustedAPIs ?? [])];
   }
 
-  public get<T = unknown>(endpoint: string, config?: IRequestConfig): Promise<T> { 
+  public get<T = unknown>(endpoint: string, config?: Nutin.RequestConfig): Promise<T> {
     return this.request<T>('GET', endpoint, null, config);
   }
-  public post<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig): Promise<T> { 
+  public post<T = unknown>(endpoint: string, data?: unknown, config?: Nutin.RequestConfig): Promise<T> {
     return this.request<T>('POST', endpoint, data, config);
   }
-  public put<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig): Promise<T> { 
+  public put<T = unknown>(endpoint: string, data?: unknown, config?: Nutin.RequestConfig): Promise<T> {
     return this.request<T>('PUT', endpoint, data, config);
   }
-  public patch<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig): Promise<T> { 
+  public patch<T = unknown>(endpoint: string, data?: unknown, config?: Nutin.RequestConfig): Promise<T> {
     return this.request<T>('PATCH', endpoint, data, config);
   }
-  public delete<T = unknown>(endpoint: string, config?: IRequestConfig): Promise<T> { 
+  public delete<T = unknown>(endpoint: string, config?: Nutin.RequestConfig): Promise<T> {
     return this.request<T>('DELETE', endpoint, undefined, config);
   }
 
@@ -37,6 +44,7 @@ export class HttpClient extends Service<HttpClient> {
     this._requestInterceptors.push(fn);
   }
 
+  // Each interceptor gets its own clone, so reading the body there doesn't consume it.
   public addResponseInterceptor(fn: (response: Response) => void): void {
     this._responseInterceptors.push(fn);
   }
@@ -44,41 +52,45 @@ export class HttpClient extends Service<HttpClient> {
   protected onDestroy(): void {
     this._baseUrl = '';
     this._defaultHeaders = {};
+    this._trustedAPIs = [];
     this._requestInterceptors = [];
     this._responseInterceptors = [];
   }
 
   private async request<T>(
-    method: HttpMethod,
+    method: Nutin.HttpMethod,
     endpoint: string,
     data?: unknown,
-    config?: IRequestConfig
+    config: Nutin.RequestConfig = {}
   ): Promise<T> {
-    const { controller, timeoutId } = HttpManager.createAbortController(config?.timeout);
-    const fullUrl = `${this._baseUrl}${endpoint}`;
-    const mergedConfig: IRequestConfig = {
-      ...config,
-      headers: { ...this._defaultHeaders, ...config?.headers },
-    };
+    const abort = HttpManager.createAbortController(config.timeout, config.signal);
 
     try {
-      const url = HttpBuilder.buildRequestUrl(fullUrl, config?.queryParams);
-      const requestOptions = HttpBuilder.buildRequestOptions(method, data, mergedConfig, controller.signal);
+      const url = HttpBuilder.resolveUrl(this._baseUrl, endpoint, this._trustedAPIs);
+      HttpBuilder.appendQueryParams(url, config.queryParams);
+
+      // Without a base URL, the client's default headers only go to the page's own origin;
+      // per-call headers are sent wherever the call goes.
+      const sendDefaults = this._baseUrl !== '' || url.origin === window.location.origin;
+      const headers = HttpBuilder.mergeHeaders(sendDefaults ? this._defaultHeaders : undefined, config.headers);
+      const requestOptions = HttpBuilder.buildRequestOptions(method, data, config, headers, abort.controller.signal);
 
       this._requestInterceptors.forEach(fn => fn(url.toString(), requestOptions));
 
       const response = await fetch(url.toString(), requestOptions);
+      // Checked before interceptors: another origin's response is never handed to app code.
+      if (response.redirected) HttpBuilder.assertRedirectTarget(this._baseUrl, url, response.url);
 
-      this._responseInterceptors.forEach(fn => fn(response));
+      this._responseInterceptors.forEach(fn => fn(response.clone()));
 
       await HttpManager.validateResponse(response);
       return await HttpManager.parseSuccessResponse<T>(response);
     } catch (error) {
-      HttpManager.handleRequestError(error);
+      HttpManager.handleRequestError(error, abort.timedOut());
     } finally {
-      HttpManager.cleanupTimeout(timeoutId);
+      abort.cleanup();
     }
   }
 }
 
-export const AppHttpClient = HttpClient.getInstance();
+export const AppHttpClient = /* @__PURE__ */ HttpClient.getInstance();

package/templates/base/src/core/services/i18n/i18n.test.js.hbs

@@ -1,4 +1,4 @@
-import { I18nService, AppEventBus } from '#root/dist/src/core/services/index.js';
+import { I18nService, initI18n } from '#root/dist/src/core/services/index.js';
 import { CONFIG } from '#root/dist/src/core/config.js';
 
 class FetchMock {
@@ -57,7 +57,6 @@ describe('i18n module', async () => {
   });
   afterEach(() => {
     fetchMock.restore();
-    localStorage.removeItem(I18nService.localStorageKey)
   });
 
   beforeAll(() =>{
@@ -125,23 +124,38 @@ describe('i18n module', async () => {
     expect(I18nService.translate('non.existent.key')).toBe('non.existent.key');
   });
 
+  it('translate and getTranslationObject ignore inherited Object.prototype members', () => {
+    expect(I18nService.translate('constructor')).toBe('constructor');
+    expect(I18nService.translate('__proto__')).toBe('__proto__');
+    expect(I18nService.translate('home.toString')).toBe('home.toString');
+    expect(I18nService.getTranslationObject('constructor')).toBe(null);
+  });
+
   it('setCurrentLanguage updates the language, persists it and loads its translations', async () => {
     await I18nService.setCurrentLanguage('fr');
 
     expect(I18nService.currentLanguage).toBe('fr');
     expect(I18nService.translate('home.title')).toBe('Mon App');
-    expect(localStorage.getItem(I18nService.localStorageKey)).toBe('fr');
   });
 
   it('setCurrentLanguage emits a language-changed event with the new language', async () => {
     const received = [];
-    const callback = (data) => received.push(data);
-    I18nService.onLanguageChange(callback);
+    const unsubscribe = I18nService.onLanguageChange((data) => received.push(data));
 
     await I18nService.setCurrentLanguage('fr');
 
     expect(received).toEqual([{ lang: 'fr' }]);
-    AppEventBus.off('language-changed', callback);
+    unsubscribe();
+  });
+
+  it('onLanguageChange returns a function that stops further notifications', async () => {
+    const received = [];
+    const unsubscribe = I18nService.onLanguageChange((data) => received.push(data));
+    unsubscribe();
+
+    await I18nService.setCurrentLanguage('fr');
+
+    expect(received).toEqual([]);
   });
 
   it('getTranslationObject returns the nested value for the current language', async () => {
@@ -224,12 +238,6 @@ describe('i18n module', async () => {
     errSpy.restore();
   });
 
-  it('honors a previously saved language preference from localStorage', async () => {
-    localStorage.setItem(I18nService.localStorageKey, 'fr');
-    await I18nService.initTranslations();
-    expect(I18nService.currentLanguage).toBe('fr');
-  });
-
   it('loadTranslations logs and leaves the language unchanged when the fetch rejects', async () => {
     Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'en-US' });
     const errSpy = spyOn(console, 'error');
@@ -258,13 +266,46 @@ describe('i18n module', async () => {
     errSpy.restore();
   });
 
-  it('onDestroy resets translations and disposes the instance', async () => {
-    await I18nService.initTranslations();
-    expect(I18nService.translate('home.title')).toBe('My App');
+  it('onDestroy clears translations but keeps the saved language preference', async () => {
+    await I18nService.setCurrentLanguage('fr');
+    expect(I18nService.translate('home.title')).toBe('Mon App');
 
     I18nService.onDestroy();
 
     expect(I18nService.translate('home.title')).toBe('home.title');
-    expect(localStorage.getItem(I18nService.localStorageKey)).toBe(null);
+  });
+
+  it('resetTranslations also forgets the saved language preference', async () => {
+    await I18nService.setCurrentLanguage('fr');
+
+    I18nService.resetTranslations();
+
+    expect(I18nService.currentLanguage).toBe('en');
+  });
+
+  it('initI18n loads the translations when CONFIG.i18n is enabled', async () => {
+    const original = I18nService.initTranslations;
+    let calls = 0;
+    I18nService.initTranslations = async () => { calls++; };
+    CONFIG.i18n = true;
+    try {
+      await initI18n();
+      expect(calls).toBe(1);
+    } finally {
+      CONFIG.i18n = false;
+      I18nService.initTranslations = original;
+    }
+  });
+
+  it('initI18n does nothing when CONFIG.i18n is disabled (default)', async () => {
+    const original = I18nService.initTranslations;
+    let calls = 0;
+    I18nService.initTranslations = async () => { calls++; };
+    try {
+      await initI18n();
+      expect(calls).toBe(0);
+    } finally {
+      I18nService.initTranslations = original;
+    }
   });
 });

package/templates/base/src/core/services/i18n/i18n.ts.hbs

@@ -1,49 +1,46 @@
-import { DEFAULT_LANGUAGE, LANGUAGES, Language, Translations } from './languages.js';
-import { AppEventBus, Service } from '../../index.js';
+import { DEFAULT_LANGUAGE, LANGUAGES } from './languages.js';
+import { AppEventBus } from '../event-bus/event-bus.js';
+import { Service } from '../../base-classes/service/service.js';
 import { CONFIG } from '../../config.js';
 
 export class I18n extends Service<I18n> {
-  private readonly _DEFAULT_LANGUAGE: Language = DEFAULT_LANGUAGE;
+  private readonly _DEFAULT_LANGUAGE: Nutin.Language = DEFAULT_LANGUAGE;
   private readonly _LANGUAGES = LANGUAGES;
-  private _currentLanguage: Language = this._DEFAULT_LANGUAGE;
-  private _translations: Translations = {};
-  private _defaultTranslations: Translations = {};
-  private readonly _localStorageKey = 'nutin-fav-lang';
+  private _currentLanguage: Nutin.Language = this._DEFAULT_LANGUAGE;
+  private _translations: Nutin.Translations = {};
+  private _defaultTranslations: Nutin.Translations = {};
 
   constructor() {
     super();
-    this.registerCleanup(this.resetTranslations);
+    this.registerCleanup(this.clearTranslations);
     this._currentLanguage = this.getPreferredLanguage();
   }
 
-  public get currentLanguage(): Language {
+  public get currentLanguage(): Nutin.Language {
     return this._currentLanguage;
   }
 
-  public get defaultLanguage(): Language {
+  public get defaultLanguage(): Nutin.Language {
     return this._DEFAULT_LANGUAGE;
   }
 
-  public get languages(): Language[] {
+  public get languages(): Nutin.Language[] {
     return this._LANGUAGES;
   }
 
-  public get localStorageKey(): string {
-    return this._localStorageKey;
-  }
-
-  public async setCurrentLanguage(lang: Language): Promise<void> {
+  public async setCurrentLanguage(lang: Nutin.Language): Promise<void> {
     this._currentLanguage = lang;
-    this.savePreferences();
     await this.loadTranslations(lang);
     AppEventBus.emit('language-changed', { lang });
   }
 
-  public onLanguageChange(callback: (payload: { lang: string }) => void) {
+  // Returns the unsubscribe function, like Navigation.onNavigate().
+  public onLanguageChange(callback: (payload: { lang: string }) => void): () => void {
     AppEventBus.subscribe('language-changed', callback);
+    return () => AppEventBus.off('language-changed', callback);
   }
 
-  public async loadTranslations(lang: Language): Promise<void> {
+  public async loadTranslations(lang: Nutin.Language): Promise<void> {
     try {
       const response = await fetch(`/locales/${lang}.json`);
       
@@ -56,8 +53,7 @@ export class I18n extends Service<I18n> {
         await this.loadDefaultTranslations();
       }
       
-      document.documentElement.lang = lang;   
-      this.savePreferences();
+      document.documentElement.lang = lang;
     } catch (error) {
       console.error('Translation load error:', error);
     }
@@ -101,31 +97,33 @@ export class I18n extends Service<I18n> {
     return value || null;
   }
 
+  // Also forgets the saved language preference.
   public resetTranslations(): void {
-    this._translations = {};
-    this._defaultTranslations = {};
-    localStorage.removeItem(this._localStorageKey);
-    this._currentLanguage = this._DEFAULT_LANGUAGE;
+    this.clearTranslations();
   }
 
+  // Teardown keeps the saved preference: it belongs to the user, not to this instance.
   protected onDestroy(): void | Promise<void> {
-    this.resetTranslations();
     this.dispose();
   }
 
-  private getPreferredLanguage(): Language {
+  private clearTranslations(): void {
+    this._translations = {};
+    this._defaultTranslations = {};
+    this._currentLanguage = this._DEFAULT_LANGUAGE;
+  }
+
+  private getPreferredLanguage(): Nutin.Language {
     const urlLocale = this.getLocaleFromUrl();
     if (urlLocale) return urlLocale;
-    const stored = this.getPreferences();
-    if (stored && this._LANGUAGES.includes(stored as Language)) return stored as Language;
-    const browserLang = navigator.language.split('-')[0] as Language;
+    const browserLang = navigator.language.split('-')[0] as Nutin.Language;
     return this._LANGUAGES.includes(browserLang) ? browserLang : this._DEFAULT_LANGUAGE;
   }
 
-  private getLocaleFromUrl(): Language | null {
-    if (!CONFIG.i18n) return null;
+  private getLocaleFromUrl(): Nutin.Language | null {
+    if (!(globalThis.__NUTIN_I18N__ ?? CONFIG.i18n)) return null;
 
-    const first = window.location.pathname.split('/').filter(Boolean)[0] as Language;
+    const first = window.location.pathname.split('/').filter(Boolean)[0] as Nutin.Language;
     return first && this._LANGUAGES.includes(first) ? first : null;
   }
 
@@ -143,20 +141,22 @@ export class I18n extends Service<I18n> {
 
   private getNestedValue(obj: any, keys: string[]): any {
     let value = obj;
+    // Own keys only: "constructor" or "__proto__" must not resolve to Object.prototype members.
     for (const key of keys) {
-      value = value?.[key];
+      value = value !== null && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, key)
+        ? value[key]
+        : undefined;
       if (!value) break;
     }
     return value;
   }
+}
 
-  private savePreferences(): void {
-    localStorage.setItem(this._localStorageKey, this._currentLanguage);
-  }
+export const I18nService = /* @__PURE__ */ I18n.getInstance();
 
-  private getPreferences(): string | null {
-    return localStorage.getItem(this._localStorageKey);
-  }
+/**
+ * Loads the translations when i18n is enabled in nutin.config.js; a no-op otherwise.
+ */
+export async function initI18n(): Promise<void> {
+  if (globalThis.__NUTIN_I18N__ ?? CONFIG.i18n) await I18nService.initTranslations();
 }
-
-export const I18nService = I18n.getInstance();

package/templates/base/src/core/services/i18n/languages.ts.hbs

@@ -3,5 +3,3 @@ import { CONFIG } from '../../config.js';
 export const LANGUAGES = CONFIG.langs.languages;
 export const DEFAULT_LANGUAGE = CONFIG.langs.defaultLanguage as (typeof LANGUAGES)[number];
 
-export type Language = typeof LANGUAGES[number];
-export type Translations = Record<string, any>;

package/templates/base/src/core/services/pipe-registry/pipe-registry.ts.hbs

@@ -1,13 +1,11 @@
-import { Service } from "../../base-classes/index.js";
-
-export type PipeFunction = (value: any, ...args: any[]) => string;
+import { Service } from "../../base-classes/service/service.js";
 
 class PipeRegistry extends Service<PipeRegistry> {
-  private _pipes: Record<string, PipeFunction> = {};
+  private _pipes: Record<string, Nutin.PipeFunction> = {};
 
   constructor() { super(); }
 
-  public register(name: string, fn: PipeFunction): void {
+  public register(name: string, fn: Nutin.PipeFunction): void {
     if(this._pipes[name]) {
       console.warn(`Pipe "${name}" already exists - skipping.`);
       return;
@@ -29,4 +27,4 @@ class PipeRegistry extends Service<PipeRegistry> {
   }
 }
 
-export const AppPipeRegistry = PipeRegistry.getInstance();
+export const AppPipeRegistry = /* @__PURE__ */ PipeRegistry.getInstance();

package/templates/base/src/core/services/pipe-registry/pipes.test.js.hbs

@@ -52,6 +52,16 @@ describe('pipes (registerPipes)', () => {
     expect(AppPipeRegistry.apply('date', value, ['en-US', 'long', true])).toBe(expected);
   });
 
+  it('date reads the time flag from template strings: "true" adds the time, "false" does not', () => {
+    const value = '2024-03-15T14:30:00Z';
+    const dateOnly = new Date(value).toLocaleString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+    const withTime = new Date(value).toLocaleString('en-US', {
+      year: 'numeric', month: 'long', day: 'numeric', hour: '2-digit', minute: '2-digit',
+    });
+    expect(AppPipeRegistry.apply('date', value, ['en-US', 'long', 'false'])).toBe(dateOnly);
+    expect(AppPipeRegistry.apply('date', value, ['en-US', 'long', 'true'])).toBe(withTime);
+  });
+
   it('date warns and returns the raw stringified value for an invalid date', () => {
     const warnSpy = spyOn(console, 'warn');
     warnSpy.andCallFake(() => {});

package/templates/base/src/core/services/pipe-registry/pipes.ts.hbs

@@ -18,12 +18,14 @@ export const registerPipes = (): void => {
     value: string | number | Date,
     locale = navigator.language,
     format = 'long',
-    time = false,
+    time: boolean | string = false,
   ) => {
     const date = new Date(value);
     // '' is not a valid Intl.DateTimeFormatOptions value for hour/minute, so
     // omit those keys entirely rather than setting them when time is false.
-    const timeOptions: Intl.DateTimeFormatOptions = time ? { hour: '2-digit', minute: '2-digit' } : {};
+    // From a template the flag arrives as a string ("false" is truthy).
+    const withTime = time === true || time === 'true';
+    const timeOptions: Intl.DateTimeFormatOptions = withTime ? { hour: '2-digit', minute: '2-digit' } : {};
     const formats = {
       short: { year: 'numeric', month: 'short', day: 'numeric', ...timeOptions } as Intl.DateTimeFormatOptions,
       long: { year: 'numeric', month: 'long', day: 'numeric', ...timeOptions } as Intl.DateTimeFormatOptions,