@barcidev/ngx-autogen 0.1.2 → 0.1.4

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

@@ -0,0 +1,200 @@
+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 { RequestConfig } from 'src/app/shared/state/entity.model';
+import { withPagination } from 'src/app/shared/state/with-entity-pagination';
+import { withEntityStatus } from 'src/app/shared/state/with-entity-status';
+iimport {
+  Add<%= classify(name) %>,
+  <%= classify(name) %>Dto,
+  Update<%= classify(name) %>
+} from '<%= grouped ? "./models/<%= dasherize(name) %>.model" : "./<%= dasherize(name) %>.model"';
+import { <%= classify(name) %>Service } from '<%= grouped ? "./services/./<%= dasherize(name) %>.service" : "./<%= dasherize(name) %>.service"';
+
+const config = entityConfig({
+  entity: type<<%= classify(name) %>Dto>(),
+  selectId: (entity) => entity.<%= pk %>,
+});
+
+export const <%= classify(name) %>Store = signalStore(
+  withEntities(config),
+  withEntityStatus(),
+  withPagination(),
+  withComputed(({ entities, entityMap, status: { idSelected } }) => ({
+    <%= camelize(pluralize(name)) %>: computed(() => entities()),
+    <%= camelize(name) %>Seleccionado: computed(() => {
+      const <%= pk %> = idSelected();
+      return <%= pk %> ? entityMap()[<%= pk %>] : null;
+    })
+  })),
+  withMethods((store, <%= camelize(name) %>Service = inject(<%= classify(name) %>Service)) => ({
+    add<%= classify(name) %>: rxMethod<RequestConfig<Add<%= classify(name) %>, <%= classify(name) %>Dto>>(
+      pipe(
+        tap(() => {
+          patchState(store, (state) => ({ status: { ...state.status, addLoading: true } }));
+        }),
+        switchMap(({ onError, onSuccess, payload: { request } }) => {
+          return <%= camelize(name) %>Service.add<%= classify(name) %>$(request).pipe(
+            tap((<%= pk %>) => {
+              const new<%= classify(name) %>: <%= classify(name) %>Dto = { ...request, <%= pk %>};
+              patchState(store, addEntity(new<%= classify(name) %>, config), (state) => ({
+                    ...state,
+                    status: { ...state.status, addError: null, addLoading: false }
+                  }));
+              if (onSuccess) {
+                onSuccess(newHorario);
+              }
+            }),
+            catchError(() => {
+              const error = new Error('');
+              patchState(store, (state) => ({
+                status: { ...state.status, addError: error, addLoading: false }
+              }));
+              if (onError) {
+                onError();
+              }
+              return EMPTY;
+            })
+          );
+        })
+      )
+    ),
+    load<%= classify(pluralize(name)) %>: rxMethod<void>(
+      pipe(
+        tap(() => {
+          patchState(store, (state) => ({ status: { ...state.status, loading: true } }));
+        }),
+        switchMap(() => {
+          return <%= camelize(name) %>Service.get<%= classify(pluralize(name)) %>$().pipe(
+            tap((response) => {
+              patchState(store, setAllEntities(response, config), (state) => ({
+                status: { ...state.status, error: null, loaded: true, loading: false }
+              }));
+            }),
+            catchError(() => {
+              patchState(store, (state) => ({
+                status: { ...state.status, error: new Error('Error al cargar horario-accesos'), loading: false }
+              }));
+              return EMPTY;
+            })
+          );
+        })
+      )
+    ),
+    remove<%= classify(name) %>: rxMethod<RequestConfig<number, boolean>>(
+      pipe(
+        tap(({ payload }) => {
+          patchState(store, (state) => ({
+            status: {
+              ...state.status,
+              _removeLoading: true,
+              idsRemoving: [...(state.status.idsRemoving || []), payload]
+            }
+          }));
+        }),
+        switchMap(({ onError, onSuccess, payload }) => {
+          return <%= camelize(name) %>Service.remove<%= classify(name) %>$(payload).pipe(
+            tap((response) => {
+              if (response) {
+                const idsRemoving = store.status.idsRemoving() || [];
+                patchState(store, removeEntity(payload), (state) => ({
+                  status: {
+                    ...state.status,
+                    _removeLoading: false,
+                    error: null,
+                    idsRemoving: idsRemoving.filter((idRemoving) => idRemoving !== payload)
+                  }
+                }));
+                if (onSuccess) {
+                  onSuccess(response);
+                }
+              } else {
+                throw new Error();
+              }
+            }),
+            catchError(() => {
+              const idsRemoving = store.status.idsRemoving() || [];
+              patchState(store, (state) => ({
+                status: {
+                  ...state.status,
+                  _removeLoading: false,
+                  error: new Error(),
+                  idsRemoving: idsRemoving.filter((idRemoving) => idRemoving !== payload)
+                }
+              }));
+              if (onError) {
+                onError();
+              }
+              return EMPTY;
+            })
+          );
+        })
+      )
+    ),
+    update<%= classify(name) %>: rxMethod<RequestConfig<Update<%= classify(name) %>, boolean>>(
+      pipe(
+        tap(({ payload }) => {
+          patchState(store, (state) => ({
+            status: {
+              ...state.status,
+              _updateLoading: true,
+              idsUpdating: [...(state.status.idsUpdating || []), payload.cod]
+            }
+          }));
+        }),
+        switchMap(({ onError, onSuccess, payload }) => {
+          return <%= camelize(name) %>Service.update<%= classify(name) %>$(entity).pipe(
+            tap((response) => {
+              if (response) {
+                const idsUpdating = store.status.idsUpdating() || [];
+                patchState(store, updateEntity({ changes: payload, id: payload.cod }, config), (state) => ({
+                  status: {
+                    ...state.status,
+                    _updateLoading: false,
+                    error: null,
+                    idsUpdating: idsUpdating.filter((idUpdating) => idUpdating !== payload.cod)
+                  }
+                }));
+                if (onSuccess) {
+                  onSuccess(response);
+                }
+              } else {
+                throw new Error('');
+              }
+            }),
+            catchError(() => {
+              const idsUpdating = store.status.idsUpdating() || [];
+              patchState(store, (state) => ({
+                status: {
+                  ...state.status,
+                  _updateLoading: false,
+                  error: new Error('Error al actualizar horario-acceso'),
+                  idsUpdating: idsUpdating.filter((idUpdating) => idUpdating !== payload.cod)
+                }
+              }));
+              if (onError) {
+                onError();
+              }
+              return EMPTY;
+            })
+          );
+        })
+      )
+    ),
+  })),
+  withHooks({
+    onInit: (store) => {
+      store.load<%= classify(pluralize(name)) %>();
+    },
+  })
+);

