ngx-essentials-schematics 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-essentials-schematics",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "A collection of Angular schematics for essential functionalities.",
   "main": "dist/index.js",
   "scripts": {
@@ -24,11 +24,13 @@
   "dependencies": {
     "@angular-devkit/core": "^20.3.13",
     "@angular-devkit/schematics": "^20.3.13",
+    "pluralize": "^8.0.0",
     "typescript": "~5.9.2"
   },
   "devDependencies": {
     "@types/jasmine": "~5.1.0",
     "@types/node": "^20.17.19",
+    "@types/pluralize": "^0.0.33",
     "copyfiles": "^2.4.1",
     "jasmine": "^5.0.0"
   }

package/src/ngrx/store/files/entity/entity.model.ts.template

@@ -0,0 +1,16 @@
+export interface EntityStatus {
+  addError?: Error | null;
+  addLoading?: boolean;
+  deleteError?: Error | null;
+  deleteLoading?: boolean;
+  error: Error | null;
+  idsDeleting?: (number | string)[];
+  idSelected?: null | number | string;
+  idsUpdating?: (number | string)[];
+  loaded: boolean;
+  loading: boolean;
+  selectedError?: Error | null;
+  selectedLoading?: boolean;
+  updateError?: Error | null;
+  updateLoading?: boolean;
+}

package/src/ngrx/store/files/form/form.model.ts.template

@@ -0,0 +1,4 @@
+import { FormControl } from '@angular/forms';
+export type FormGroupType<T> = {
+  [K in keyof T]: FormControl<T[K]>;
+};

package/src/ngrx/store/files/store/__name@dasherize__.model.ts.template

@@ -0,0 +1,16 @@
+import { FormGroupType } from '../common/form/form.model';
+
+export interface Add<%= classify(name) %> {
+  nombre: string;
+  descripcion?: string;
+}
+
+export type Add<%= classify(name) %>Form = FormGroupType<Add<%= classify(name) %>>;
+
+export interface <%= classify(name) %>Dto {
+  cod: number;
+  nombre: string;
+  descripcion?: string;
+}
+
+export type Update<%= classify(name) %> = Partial<<%= classify(name) %>Dto> & Pick<<%= classify(name) %>Dto, 'cod'>;

package/src/ngrx/store/files/store/__name@dasherize__.service.ts.template

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { Observable, of } from 'rxjs';
+import {
+  Add<%= classify(name) %>,
+  <%= classify(name) %>Dto,
+  Update<%= classify(name) %>
+} from './<%= dasherize(name) %>.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class <%= classify(name) %>Service {
+
+  add<%= classify(name) %>$(entity: Add<%= classify(name) %>): Observable<number> {
+    return of(0);
+  }
+
+  delete<%= classify(name) %>$(cod: number): Observable<boolean> {
+    return of(true);
+  }
+
+  get<%= classify(pluralize(name)) %>$(): Observable<<%= classify(name) %>Dto[]> {
+    return of([]);
+  }
+
+  update<%= classify(name) %>$(entity: Update<%= classify(name) %>): Observable<boolean> {
+    return of(true);
+  }
+}

package/src/ngrx/store/files/store/__name@dasherize__.store.ts.template

