@ngflow/ng-architect 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngflow/ng-architect",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Angular schematics to generate files and maintain clean architecture",
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/src/collection.json

@@ -15,11 +15,21 @@
   // The factory is required, except when using the extends field. Then the factory can
   // overwrite the extended schematic factory.
   "schematics": {
-  "ng-architect": {
-    "description": "Gera uma feature Angular completa com rotas e arquivos",
-    "factory": "./ng-architect/index#default",
-    "schema": "./ng-architect/schema.json"
-  },
+    "ng-architect": {
+      "description": "Gera uma feature Angular completa com rotas e arquivos",
+      "factory": "./ng-architect/feature/index#default",
+      "schema": "./ng-architect/feature/schema.json"
+    },
+    "component": {
+      "description": "Generate a reusable Angular component",
+      "factory": "./ng-architect/component/index",
+      "schema": "./ng-architect/component/schema.json"
+    },
+    "service": {
+      "description": "Generate a service with optional store and tests",
+      "factory": "./ng-architect/service/index",
+      "schema": "./ng-architect/service/schema.json"
+    },
     "my-extend-schematic": {
       "description": "A schematic that extends another schematic.",
       "extends": "my-full-schematic"

package/src/ng-architect/component/index.ts

@@ -0,0 +1,27 @@
+import {
+  Rule,
+  SchematicContext,
+  Tree,
+  apply,
+  chain,
+  mergeWith,
+  template,
+  url
+} from '@angular-devkit/schematics';
+import { toKebabCase, toPascalCase } from '../utils/string-utils';
+
+export default function(options: any): Rule {
+  const componentKebab = toKebabCase(options.name);
+  const componentPascal = toPascalCase(options.name);
+
+  return chain([
+    (tree: Tree, context: SchematicContext) => {
+      context.logger.info(`✅ Creating component: ${componentPascal} (${componentKebab})`);
+    },
+    mergeWith(
+      apply(url('./files'), [
+        template({ componentKebab, componentPascal, module: options.module })
+      ])
+    )
+  ]);
+}

package/src/ng-architect/component/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ComponentSchema",
+  "title": "Angular Component Generator",
+  "description": "Generates a reusable Angular component",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the component (e.g., navbar, footer)",
+      "minLength": 1
+    },
+    "module": {
+      "type": "string",
+      "description": "Optional: The Angular module to declare this component in"
+    }
+  },
+  "required": ["name"]
+}

package/src/ng-architect/feature/index.ts

@@ -0,0 +1,47 @@
+import {
+  Rule,
+  SchematicContext,
+  Tree,
+  apply,
+  chain,
+  filter,
+  mergeWith,
+  template,
+  url
+} from '@angular-devkit/schematics';
+import { toKebabCase, toPascalCase } from '../utils/string-utils';
+import { addRoute, createOrUpdateBarrel } from '../utils/file-utils';
+
+export default function (options: { name: string }): Rule {
+  const featureKebab = toKebabCase(options.name);
+  const featurePascal = toPascalCase(options.name);
+
+  return chain([
+    // Log inicial
+    (_tree: Tree, context: SchematicContext) => {
+      context.logger.info(`✅ Creating feature: ${featurePascal} (${featureKebab})`);
+    },
+
+    // Gera os arquivos a partir do template
+    mergeWith(
+      apply(url('./files'), [
+        filter(path => !path.endsWith('.swp')),
+        template({ featureKebab, featurePascal })
+      ])
+    ),
+
+    // Atualiza app.routes.ts adicionando a rota
+    (tree: Tree, context: SchematicContext) => {
+      addRoute(tree, context, featureKebab);
+
+      // Cria barrels automáticos em data, models e pages
+      const folders = ['data', 'models', 'pages'];
+      folders.forEach(folder => {
+        const path = `src/app/features/${featureKebab}/${folder}`;
+        createOrUpdateBarrel(tree, context, path);
+      });
+
+      return tree;
+    }
+  ]);
+}

