@barcidev/ngx-autogen 0.1.0

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 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)) %>();
+    },
+  })
+);

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

@@ -0,0 +1,3 @@
+import { Rule } from "@angular-devkit/schematics";
+import { StoreSchemaOptions } from "./schema";
+export declare function signalStore(options: StoreSchemaOptions): Rule;

package/src/ngrx/store/index.js

@@ -0,0 +1,121 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalStore = signalStore;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const pluralizeEs = (name) => {
+    if (!name)
+        return name;
+    const lastChar = name.slice(-1).toLowerCase();
+    const vowels = ["a", "e", "i", "o", "u"];
+    if (vowels.includes(lastChar))
+        return name + "s";
+    if (lastChar === "z")
+        return name.slice(0, -1) + "ces";
+    return name + "es";
+};
+const pluralizeEn = (name) => {
+    if (!name)
+        return name;
+    const lastChar = name.slice(-1).toLowerCase();
+    const vowels = ["a", "e", "i", "o", "u"];
+    if (lastChar === "y" && !vowels.includes(name.slice(-2, -1).toLowerCase())) {
+        return name.slice(0, -1) + "ies";
+    }
+    if (["s", "x", "z", "ch", "sh"].some((end) => name.toLowerCase().endsWith(end))) {
+        return name + "es";
+    }
+    return name + "s";
+};
+function mergeFilesSmart(urlPath, destPath, options) {
+    return (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)(urlPath), [
+        (0, schematics_1.applyTemplates)(Object.assign(Object.assign({}, core_1.strings), options)),
+        (0, schematics_1.move)(destPath),
+        (0, schematics_1.forEach)((fileEntry) => {
+            // Si el archivo ya existe en el árbol
+            if (treeRef.exists(fileEntry.path)) {
+                const existingContent = treeRef.read(fileEntry.path).toString();
+                const newContent = fileEntry.content.toString();
+                // Solo escribimos si el contenido nuevo no está ya incluido (basado en una cadena clave o firma)
+                // Puedes ajustar esta condición según lo que necesites verificar
+                if (existingContent.includes(newContent.trim())) {
+                    return null; // Descarta el archivo del proceso de merge (no hace nada)
+                }
+                // Si el archivo existe pero queremos añadir contenido al final (opcional)
+                // treeRef.overwrite(fileEntry.path, existingContent + '\n' + newContent);
+                return null;
+            }
+            return fileEntry;
+        }),
+    ]));
+}
+let treeRef;
+function signalStore(options) {
+    return (tree) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const workspace = yield (0, workspace_1.getWorkspace)(tree);
+        const globalConfig = (_a = workspace.extensions.schematics) === null || _a === void 0 ? void 0 : _a["ngx-autogen:all"];
+        if (globalConfig && globalConfig.pk && !options.pk) {
+            options.pk = globalConfig.pk;
+        }
+        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}/${nameDash}.store';`,
+            "",
+        ].join("\n");
+        let content = "";
+        if (tree.exists(indexPath)) {
+            content = tree.read(indexPath).toString();
+        }
+        if (content.includes(entityHeader)) {
+            const lines = exportBlock.split("\n");
+            lines.forEach((line) => {
+                if (line.trim() !== "" && !content.includes(line)) {
+                    content += line + "\n";
+                }
+            });
+        }
+        else {
+            content =
+                content.trim() + (content.length > 0 ? "\n\n" : "") + exportBlock;
+        }
+        if (tree.exists(indexPath)) {
+            tree.overwrite(indexPath, content);
+        }
+        else {
+            tree.create(indexPath, content);
+        }
+        const templateStoreSource = (0, schematics_1.apply)((0, schematics_1.url)("./files/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)((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]);
+    });
+}
+//# sourceMappingURL=index.js.map

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

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

package/src/ngrx/store/schema.json

@@ -0,0 +1,30 @@
+{
+  "$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"]
+}