@@ -0,0 +1,212 @@
+import { computed, inject } from '@angular/core';
+import { patchState, signalStore, type, withComputed, withHooks, withMethods, withState } from '@ngrx/signals';
+import {
+  addEntity,
+  entityConfig,
+  removeEntity,
+  setAllEntities,
+  updateEntity,
+  withEntities
+} from '@ngrx/signals/entities';
+import { rxMethod } from '@ngrx/signals/rxjs-interop';
+import { catchError, of, pipe, switchMap, tap } from 'rxjs';
+
+import { EntityStatus } from '../common/entity/entity.model';
+import {
+  <%= classify(name) %>Dto,
+  Add<%= classify(name) %>,
+  Update<%= classify(name) %>
+} from './<%= dasherize(name) %>.model';
+import { <%= classify(name) %>Service } from './<%= dasherize(name) %>.service';
+
+const initialStatus: EntityStatus = {
+  error: null,
+  loaded: false,
+  loading: false,
+};
+
+const <%= camelize(name) %>EntitiesConfig = entityConfig({
+  collection: '<%= camelize(name) %>',
+  entity: type<<%= classify(name) %>Dto>(),
+  selectId: (entity) => entity.cod,
+});
+
+export const <%= classify(name) %>Store = signalStore(
+  { providedIn: 'root' },
+  withEntities(<%= camelize(name) %>EntitiesConfig),
+  withState({
+    <%= camelize(name) %>Status: initialStatus,
+  }),
+  withComputed(({ <%= camelize(name) %>EntityMap, <%= camelize(name) %>Status }) => ({
+    <%= camelize(name) %>Seleccionado: computed(() => {
+      const id = <%= camelize(name) %>Status().idSelected;
+      return id ? <%= camelize(name) %>EntityMap()[id] : null;
+    }),
+    <%= camelize(pluralize(name)) %>: computed(() => Object.values(<%= camelize(name) %>EntityMap())),
+    loading<%= classify(pluralize(name)) %>: computed(() => <%= camelize(name) %>Status().loading),
+    loadingRemove<%= classify(name) %>: computed(
+      () => (cod?: number) =>
+        (cod ? <%= camelize(name) %>Status().idsDeleting?.includes(cod) : <%= camelize(name) %>Status().deleteLoading) || false
+    ),
+    loadingUpdate<%= classify(name) %>: computed(
+      () => (cod?: number) =>
+        (cod ? <%= camelize(name) %>Status().idsUpdating?.includes(cod) : <%= camelize(name) %>Status().updateLoading) || false
+    ),
+  })),
+  withMethods((store, <%= camelize(name) %>Service = inject(<%= classify(name) %>Service)) => ({
+    add<%= classify(name) %>: rxMethod<Add<%= classify(name) %>>(
+      pipe(
+        tap(() => {
+          patchState(store, { <%= camelize(name) %>Status: { ...store.<%= camelize(name) %>Status(), addLoading: true } });
+        }),
+        switchMap((entity) => {
+          return <%= camelize(name) %>Service.add<%= classify(name) %>$(entity).pipe(
+            tap((cod) => {
+              patchState(store, addEntity({ ...entity, cod }, <%= camelize(name) %>EntitiesConfig), {
+                <%= camelize(name) %>Status: {
+                  ...store.<%= camelize(name) %>Status(),
+                  addLoading: false,
+                  error: null,
+                },
+              });
+            }),
+            catchError(() => {
+              patchState(store, {
+                <%= camelize(name) %>Status: {
+                  ...store.<%= camelize(name) %>Status(),
+                  addLoading: false,
+                  error: new Error('Error al agregar <%= name %>'),
+                },
+              });
+              return of(entity);
+            })
+          );
+        })
+      )
+    ),
+    load<%= classify(pluralize(name)) %>: rxMethod<void>(
+      pipe(
+        tap(() => {
+          patchState(store, { <%= camelize(name) %>Status: { ...store.<%= camelize(name) %>Status(), loading: true } });
+        }),
+        switchMap(() => {
+          return <%= camelize(name) %>Service.get<%= classify(pluralize(name)) %>$().pipe(
+            tap((response) => {
+              patchState(store, setAllEntities(response, <%= camelize(name) %>EntitiesConfig), {
+                <%= camelize(name) %>Status: {
+                  ...store.<%= camelize(name) %>Status(),
+                  error: null,
+                  loaded: true,
+                  loading: false,
+                },
+              });
+            }),
+            catchError(() => {
+              patchState(store, {
+                <%= camelize(name) %>Status: {
+                  ...store.<%= camelize(name) %>Status(),
+                  error: new Error('Error al cargar <%= pluralize(name) %>'),
+                  loading: false,
+                },
+              });
+              return of([]);
+            })
+          );
+        })
+      )
+    ),
+    remove<%= classify(name) %>: rxMethod<number>(
+      pipe(
+        tap((cod) => {
+          patchState(store, {
+            <%= camelize(name) %>Status: {
+              ...store.<%= camelize(name) %>Status(),
+              deleteLoading: true,
+              idsDeleting: [...(store.<%= camelize(name) %>Status().idsDeleting || []), cod],
+            },
+          });
+        }),
+        switchMap((cod) => {
+          return <%= camelize(name) %>Service.delete<%= classify(name) %>$(cod).pipe(
+            tap((success) => {
+              if (success) {
+                const idsDeleting = store.<%= camelize(name) %>Status().idsDeleting || [];
+                patchState(store, removeEntity(cod, <%= camelize(name) %>EntitiesConfig), {
+                  <%= camelize(name) %>Status: {
+                    ...store.<%= camelize(name) %>Status(),
+                    deleteLoading: false,
+                    error: null,
+                    idsDeleting: idsDeleting.filter((id) => id !== cod),
+                  },
+                });
+              } else {
+                throw new Error('Error al eliminar <%= name %>');
+              }
+            }),
+            catchError(() => {
+              const idsDeleting = store.<%= camelize(name) %>Status().idsDeleting || [];
+              patchState(store, {
+                <%= camelize(name) %>Status: {
+                  ...store.<%= camelize(name) %>Status(),
+                  deleteLoading: false,
+                  error: new Error('Error al eliminar <%= name %>'),
+                  idsDeleting: idsDeleting.filter((id) => id !== cod),
+                },
+              });
+              return of(false);
+            })
+          );
+        })
+      )
+    ),
+    update<%= classify(name) %>: rxMethod<Update<%= classify(name) %>>(
+      pipe(
+        tap((entity) => {
+          patchState(store, {
+            <%= camelize(name) %>Status: {
+              ...store.<%= camelize(name) %>Status(),
+              idsUpdating: [...(store.<%= camelize(name) %>Status().idsUpdating || []), entity.cod],
+              updateLoading: true,
+            },
+          });
+        }),
+        switchMap((entity) => {
+          return <%= camelize(name) %>Service.update<%= classify(name) %>$(entity).pipe(
+            tap((success) => {
+              if (success) {
+                const idsUpdating = store.<%= camelize(name) %>Status().idsUpdating || [];
+                patchState(store, updateEntity({ changes: entity, id: entity.cod }, <%= camelize(name) %>EntitiesConfig), {
+                  <%= camelize(name) %>Status: {
+                    ...store.<%= camelize(name) %>Status(),
+                    error: null,
+                    idsUpdating: idsUpdating.filter((id) => id !== entity.cod),
+                    updateLoading: false,
+                  },
+                });
+              } else {
+                throw new Error('Error al actualizar <%= name %>');
+              }
+            }),
+            catchError(() => {
+              const idsUpdating = store.<%= camelize(name) %>Status().idsUpdating || [];
+              patchState(store, {
+                <%= camelize(name) %>Status: {
+                  ...store.<%= camelize(name) %>Status(),
+                  error: new Error('Error al actualizar <%= name %>'),
+                  idsUpdating: idsUpdating.filter((id) => id !== entity.cod),
+                  updateLoading: false,
+                },
+              });
+              return of(false);
+            })
+          );
+        })
+      )
+    ),
+  })),
+  withHooks({
+    onInit: (store) => {
+      store.load<%= classify(pluralize(name)) %>();
+    },
+  })
+);