package/src/ng-architect/{schema.json → feature/schema.json}

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema",
-  "$id": "MyFullSchematicsSchema",
+  "$id": "ngArchitectSchema",
   "title": "Angular Feature Generator",
   "description": "Generates a complete Angular feature with pages, services, store, models and routes",
   "type": "object",

package/src/ng-architect/service/files/__serviceKebab__/__serviceKebab__.service.ts

@@ -0,0 +1,27 @@
+import {
+  Rule,
+  SchematicContext,
+  Tree,
+  apply,
+  chain,
+  mergeWith,
+  template,
+  url
+} from '@angular-devkit/schematics';
+import { toKebabCase, toPascalCase } from '../../../utils/string-utils';
+
+export default function(options: any): Rule {
+  const serviceKebab = toKebabCase(options.name);
+  const servicePascal = toPascalCase(options.name);
+
+  return chain([
+    (tree: Tree, context: SchematicContext) => {
+      context.logger.info(`✅ Creating service: ${servicePascal} (${serviceKebab})`);
+    },
+    mergeWith(
+      apply(url('./files'), [
+        template({ serviceKebab, servicePascal, store: options.store })
+      ])
+    )
+  ]);
+}

package/src/ng-architect/service/schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ServiceSchema",
+  "title": "Angular Service Generator",
+  "description": "Generates an Angular service with optional store and tests",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the service (e.g., user, auth)",
+      "minLength": 1
+    },
+    "store": {
+      "type": "boolean",
+      "description": "Whether to generate a store alongside the service",
+      "default": false
+    }
+  },
+  "required": ["name"]
+}

package/src/ng-architect/utils/file-utils.ts

@@ -0,0 +1,58 @@
+// utils/file-utils.ts
+import { Tree, SchematicContext } from '@angular-devkit/schematics';
+import { toPascalCase, toKebabCase } from './string-utils';
+
+/**
+ * Atualiza o app.routes.ts adicionando uma nova rota
+ */
+export function addRoute(
+  tree: Tree,
+  context: SchematicContext,
+  featureName: string
+) {
+  const appRoutesPath = 'src/app/app.routes.ts';
+  const featureKebab = toKebabCase(featureName);
+  const featurePascal = toPascalCase(featureName);
+
+  if (!tree.exists(appRoutesPath)) {
+    context.logger.warn(`⚠️ ${appRoutesPath} não encontrado, rota não registrada`);
+    return;
+  }
+
+  let content = tree.read(appRoutesPath)?.toString('utf-8') || '';
+  const routePattern = new RegExp(`path:\\s*['"]${featureKebab}['"]`);
+  if (routePattern.test(content)) {
+    context.logger.warn(`ℹ️ Rota "${featureKebab}" já existe em app.routes.ts`);
+    return;
+  }
+
+  const routeBlock = `  {
+    path: '${featureKebab}',
+    loadChildren: () =>
+      import('./features/${featureKebab}/${featureKebab}.routes')
+        .then(m => m.${featurePascal}Routes),
+  },`;
+
+  content = content.replace(/\n\];\s*$/, `\n${routeBlock}\n];`);
+  tree.overwrite(appRoutesPath, content);
+  context.logger.info(`➕ Rota "${featureKebab}" registrada em app.routes.ts`);
+}
+
+/**
+ * Cria ou atualiza um arquivo barrel (index.ts) em uma pasta
+ */
+export function createOrUpdateBarrel(
+  tree: Tree,
+  context: SchematicContext,
+  folderPath: string
+) {
+  if (!tree.exists(folderPath)) return;
+
+  const files = tree.getDir(folderPath).subfiles.filter(f => f.endsWith('.ts'));
+  const exports = files.map(f => `export * from './${f.replace('.ts','')}';`).join('\n');
+
+  const barrelPath = `${folderPath}/index.ts`;
+  tree.overwrite(barrelPath, exports);
+
+  context.logger.info(`📦 Barrel atualizado em ${folderPath}`);
+}

