@tinya-code/gas-admin-ui 0.2.0-alpha.15 → 0.2.0-alpha.18

package/src/lib/core/services/config.service.ts

@@ -1,119 +0,0 @@
-import { inject, Service, signal } from '@angular/core';
-import { catchError, firstValueFrom, forkJoin, of } from 'rxjs';
-
-import { ApiService } from './api.service';
-import type { ResourceEndpoints } from '../models/schema.model';
-
-/**
- * Servicio global de configuración: reúne los singletons declarativos y los
- * deja disponibles para interpolación de plantillas (enlaces públicos,
- * mensajes para compartir).
- *
- * Es genérico a propósito: NO conoce ningún singleton concreto. Los
- * endpoints los inyecta `app.config.ts` con `provideAppInitializer`,
- * derivándolos del registry — agregar un singleton de configuración nuevo
- * = declarar su schema, sin tocar este fichero (refactormotor.md §1 — el
- * schema es el único plano de control).
- *
- * No hay efectos en el constructor: la carga es explícita (`load`), así un
- * TestBed que sólo provee un ApiService parcial no recibe una llamada
- * síncrona a `get` durante la construcción.
- */
-@Service()
-export class ConfigService {
-  private readonly api = inject(ApiService, { optional: true });
-
-  /** Mapa reactivo de configuración global (p. ej. `public_base_url`). */
-  readonly globalConfig = signal<Record<string, unknown>>({
-    // Fallback genérico: el origen actual. Lo que declare el singleton
-    // (p. ej. `share_message_template`) lo pone el backend, no el front.
-    public_base_url: typeof window !== 'undefined' ? window.location.origin : '',
-  });
-
-  /** Endpoints conocidos; los guarda `load` para que `ensureLoaded` pueda reintentar. */
-  private endpoints: readonly ResourceEndpoints[] = [];
-
-  /**
-   * `true` cuando la última carga terminó SIN fallos. Si algún singleton
-   * falló (o ninguno respondió), queda `false` y el próximo punto crítico
-   * vuelve a intentar: no hay estado «cargado a medias para siempre».
-   */
-  private loaded = false;
-
-  /** Carga en curso: `ensureLoaded` la reutiliza en vez de duplicar viajes. */
-  private inFlight: Promise<void> | null = null;
-
-  /**
-   * Carga todos los endpoints de configuración recibidos. Silenciosa: un
-   * singleton que falle o que devuelva vacío no rompe nada, simplemente no
-   * aporta claves (y deja `loaded = false` para poder reintentar).
-   */
-  load(endpoints: readonly ResourceEndpoints[]): void {
-    this.endpoints = endpoints;
-    void this.ensure();
-  }
-
-  /**
-   * Garantiza la config global antes de un punto que la necesita.
-   *
-   * El load del bootstrap NO es bloqueante y sólo intenta una vez: si la app
-   * arrancó sin sesión (el 401 de los singletons se traga en el `catchError`)
-   * o la red tardó, la sesión seguía con la config vacía y, por ejemplo, el
-   * mensaje de `copy-share` degradaba a «sólo la URL» (R8.7). Acá el reintento
-   * corre con la sesión ya iniciada y responde bien; si ya se cargó, es un
-   * no-op síncrono.
-   */
-  ensureLoaded(): Promise<void> {
-    return this.ensure();
-  }
-
-  private ensure(): Promise<void> {
-    if (this.loaded) return Promise.resolve();
-    if (this.inFlight) return this.inFlight;
-    if (!this.api || typeof this.api.get !== 'function' || this.endpoints.length === 0) {
-      return Promise.resolve();
-    }
-
-    this.inFlight = firstValueFrom(
-      forkJoin(
-        this.endpoints.map((endpoint) =>
-          this.api!.get<Record<string, unknown>>(endpoint).pipe(
-            // `null` marca el fallo: con `of({})` un singleton caído era
-            // indistinguible de uno realmente vacío y la carga quedaría
-            // «hecha» sin datos.
-            catchError(() => of(null)),
-          ),
-        ),
-      ),
-    ).then((blocks) => {
-      this.inFlight = null;
-      blocks.forEach((data) => {
-        if (data && typeof data === 'object' && Object.keys(data).length > 0) {
-          this.globalConfig.update((current) => ({ ...current, ...data }));
-        }
-      });
-      this.loaded = blocks.every((data) => data !== null);
-    });
-
-    return this.inFlight;
-  }
-
-  /**
-   * Contexto de datos para interpolar plantillas del schema
-   * (`urlTemplate`, `shareTextTemplate`, `postCreate.description`, …).
-   *
-   * Sólo aporta datos y la base pública — la FORMA de la URL pública
-   * (`/p/{ref}`) la declara el propio schema en su `urlTemplate`; este
-   * servicio no decide cómo se arma el enlace.
-   */
-  buildInterpolationContext(record: Record<string, unknown>): Record<string, unknown> {
-    const config = this.globalConfig();
-    const baseUrl = String(config['public_base_url'] || window.location.origin).replace(/\/+$/, '');
-
-    return {
-      ...config,
-      ...record,
-      public_base_url: baseUrl,
-    };
-  }
-}