package/src/ngrx/store/index.js

@@ -68,16 +68,24 @@ function signalStore(options) {
         if (globalConfig && globalConfig.pk && !options.pk) {
             options.pk = globalConfig.pk;
         }
+        if (!options.path) {
+            options.path = process.cwd();
+        }
+        // Si la carpeta final no se llama 'state', agregarla
+        let movePath = (0, core_1.normalize)(options.path);
+        const pathParts = movePath.split(/[\\/]/).filter(Boolean);
+        if (pathParts[pathParts.length - 1] !== "state") {
+            movePath = (0, core_1.join)(movePath, "state");
+        }
         treeRef = tree;
-        const movePath = (0, core_1.normalize)(options.path);
         const indexPath = (0, core_1.join)(movePath, "index.ts");
         const nameDash = core_1.strings.dasherize(options.name);
         const entityName = core_1.strings.classify(options.name);
         const entityHeader = `/* ${entityName.toUpperCase()} */`;
         const exportBlock = [
             entityHeader,
-            `export * from './${nameDash}/${nameDash}.model';`,
-            `export * from './${nameDash}/${nameDash}.service';`,
+            `export * from './${nameDash}${options.grouped ? "/models" : ""}/${nameDash}.model';`,
+            `export * from './${nameDash}${options.grouped ? "/services" : ""}/${nameDash}.service';`,
             `export * from './${nameDash}/${nameDash}.store';`,
             "",
         ].join("\n");
@@ -103,7 +111,35 @@ function signalStore(options) {
         else {
             tree.create(indexPath, content);
         }
-        const templateStoreSource = (0, schematics_1.apply)((0, schematics_1.url)("./files/store"), [
+        // Generar archivos en las carpetas store, services y models
+        const namePath = (0, core_1.join)(movePath, core_1.strings.dasherize(options.name));
+        const rules = [];
+        // store
+        rules.push((0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)("./files/state/store"), [
+            (0, schematics_1.applyTemplates)(Object.assign(Object.assign(Object.assign({}, core_1.strings), options), { pluralize: (word) => {
+                    switch (options.lang) {
+                        case "es":
+                            return pluralizeEs(word);
+                        default:
+                            return pluralizeEn(word);
+                    }
+                }, pk: options.pk || "id" })),
+            (0, schematics_1.move)("store"),
+        ])));
+        // services
+        rules.push((0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)("./files/state/services"), [
+            (0, schematics_1.applyTemplates)(Object.assign(Object.assign(Object.assign({}, core_1.strings), options), { pluralize: (word) => {
+                    switch (options.lang) {
+                        case "es":
+                            return pluralizeEs(word);
+                        default:
+                            return pluralizeEn(word);
+                    }
+                }, pk: options.pk || "id" })),
+            (0, schematics_1.move)((0, core_1.join)(namePath, options.grouped ? "services" : "")),
+        ])));
+        // models
+        rules.push((0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)("./files/state/models"), [
             (0, schematics_1.applyTemplates)(Object.assign(Object.assign(Object.assign({}, core_1.strings), options), { pluralize: (word) => {
                     switch (options.lang) {
                         case "es":
@@ -112,10 +148,11 @@ function signalStore(options) {
                             return pluralizeEn(word);
                     }
                 }, pk: options.pk || "id" })),
-            (0, schematics_1.move)((0, core_1.join)(movePath, core_1.strings.dasherize(options.name))),
-        ]);
-        const commonEntityRule = mergeFilesSmart("./files/entity", (0, core_1.join)(movePath, "common/entity"), options);
-        return (0, schematics_1.chain)([(0, schematics_1.mergeWith)(templateStoreSource), commonEntityRule]);
+            (0, schematics_1.move)((0, core_1.join)(namePath, options.grouped ? "models" : "")),
+        ])));
+        // common entity
+        rules.push(mergeFilesSmart("./files/entity", "src/app/shared/state", options));
+        return (0, schematics_1.chain)(rules);
     });
 }
 //# sourceMappingURL=index.js.map

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