package/src/ngrx/store/index.d.ts

@@ -1,5 +1,5 @@
-import { Rule } from '@angular-devkit/schematics';
-import { SchemaOptions } from './schema';
+import { Rule } from "@angular-devkit/schematics";
+import { SchemaOptions } from "./schema";
 /**
  * Genera un Signal Store profesional para Angular 20
  * @param {SchemaOptions} options - Opciones del esquema

package/src/ngrx/store/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.signalStore = signalStore;
 const core_1 = require("@angular-devkit/core");
 const schematics_1 = require("@angular-devkit/schematics");
+const pluralize = require("pluralize");
 /**
  * Genera un Signal Store profesional para Angular 20
  * @param {SchemaOptions} options - Opciones del esquema
@@ -10,10 +11,10 @@ const schematics_1 = require("@angular-devkit/schematics");
  */
 function signalStore(options) {
     return (tree) => {
-        const movePath = (0, core_1.normalize)(options.path || 'src/app/state');
-        // 1. Lógica para actualizar el index.ts (Barrel)
-        const indexPath = (0, core_1.join)(movePath, 'index.ts');
-        const exportLine = `export * from './${core_1.strings.dasherize(options.name)}.store';\n`;
+        const defaultPath = "src/app/core";
+        const movePath = (0, core_1.normalize)(options.path || defaultPath);
+        const indexPath = (0, core_1.join)(movePath, "index.ts");
+        const exportLine = `export * from './${core_1.strings.dasherize(options.name)}/${core_1.strings.dasherize(options.name)}.store';\n`;
         if (tree.exists(indexPath)) {
             const content = tree.read(indexPath).toString();
             if (!content.includes(exportLine)) {
@@ -23,9 +24,25 @@ function signalStore(options) {
         else {
             tree.create(indexPath, exportLine);
         }
-        // 2. Lógica de generación del archivo .store.ts
-        const templateSource = (0, schematics_1.apply)((0, schematics_1.url)('./files'), [(0, schematics_1.applyTemplates)(Object.assign(Object.assign({}, core_1.strings), options)), (0, schematics_1.move)(movePath)]);
-        return (0, schematics_1.chain)([(0, schematics_1.mergeWith)(templateSource)]);
+        const templateEntitySource = (0, schematics_1.apply)((0, schematics_1.url)("./files/entity"), [
+            (0, schematics_1.applyTemplates)(Object.assign(Object.assign(Object.assign({}, core_1.strings), options), { pluralize: (word) => {
+                    return pluralize(word);
+                } })),
+            (0, schematics_1.move)(defaultPath + "/common/entity"),
+        ]);
+        const templateFormSource = (0, schematics_1.apply)((0, schematics_1.url)("./files/form"), [
+            (0, schematics_1.applyTemplates)(Object.assign(Object.assign({}, core_1.strings), options)),
+            (0, schematics_1.move)(defaultPath + "/common/form"),
+        ]);
+        const templateStoreSource = (0, schematics_1.apply)((0, schematics_1.url)("./files/store"), [
+            (0, schematics_1.applyTemplates)(Object.assign(Object.assign({}, core_1.strings), options)),
+            (0, schematics_1.move)(movePath + `/${core_1.strings.dasherize(options.name)}`),
+        ]);
+        return (0, schematics_1.chain)([
+            (0, schematics_1.mergeWith)(templateStoreSource),
+            (0, schematics_1.mergeWith)(templateEntitySource),
+            (0, schematics_1.mergeWith)(templateFormSource),
+        ]);
     };
 }
 //# sourceMappingURL=index.js.map

package/src/ngrx/store/files/__name@dasherize__.store.ts.template

@@ -1,34 +0,0 @@
-import { signalStore, withState, withMethods, withComputed, patchState } from '@ngrx/signals';
-import { withEntities } from '@ngrx/signals/entities';
-import { computed } from '@angular/core';
-import { EntityStatus } from '@shared/models/common.model';
-
-export interface <%= classify(name) %> {
-  cod: number;
-}
-
-const initialStatus: EntityStatus = {
-  loading: false,
-  error: null,
-};
-
-export const <%= classify(name) %>Store = signalStore(
-  { providedIn: 'root' },
-  withEntities<<%= classify(name) %>>(),
-  withState({
-    status: initialStatus,
-    selectedId: null as number | null,
-  }),
-  withComputed(({ entityMap, selectedId }) => ({
-    selectedEntity: computed(() => {
-      const id = selectedId();
-      return id ? entityMap()[id] : null;
-    }),
-  })),
-  withMethods((store) => ({
-    setLoading: (loading: boolean) =>
-      patchState(store, (state) => ({ status: { ...state.status, loading } })),
-    setError: (error: string | null) =>
-      patchState(store, (state) => ({ status: { ...state.status, error, loading: false } })),
-  }))
-);