package/src/lib/core/services/data-source.service.spec.ts

@@ -1,179 +0,0 @@
-import { testCatalog } from '../testing/test-catalog';
-
-setSchemaCatalog(testCatalog);
-
-import { TestBed } from '@angular/core/testing';
-import { of, throwError } from 'rxjs';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type { DataSource } from '../models/schema.model';
-import { getSchema, setSchemaCatalog } from '../registry/schema-catalog';
-import { ApiService } from './api.service';
-import { DataSourceService, dataSourceKey, interpolateParams } from './data-source.service';
-
-/** Filas mínimas: el motor no impone forma a las columnas. */
-const FILAS = [
-  { slug: 'bebidas', name: 'Bebidas', active: true },
-  { slug: 'pan', name: 'Pan', active: false },
-];
-
-describe('DataSourceService', () => {
-  const listSpy = vi.fn();
-
-  beforeEach(async () => {
-    listSpy.mockReset();
-    listSpy.mockImplementation(() => of([...FILAS]));
-    await TestBed.configureTestingModule({
-      providers: [{ provide: ApiService, useValue: { list: listSpy } }],
-    }).compileComponents();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  const ds = (): DataSourceService => TestBed.inject(DataSourceService);
-
-  // ── interpolateParams ──────────────────────────────────────────────────
-
-  describe('interpolateParams', () => {
-    it('resuelve {campo} contra el contexto', () => {
-      expect(interpolateParams({ categoria: '{slug}' }, { slug: 'bebidas' })).toEqual({
-        categoria: 'bebidas',
-      });
-    });
-
-    it("un valor que se resuelve vacío se OMITE (no viaja `''`)", () => {
-      // Mandar `''` haría que el back comparara contra filas realmente
-      // vacías: el parámetro ausente es fail-closed, el vacío no.
-      expect(interpolateParams({ categoria: '{slug}', origen: 'manual' }, {})).toEqual({
-        origen: 'manual',
-      });
-      expect(interpolateParams({ categoria: '{slug}' }, { slug: null })).toEqual({});
-    });
-
-    it('sin params devuelve objeto vacío y no explota con contexto ausente', () => {
-      expect(interpolateParams(undefined)).toEqual({});
-      expect(interpolateParams({ categoria: '{slug}' })).toEqual({});
-    });
-  });
-
-  // ── dataSourceKey ──────────────────────────────────────────────────────
-
-  describe('dataSourceKey', () => {
-    const base: DataSource = { resource: 'categories', view: 'activos' };
-
-    it('la clave es resource|view|params con las claves ordenadas', () => {
-      expect(dataSourceKey({ ...base, params: { b: '2', a: '1' } })).toBe(
-        'categories|activos|a=1&b=2',
-      );
-      // Mismo pedido, distinto orden de escritura ⇒ MISMA entrada de caché.
-      expect(dataSourceKey({ ...base, params: { a: '1', b: '2' } })).toBe(
-        dataSourceKey({ ...base, params: { b: '2', a: '1' } }),
-      );
-    });
-
-    it('un {campo} que cambia es OTRA clave', () => {
-      const source: DataSource = { resource: 'orders', params: { cliente: '{dni}' } };
-      expect(dataSourceKey(source, { dni: '1' })).not.toBe(dataSourceKey(source, { dni: '2' }));
-    });
-
-    it('una view distinta es otra clave; sin view queda el hueco', () => {
-      expect(dataSourceKey({ resource: 'categories' })).toBe('categories||');
-      expect(dataSourceKey({ resource: 'categories', view: 'activos' })).toBe(
-        'categories|activos|',
-      );
-    });
-  });
-
-  // ── rows: payload, caché y errores ─────────────────────────────────────
-
-  describe('rows', () => {
-    const source: DataSource = { resource: 'categories', view: 'activos' };
-
-    it('pide el endpoint del recurso con { view, params } declarados', async () => {
-      await ds().rows({ ...source, params: { orden: 'asc' } });
-      expect(listSpy).toHaveBeenCalledTimes(1);
-      // El servicio resuelve el id contra el registry y manda SU endpoint:
-      // el componente nunca arma una URL.
-      expect(listSpy).toHaveBeenCalledWith(getSchema('categories')!.endpoint, {
-        view: 'activos',
-        params: { orden: 'asc' },
-      });
-    });
-
-    it('sin view ni params manda payload vacío (lectura llana)', async () => {
-      await ds().rows({ resource: 'categories' });
-      expect(listSpy).toHaveBeenCalledWith(getSchema('categories')!.endpoint, {});
-    });
-
-    it('la misma clave se pide UNA vez (caché por resource+view+params)', async () => {
-      await ds().rows(source);
-      await ds().rows(source);
-      await ds().rows({ resource: 'categories', view: 'activos' });
-      expect(listSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('parámetros resueltos distintos ⇒ otra vuelta', async () => {
-      const conParam: DataSource = { resource: 'orders', params: { cliente: '{dni}' } };
-      await ds().rows(conParam, { dni: '1' });
-      await ds().rows(conParam, { dni: '2' });
-      expect(listSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it('`fresh` salta la caché (recarga tras una escritura)', async () => {
-      await ds().rows(source);
-      await ds().rows(source, undefined, true);
-      expect(listSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it('pasado el TTL vuelve a pedir (frescura, no inmortalidad)', async () => {
-      vi.useFakeTimers();
-      await ds().rows(source);
-      vi.advanceTimersByTime(30_001);
-      await ds().rows(source);
-      expect(listSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it('un error NO queda cacheado: el siguiente intento vuelve a pedir', async () => {
-      listSpy.mockImplementationOnce(() => throwError(() => new Error('503')));
-      await expect(ds().rows(source)).rejects.toThrow('503');
-      await ds().rows(source);
-      expect(listSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it('una respuesta que no es lista llega como [] (el consumidor decide)', async () => {
-      listSpy.mockImplementationOnce(() => of({ items: FILAS }));
-      await expect(ds().rows(source)).resolves.toEqual([]);
-    });
-
-    it('un id inexistente es error de configuración y NO pide a la red', async () => {
-      await expect(ds().rows({ resource: 'fantasma' })).rejects.toThrow(
-        'Recurso desconocido: fantasma',
-      );
-      expect(listSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  // ── invalidate ─────────────────────────────────────────────────────────
-
-  describe('invalidate', () => {
-    it('sin argumento vacía toda la caché', async () => {
-      await ds().rows({ resource: 'categories' });
-      await ds().rows({ resource: 'products' });
-      ds().invalidate();
-      await ds().rows({ resource: 'categories' });
-      await ds().rows({ resource: 'products' });
-      expect(listSpy).toHaveBeenCalledTimes(4);
-    });
-
-    it('con resourceId sólo tira las de ESE recurso (prefijo de clave)', async () => {
-      await ds().rows({ resource: 'categories' });
-      await ds().rows({ resource: 'products' });
-      ds().invalidate('categories');
-      await ds().rows({ resource: 'categories' });
-      await ds().rows({ resource: 'products' });
-      expect(listSpy).toHaveBeenCalledTimes(3);
-    });
-  });
-});

package/src/lib/core/services/data-source.service.ts

@@ -1,142 +0,0 @@
-import { inject, Service } from '@angular/core';
-import { firstValueFrom } from 'rxjs';
-
-import type { DataSource } from '../models/schema.model';
-import { interpolateTemplate } from '../utils/template-interpolator';
-import { getSchema } from '../registry/schema-catalog';
-import { ApiService } from './api.service';
-
-/** Fila cruda de un listado: el motor no impone forma a las columnas. */
-export type SourceRow = Record<string, unknown>;
-
-/**
- * Cuánto se reutiliza una respuesta pedida igual (F8 · R6.5).
- *
- * Un panel de administración lee mucho y escribe poco: medio minuto de
- * frescura cubre un recorrido por varios formularios sin repetir la misma
- * vuelta. Es una decisión de UX, no de contrato — `invalidate()` la salta
- * cuando el usuario acaba de crear lo que la fuente lista.
- */
-const TTL_MS = 30_000;
-
-/** Techo de claves cacheadas: un Map sin límite es una fuga en una sesión larga. */
-const MAX_CLAVES = 100;
-
-/**
- * `source.params` con cada `{campo}` resuelto contra `ctx`.
- *
- * - Un valor que se resuelve **vacío se OMITE** en vez de mandar `''`: el
- *   back distingue «parámetro ausente» (fail-closed ⇒ sin filas) de un
- *   `eq ''` que podría cruzarse con filas realmente vacías.
- * - Un parámetro sin marcador `{}` es literal y viaja tal cual.
- */
-export function interpolateParams(
-  params: Record<string, string> | undefined,
-  ctx?: Record<string, unknown>,
-): Record<string, string> {
-  const out: Record<string, string> = {};
-  if (params === undefined) return out;
-  for (const name of Object.keys(params)) {
-    const raw = params[name];
-    const value = interpolateTemplate(raw, ctx ?? {});
-    if (value !== '') out[name] = value;
-  }
-  return out;
-}
-
-/**
- * Clave de caché de una fuente: `resource|view|params` (F8 · R6.5).
- *
- * Los parámetros van **resueltos** y ordenados, así que dos fuentes que
- * terminan pidiendo lo mismo comparten entrada, y un `{campo}` que cambia
- * es otra entrada. Pura: es también el valor que `resource({ params })` de
- * Angular compara para decidir si vuelve a cargar.
- */
-export function dataSourceKey(source: DataSource, ctx?: Record<string, unknown>): string {
-  const params = interpolateParams(source.params, ctx);
-  const names = Object.keys(params).sort();
-  const query = names
-    .map((name) => `${encodeURIComponent(name)}=${encodeURIComponent(params[name])}`)
-    .join('&');
-  return `${source.resource}|${source.view ?? ''}|${query}`;
-}
-
-/**
- * Fetcher único de `source` (F8 · R6.5): relations, selects y widgets del
- * panel piden sus filas ACÁ y no cada uno desde su componente.
- *
- * - **Caché por `resource+view+params`** con TTL e invalidación explícita —
- *   es la pieza que evita que seis widgets del panel disparen seis vueltas
- *   iguales a la misma vista.
- * - **Deduplicación de vuelta en vuelo**: dos consumidores que pidan la misma
- *   clave en el mismo ciclo comparten la promesa (no la respuesta, la vuelta).
- * - Un error **no queda cacheado**: se borra la entrada para que la recarga
- *   del consumidor vuelva a intentarlo en vez de devolver siempre la misma
- *   rechazada.
- */
-@Service()
-export class DataSourceService {
-  private readonly api = inject(ApiService);
-
-  private readonly cache = new Map<string, { promise: Promise<SourceRow[]>; at: number }>();
-
-  /**
-   * Filas de la fuente declarada.
-   *
-   * `fresh` salta la caché (recarga tras una escritura); `ctx` sólo se usa
-   * para resolver `{campo}` en `params` y no cambia la forma de la respuesta.
-   */
-  async rows(
-    source: DataSource,
-    ctx?: Record<string, unknown>,
-    fresh = false,
-  ): Promise<SourceRow[]> {
-    const key = dataSourceKey(source, ctx);
-    if (!fresh) {
-      const hit = this.cache.get(key);
-      if (hit !== undefined && Date.now() - hit.at < TTL_MS) return hit.promise;
-    }
-    const promise = this.fetch(source, ctx).catch((error: unknown) => {
-      this.cache.delete(key);
-      throw error;
-    });
-    this.cache.set(key, { promise, at: Date.now() });
-    if (this.cache.size > MAX_CLAVES) {
-      // El Map conserva el orden de inserción: sale la más vieja.
-      const oldest = this.cache.keys().next();
-      if (!oldest.done) this.cache.delete(oldest.value);
-    }
-    return promise;
-  }
-
-  /**
-   * Vacía las filas ya pedidas. Sin argumento, todas; con un `resourceId`,
-   * sólo las de ese recurso (lo que acaba de crear el drawer de relación).
-   */
-  invalidate(resourceId?: string): void {
-    if (resourceId === undefined) {
-      this.cache.clear();
-      return;
-    }
-    const prefix = `${resourceId}|`;
-    for (const key of [...this.cache.keys()]) {
-      if (key.startsWith(prefix)) this.cache.delete(key);
-    }
-  }
-
-  private async fetch(source: DataSource, ctx?: Record<string, unknown>): Promise<SourceRow[]> {
-    const target = getSchema(source.resource);
-    if (!target) {
-      // Un id que ni siquiera existe en el registry es error de
-      // configuración, no de red: el consumidor lo pinta como «no se
-      // pudieron cargar» con este texto.
-      throw new Error(`Recurso desconocido: ${source.resource}`);
-    }
-    const payload: Record<string, unknown> = {};
-    if (source.view !== undefined && source.view !== '') payload['view'] = source.view;
-    const params = interpolateParams(source.params, ctx);
-    if (Object.keys(params).length > 0) payload['params'] = params;
-    const rows = await firstValueFrom(this.api.list<SourceRow>(target.endpoint, payload));
-    return Array.isArray(rows) ? rows : [];
-  }
-}

package/src/lib/core/services/error-mapper.service.spec.ts

@@ -1,50 +0,0 @@
-import { ApiError } from '../models/api.model';
-import { ErrorMapperService } from './error-mapper.service';
-
-/**
- * D42 — el422 con `errors[]` tiene que llegar PINTADO campo a campo.
- *
- * La clave que devuelve `map` es exactamente la que después resuelve el
- * host como `serverErrors[prefix + key]` (render-host:529), así que aquí se
- * comprueba la forma entera: varias rutas a la vez, el fallback a `general`
- * cuando ninguna ruta es pintable y el caso viejo del `path` del sobre.
- */
-describe('ErrorMapperService — errores de validación con ruta', () => {
-  const mapper = new ErrorMapperService();
-
-  it('varios issues con ruta → un campo por ruta, con su mensaje', () => {
-    const error = new ApiError(422, 'Errores de validación', undefined, undefined, [
-      { path: 'sku', message: 'Debe tener al menos 5 caracteres.', code: 'VALIDATION_MIN_LENGTH' },
-      { path: 'faq[2].answer', message: 'Campo obligatorio.', code: 'VALIDATION_REQUIRED' },
-    ]);
-    expect(mapper.map(error)).toEqual({
-      fields: {
-        sku: 'Debe tener al menos 5 caracteres.',
-        'faq[2].answer': 'Campo obligatorio.',
-      },
-    });
-  });
-
-  it('sin ninguna ruta pintable, el mensaje del sobre queda en general', () => {
-    const sinRutas = new ApiError(422, 'Errores de validación', undefined, undefined, [
-      { path: '', message: 'Esto no es pintable' },
-    ]);
-    expect(mapper.map(sinRutas)).toEqual({ fields: {}, general: 'Errores de validación' });
-
-    const sinIssues = new ApiError(409, 'El registro cambió o ya existe.');
-    expect(mapper.map(sinIssues)).toEqual({
-      fields: {},
-      general: 'El registro cambió o ya existe.',
-    });
-  });
-
-  it('conserva el caso viejo: `path` suelto en el sobre → un campo', () => {
-    const error = new ApiError(422, 'Ya existe un registro con este valor', 'name');
-    expect(mapper.map(error)).toEqual({ fields: { name: 'Ya existe un registro con este valor' } });
-  });
-
-  it('un error que no es de la API cae en general', () => {
-    expect(mapper.map(new Error('boom'))).toEqual({ fields: {}, general: 'boom' });
-    expect(mapper.map('¿esto?')).toEqual({ fields: {}, general: 'Error inesperado' });
-  });
-});

package/src/lib/core/services/error-mapper.service.ts

@@ -1,49 +0,0 @@
-import { Service } from '@angular/core';
-
-import { ApiError } from '../models/api.model';
-
-export interface MappedError {
-  /** Errores por ruta de campo (ej. `faq[2].answer`); se pintan en el campo exacto. */
-  fields: Record<string, string>;
-  /** Mensaje general; presente cuando el error no tiene ruta de campo (base.md §10). */
-  general?: string;
-}
-
-/**
- * Convierte un error recibido en el formato que consume la UI:
- * rutas de campo para pintar el error donde corresponde, o mensaje general.
- *
- * Un422 trae VARIOS issues con ruta (`error.errors[]`, auth.md §6); cada uno
- * se convierte en `fields[path] = mensaje`, que es exactamente la clave que
- * después resuelve el host como `serverErrors[prefix + key]`. Si al final no
- * hay ninguna ruta pintable (error sin `errors[]`, issue sin `path`), el
- * mensaje del sobre queda en `general` como hasta ahora (base.md §10).
- */
-@Service()
-export class ErrorMapperService {
-  map(error: unknown): MappedError {
-    if (error instanceof ApiError) {
-      const fields: Record<string, string> = {};
-      for (const issue of error.issues) {
-        if (issue.path) {
-          fields[issue.path] = issue.message;
-        }
-      }
-      // Sobre con `path` suelto (sin `errors[]`): misma historia, un campo.
-      if (error.fieldPath && fields[error.fieldPath] === undefined) {
-        fields[error.fieldPath] = error.message;
-      }
-      if (Object.keys(fields).length > 0) {
-        return { fields };
-      }
-    }
-    return { fields: {}, general: this.messageOf(error) };
-  }
-
-  messageOf(error: unknown): string {
-    if (error instanceof Error) {
-      return error.message;
-    }
-    return 'Error inesperado';
-  }
-}

package/src/lib/core/services/notification.service.ts

@@ -1,73 +0,0 @@
-import { Service, signal } from '@angular/core';
-
-export type ToastKind = 'success' | 'error' | 'info';
-
-export interface Toast {
-  id: number;
-  kind: ToastKind;
-  message: string;
-}
-
-export interface ConfirmOptions {
-  title: string;
-  message: string;
-  confirmLabel?: string;
-  cancelLabel?: string;
-}
-
-/**
- * Notificaciones de la app: toasts (señales, se renderizan en `app-toast`,
- * Fase 5) y un diálogo de confirmación con respuesta como `Promise`
- * (base.md §10: borrado con confirmación, aviso de cambios sin guardar).
- */
-@Service()
-export class NotificationService {
-  readonly toasts = signal<Toast[]>([]);
-  /** Confirmación en curso; `null` = sin diálogo. */
-  readonly confirmation = signal<ConfirmOptions | null>(null);
-
-  private nextId = 1;
-  private pendingResolve: ((accepted: boolean) => void) | null = null;
-
-  success(message: string): void {
-    this.push('success', message);
-  }
-
-  error(message: string): void {
-    this.push('error', message);
-  }
-
-  info(message: string): void {
-    this.push('info', message);
-  }
-
-  dismiss(id: number): void {
-    this.toasts.update((toasts) => toasts.filter((toast) => toast.id !== id));
-  }
-
-  /** Abre el diálogo de confirmación y espera la respuesta del usuario. */
-  confirm(options: ConfirmOptions): Promise<boolean> {
-    // Solo una confirmación a la vez: la anterior se responde como rechazo.
-    this.pendingResolve?.(false);
-    this.confirmation.set(options);
-    return new Promise<boolean>((resolve) => {
-      this.pendingResolve = resolve;
-    });
-  }
-
-  /** Resuelve la confirmación pendiente (lo llama el componente de diálogo, Fase 5). */
-  resolveConfirmation(accepted: boolean): void {
-    this.confirmation.set(null);
-    const resolve = this.pendingResolve;
-    this.pendingResolve = null;
-    resolve?.(accepted);
-  }
-
-  private push(kind: ToastKind, message: string): void {
-    const id = this.nextId++;
-    this.toasts.update((toasts) => [...toasts, { id, kind, message }]);
-    if (kind !== 'error') {
-      setTimeout(() => this.dismiss(id), 4000);
-    }
-  }
-}

package/src/lib/core/services/relation-drawer.service.ts

@@ -1,41 +0,0 @@
-import { Service, signal } from '@angular/core';
-
-/** Pedido de «Crear nuevo» lanzado desde el dropdown de una relación. */
-export interface RelationCreateRequest {
-  /** Recurso a crear (el `source.resource` de la relación). */
-  resource: string;
-  /**
-   * Se invoca con la clave recién creada. Vive en la relación porque es ella
-   * la que tiene que recargar sus opciones y preseleccionar el valor.
-   */
-  onCreated: (key: string) => void;
-}
-
-/**
- * Puente entre el control `relation` y el drawer que abre el formulario.
- *
- * Existe como señal inyectable y NO como un `output()` encadenado porque el
- * camino directo — `relation → DrawerForm → FieldHost → relation` — arma un
- * ciclo de imports de módulos: `field-host` se decoraría con
- * `FieldRelation === undefined` y Angular tiraría `Cannot read properties of
- * undefined (reading 'ɵcmp')`. El campo no puede importar un componente que,
- * a su vez, lo importa a él.
- *
- * Sólo hay un drawer a la vez, así que una única señal alcanza: quien lo
- * abre lo cierra con `clear()` al recibir `close`/`saved`.
- */
-@Service()
-export class RelationDrawerService {
-  private readonly pending = signal<RelationCreateRequest | null>(null);
-
-  /** Pedido en curso; `null` cuando no hay panel abierto. */
-  readonly request = this.pending.asReadonly();
-
-  open(resource: string, onCreated: (key: string) => void): void {
-    this.pending.set({ resource, onCreated });
-  }
-
-  clear(): void {
-    this.pending.set(null);
-  }
-}