@@ -1,6 +1,7 @@
-export interface StoreSchemaOptions {
-  name: string;
-  path: string;
-  pk?: string;
-  lang: "en" | "es";
-}
+export interface StoreSchemaOptions {
+  name: string;
+  path?: string;
+  grouped: boolean;
+  pk?: string;
+  lang: "en" | "es";
+}

package/src/ngrx/store/schema.json

@@ -1,30 +1,34 @@
-{
-  "$schema": "http://json-schema.org/schema",
-  "$id": "SignalStoreSchematic",
-  "title": "Signal Store Schema",
-  "type": "object",
-  "properties": {
-    "name": {
-      "type": "string",
-      "description": "Name of the entity.",
-      "x-prompt": "What's the name of the entity?",
-      "priority": 1
-    },
-    "path": {
-      "type": "string",
-      "description": "Destination path.",
-      "default": "src/app/core"
-    },
-    "lang": {
-      "type": "string",
-      "description": "Language for pluralization ('en' for English, 'es' for Spanish).",
-      "enum": ["en", "es"],
-      "default": "en"
-    },
-    "pk": {
-      "type": "string",
-      "description": "Name of the primary key."
-    }
-  },
-  "required": ["name"]
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "SignalStoreSchematic",
+  "title": "Signal Store Schema",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Name of the entity.",
+      "x-prompt": "What's the name of the entity?",
+      "priority": 1
+    },
+    "path": {
+      "type": "string",
+      "description": "Destination path."
+    },
+    "grouped": {
+      "type": "boolean",
+      "description": "Whether the files should be grouped in subfolders.",
+      "default": false
+    },
+    "lang": {
+      "type": "string",
+      "description": "Language for pluralization ('en' for English, 'es' for Spanish).",
+      "enum": ["en", "es"],
+      "default": "en"
+    },
+    "pk": {
+      "type": "string",
+      "description": "Name of the primary key."
+    }
+  },
+  "required": ["name"]
 }

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