package/src/ng-architect/utils/string-utils.ts

@@ -0,0 +1,23 @@
+// utils/string-utils.ts
+
+/**
+ * Converte uma string para kebab-case
+ * Ex: "UserProfile" -> "user-profile"
+ */
+export function toKebabCase(value: string): string {
+  return value
+    .replace(/([a-z])([A-Z])/g, '$1-$2') // separa camelCase
+    .replace(/[\s_]+/g, '-')             // substitui espaços ou underscores por "-"
+    .toLowerCase();
+}
+
+/**
+ * Converte uma string para PascalCase
+ * Ex: "user-profile" -> "UserProfile"
+ */
+export function toPascalCase(value: string): string {
+  return value
+    .split(/[-_\s]/)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "baseUrl": "tsconfig",
+    "baseUrl": "src",
     "lib": ["es2018", "dom"],
     "module": "commonjs",
     "moduleResolution": "node",
@@ -16,8 +16,18 @@
     "sourceMap": true,
     "strictNullChecks": true,
     "target": "es6",
-    "types": ["jasmine", "node"]
+    "types": ["jasmine", "node"],
+
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["src/*/files/**/*"]
+"exclude": [
+  "node_modules",
+  "dist",
+  "src/**/*.spec.ts",
+  "src/feature/files/**/*",
+  "src/component/files/**/*",
+  "src/service/files/**/*"
+]
+
+
 }

package/src/ng-architect/index.ts

@@ -1,76 +0,0 @@
-import {
-  Rule,
-  SchematicContext,
-  Tree,
-  apply,
-  chain,
-  filter,
-  mergeWith,
-  template,
-  url,
-} from '@angular-devkit/schematics';
-
-// Helper functions
-const toKebabCase = (value: string): string =>
-  value
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
-    .replace(/_/g, '-')
-    .toLowerCase();
-
-const toPascalCase = (value: string): string =>
-  value
-    .split(/[-_]/)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join('');
-
-export default function (options: any): Rule {
-  const featureKebab = toKebabCase(options.name);
-  const featurePascal = toPascalCase(options.name);
-
-  return chain([
-    (_tree: Tree, context: SchematicContext) => {
-      context.logger.info(`✅ Criando feature: ${featurePascal} (${featureKebab})`);
-    },
-
-    // Generate files from templates
-    mergeWith(
-      apply(url('./files'), [
-        filter((path) => !path.endsWith('.swp')),
-        template({
-          featureKebab,
-          featurePascal,
-        }),
-      ])
-    ),
-
-    // Update app.routes.ts if it exists
-    (tree: Tree, context: SchematicContext) => {
-      const appRoutesPath = 'src/app/app.routes.ts';
-
-      if (tree.exists(appRoutesPath)) {
-        let content = tree.read(appRoutesPath)?.toString('utf-8') || '';
-
-        const routePattern = new RegExp(`path:\\s*['"]${featureKebab}['"]`);
-        if (!routePattern.test(content)) {
-          const routeBlock = `  {
-    path: '${featureKebab}',
-    loadChildren: () =>
-      import('./features/${featureKebab}/${featureKebab}.routes')
-        .then(m => m.${featurePascal}Routes),
-  },`;
-
-          // Insert before the closing bracket
-          content = content.replace(/\n\];\s*$/, `\n${routeBlock}\n];`);
-          tree.overwrite(appRoutesPath, content);
-          context.logger.info(`➕ Rota "${featureKebab}" registada em app.routes.ts`);
-        } else {
-          context.logger.warn(`ℹ️ Rota "${featureKebab}" já existe em app.routes.ts`);
-        }
-      } else {
-        context.logger.warn('⚠️ app.routes.ts não encontrado, rota não registada automaticamente');
-      }
-
-      return tree;
-    },
-  ]);
-}