@@ -1,212 +0,0 @@
-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 config = entityConfig({
-  entity: type<<%= classify(name) %>Dto>(),
-  selectId: (entity) => entity.<%= pk %>,
-});
-
-export const <%= classify(name) %>Store = signalStore(
-  withEntities(config),
-  withState({
-    _status: initialStatus,
-  }),
-  withComputed(({ entityMap, _status }) => ({
-    <%= camelize(pluralize(name)) %>: computed(() => Object.values(entityMap())),
-    <%= camelize(name) %>Seleccionado: computed(() => {
-      const <%= pk %> = _status().idSelected;
-      return <%= pk %> ? entityMap()[<%= pk %>] : null;
-    }),
-    error: computed(() => _status().error),
-    loaded: computed(() => _status().loaded),
-    loading: computed(() => _status().loading),
-    loadingRemove: computed(
-      () => (<%= pk %>?: number) =>
-        (<%= pk %> ? _status().idsRemoving?.includes(<%= pk %>) : _status().removeLoading) || false
-    ),
-    loadingUpdate: computed(
-      () => (<%= pk %>?: number) =>
-        (<%= pk %> ? _status().idsUpdating?.includes(<%= pk %>) : _status().updateLoading) || false
-    ),
-  })),
-  withMethods((store, <%= camelize(name) %>Service = inject(<%= classify(name) %>Service)) => ({
-    add<%= classify(name) %>: rxMethod<Add<%= classify(name) %>>(
-      pipe(
-        tap(() => {
-          patchState(store, { _status: { ...store._status(), addLoading: true } });
-        }),
-        switchMap((entity) => {
-          return <%= camelize(name) %>Service.add<%= classify(name) %>$(entity).pipe(
-            tap((<%= pk %>) => {
-              patchState(store, addEntity({ ...entity, <%= pk %> }, config), {
-                _status: {
-                  ...store._status(),
-                  addLoading: false,
-                  error: null,
-                },
-              });
-            }),
-            catchError(() => {
-              patchState(store, {
-                _status: {
-                  ...store._status(),
-                  addLoading: false,
-                  error: new Error('Error al agregar <%= name %>'),
-                },
-              });
-              return of(entity);
-            })
-          );
-        })
-      )
-    ),
-    load<%= classify(pluralize(name)) %>: rxMethod<void>(
-      pipe(
-        tap(() => {
-          patchState(store, { _status: { ...store._status(), loading: true } });
-        }),
-        switchMap(() => {
-          return <%= camelize(name) %>Service.get<%= classify(pluralize(name)) %>$().pipe(
-            tap((response) => {
-              patchState(store, setAllEntities(response, config), {
-                _status: {
-                  ...store._status(),
-                  error: null,
-                  loaded: true,
-                  loading: false,
-                },
-              });
-            }),
-            catchError(() => {
-              patchState(store, {
-                _status: {
-                  ...store._status(),
-                  error: new Error('Error al cargar <%= pluralize(name) %>'),
-                  loading: false,
-                },
-              });
-              return of([]);
-            })
-          );
-        })
-      )
-    ),
-    remove<%= classify(name) %>: rxMethod<number>(
-      pipe(
-        tap((<%= pk %>) => {
-          patchState(store, {
-            _status: {
-              ...store._status(),
-              removeLoading: true,
-              idsRemoving: [...(store._status().idsRemoving || []), <%= pk %>],
-            },
-          });
-        }),
-        switchMap((<%= pk %>) => {
-          return <%= camelize(name) %>Service.remove<%= classify(name) %>$(<%= pk %>).pipe(
-            tap((success) => {
-              if (success) {
-                const idsRemoving = store._status().idsRemoving || [];
-                patchState(store, removeEntity(<%= pk %>), {
-                  _status: {
-                    ...store._status(),
-                    removeLoading: false,
-                    error: null,
-                    idsRemoving: idsRemoving.filter((idRemoving) => idRemoving !== <%= pk %>),
-                  },
-                });
-              } else {
-                throw new Error('Error al eliminar <%= name %>');
-              }
-            }),
-            catchError(() => {
-              const idsRemoving = store._status().idsRemoving || [];
-              patchState(store, {
-                _status: {
-                  ...store._status(),
-                  removeLoading: false,
-                  error: new Error('Error al eliminar <%= name %>'),
-                  idsRemoving: idsRemoving.filter((idRemoving) => idRemoving !== <%= pk %>),
-                },
-              });
-              return of(false);
-            })
-          );
-        })
-      )
-    ),
-    update<%= classify(name) %>: rxMethod<Update<%= classify(name) %>>(
-      pipe(
-        tap((entity) => {
-          patchState(store, {
-            _status: {
-              ...store._status(),
-              idsUpdating: [...(store._status().idsUpdating || []), entity.<%= pk %>],
-              updateLoading: true,
-            },
-          });
-        }),
-        switchMap((entity) => {
-          return <%= camelize(name) %>Service.update<%= classify(name) %>$(entity).pipe(
-            tap((success) => {
-              if (success) {
-                const idsUpdating = store._status().idsUpdating || [];
-                patchState(store, updateEntity({ changes: entity, id: entity.<%= pk %> }, config), {
-                  _status: {
-                    ...store._status(),
-                    error: null,
-                    idsUpdating: idsUpdating.filter((idUpdating) => idUpdating !== entity.<%= pk %>),
-                    updateLoading: false,
-                  },
-                });
-              } else {
-                throw new Error('Error al actualizar <%= name %>');
-              }
-            }),
-            catchError(() => {
-              const idsUpdating = store._status().idsUpdating || [];
-              patchState(store, {
-                _status: {
-                  ...store._status(),
-                  error: new Error('Error al actualizar <%= name %>'),
-                  idsUpdating: idsUpdating.filter((idUpdating) => idUpdating !== entity.<%= pk %>),
-                  updateLoading: false,
-                },
-              });
-              return of(false);
-            })
-          );
-        })
-      )
-    ),
-  })),
-  withHooks({
-    onInit: (store) => {
-      store.load<%= classify(pluralize(name)) %>();
-    },
-  })
-);