@ngstato/schematics 0.4.0

package/README.md

@@ -0,0 +1,96 @@
+<div align="center">
+
+# @ngstato/schematics
+
+### `ng generate @ngstato/schematics:store users` — done.
+
+**Scaffold stores, features, and tests in seconds.**
+
+[![npm](https://img.shields.io/badge/npm-v0.3.0-blue)](https://www.npmjs.com/package/@ngstato/schematics)
+[![Angular CLI](https://img.shields.io/badge/Angular_CLI-17%2B-dd0031)](https://angular.dev)
+[![license](https://img.shields.io/badge/license-MIT-lightgrey)](#)
+
+</div>
+
+---
+
+## Install
+
+```bash
+npm install -D @ngstato/schematics
+```
+
+## Generate a store
+
+```bash
+ng generate @ngstato/schematics:store users
+# or shorthand
+ng g @ngstato/schematics:s users
+```
+
+Creates:
+```
+src/app/stores/users/
+├── users.store.ts       # Store with CRUD actions, selectors, hooks, DevTools
+└── users.store.spec.ts  # Test file with createMockStore
+```
+
+### Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--name` | (required) | Store name (e.g. `users`, `products`) |
+| `--crud` | `true` | Generate CRUD actions (load, create, update, delete) |
+| `--entity` | `false` | Use `createEntityAdapter` for normalized collections |
+| `--devtools` | `true` | Connect to DevTools with `connectDevTools` |
+| `--spec` | `true` | Generate test file |
+| `--flat` | `false` | Create file directly in path (no subdirectory) |
+| `--path` | `src/app/stores` | Target directory |
+
+### Examples
+
+```bash
+# Basic CRUD store
+ng g @ngstato/schematics:s products
+
+# Entity-based store with adapter
+ng g @ngstato/schematics:s orders --entity
+
+# Flat file, no tests
+ng g @ngstato/schematics:s settings --flat --no-spec
+
+# Custom path
+ng g @ngstato/schematics:s auth --path src/app/core/auth
+```
+
+## Generate a feature
+
+```bash
+ng generate @ngstato/schematics:feature loading
+# or shorthand
+ng g @ngstato/schematics:f pagination
+```
+
+Creates a reusable store feature:
+
+```ts
+// loading.feature.ts
+export function withLoading(): FeatureConfig {
+  return {
+    state:    { loading: false, error: null },
+    actions:  { /* ... */ },
+    computed: { /* ... */ }
+  }
+}
+
+// Usage in any store
+const store = createStore({
+  items: [],
+  ...mergeFeatures(withLoading(), withPagination()),
+  actions: { ... }
+})
+```
+
+## License
+
+MIT

package/collection.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "../node_modules/@angular-devkit/schematics/collection-schema.json",
+  "schematics": {
+    "store": {
+      "description": "Generate a new ngStato store",
+      "factory": "./dist/store/index#store",
+      "schema": "./src/store/schema.json",
+      "aliases": ["s"]
+    },
+    "feature": {
+      "description": "Generate a reusable store feature",
+      "factory": "./dist/feature/index#feature",
+      "schema": "./src/feature/schema.json",
+      "aliases": ["f"]
+    }
+  }
+}

package/dist/feature/index.d.ts

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

package/dist/feature/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feature = feature;
+const schematics_1 = require("@angular-devkit/schematics");
+const core_1 = require("@angular-devkit/core");
+function feature(options) {
+    return (_tree, _context) => {
+        const name = core_1.strings.dasherize(options.name);
+        const fnName = core_1.strings.camelize(`with-${options.name}`);
+        const className = core_1.strings.classify(options.name);
+        const content = `import type { FeatureConfig } from '@ngstato/core'
+
+/**
+ * ${fnName}() — Reusable store feature
+ *
+ * Usage:
+ * \`\`\`ts
+ * const store = createStore({
+ *   ...mergeFeatures(${fnName}()),
+ *   // your state and actions
+ * })
+ * \`\`\`
+ */
+export function ${fnName}(): FeatureConfig {
+  return {
+    state: {
+      // TODO: Add feature state
+    },
+
+    actions: {
+      // TODO: Add feature actions
+    },
+
+    computed: {
+      // TODO: Add feature computed
+    }
+  }
+}
+`;
+        return (0, schematics_1.chain)([
+            (tree) => {
+                tree.create(`${options.path}/${name}.feature.ts`, content);
+                return tree;
+            }
+        ]);
+    };
+}

package/dist/feature/schema.d.ts

@@ -0,0 +1,4 @@
+export interface FeatureSchema {
+    name: string;
+    path: string;
+}

package/dist/feature/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store/index.d.ts

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

package/dist/store/index.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.store = store;
+const schematics_1 = require("@angular-devkit/schematics");
+const core_1 = require("@angular-devkit/core");
+function store(options) {
+    return (_tree, _context) => {
+        const name = core_1.strings.dasherize(options.name);
+        const className = core_1.strings.classify(options.name);
+        const path = options.flat
+            ? options.path
+            : `${options.path}/${name}`;
+        // Generate the store file content
+        const storeContent = generateStoreFile(className, name, options);
+        const rules = [];
+        rules.push((tree) => {
+            tree.create(`${path}/${name}.store.ts`, storeContent);
+            return tree;
+        });
+        // Generate spec file
+        if (options.spec) {
+            const specContent = generateSpecFile(className, name, options);
+            rules.push((tree) => {
+                tree.create(`${path}/${name}.store.spec.ts`, specContent);
+                return tree;
+            });
+        }
+        return (0, schematics_1.chain)(rules);
+    };
+}
+function generateStoreFile(className, name, options) {
+    const imports = ['createStore', 'http'];
+    if (options.devtools)
+        imports.push('connectDevTools');
+    if (options.entity)
+        imports.push('createEntityAdapter', 'withEntities');
+    let content = `import { ${imports.join(', ')} } from '@ngstato/core'
+import { StatoStore, injectStore } from '@ngstato/angular'
+
+`;
+    // Interface
+    content += `export interface ${className} {
+  id: string
+  name: string
+  // TODO: Add your entity properties
+}
+
+`;
+    // Entity adapter
+    if (options.entity) {
+        content += `const adapter = createEntityAdapter<${className}>()
+
+`;
+    }
+    // Store factory
+    content += `function create${className}Store() {
+  const store = createStore({
+    // ── State ──
+`;
+    if (options.entity) {
+        content += `    ...withEntities<${className}>(),
+`;
+    }
+    else {
+        content += `    ${name}s: [] as ${className}[],
+`;
+    }
+    content += `    loading: false,
+    error: null as string | null,
+
+    // ── Selectors ──
+    selectors: {
+`;
+    if (options.entity) {
+        content += `      total: (s) => s.ids.length,
+`;
+    }
+    else {
+        content += `      total: (s) => s.${name}s.length,
+`;
+    }
+    content += `    },
+
+    // ── Actions ──
+    actions: {
+`;
+    if (options.crud) {
+        if (options.entity) {
+            content += generateEntityCrudActions(className, name);
+        }
+        else {
+            content += generateBasicCrudActions(className, name);
+        }
+    }
+    else {
+        content += `      // TODO: Add your actions
+`;
+    }
+    content += `    },
+
+    // ── Hooks ──
+    hooks: {
+      onInit:  (store) => store.load${className}s(),
+      onError: (err, action) => console.error(\`[${className}Store] \${action}:\`, err.message)
+    }
+  })
+
+`;
+    if (options.devtools) {
+        content += `  connectDevTools(store, '${className}Store')
+`;
+    }
+    content += `  return store
+}
+
+// ── Angular Injectable ──
+export const ${className}Store = StatoStore(() => create${className}Store())
+`;
+    return content;
+}
+function generateBasicCrudActions(className, name) {
+    return `      async load${className}s(state) {
+        state.loading = true
+        state.error = null
+        try {
+          state.${name}s = await http.get('/${name}s')
+        } catch (e) {
+          state.error = (e as Error).message
+          throw e
+        } finally {
+          state.loading = false
+        }
+      },
+
+      async create${className}(state, payload: Omit<${className}, 'id'>) {
+        const created = await http.post<${className}>('/${name}s', payload)
+        state.${name}s = [...state.${name}s, created]
+      },
+
+      async update${className}(state, id: string, changes: Partial<${className}>) {
+        const updated = await http.patch<${className}>(\`/${name}s/\${id}\`, changes)
+        state.${name}s = state.${name}s.map(item =>
+          item.id === id ? { ...item, ...updated } : item
+        )
+      },
+
+      async delete${className}(state, id: string) {
+        await http.delete(\`/${name}s/\${id}\`)
+        state.${name}s = state.${name}s.filter(item => item.id !== id)
+      },
+`;
+}
+function generateEntityCrudActions(className, name) {
+    return `      async load${className}s(state) {
+        state.loading = true
+        state.error = null
+        try {
+          const items = await http.get<${className}[]>('/${name}s')
+          adapter.setAll(state, items)
+        } catch (e) {
+          state.error = (e as Error).message
+          throw e
+        } finally {
+          state.loading = false
+        }
+      },
+
+      async create${className}(state, payload: Omit<${className}, 'id'>) {
+        const created = await http.post<${className}>('/${name}s', payload)
+        adapter.addOne(state, created)
+      },
+
+      async update${className}(state, id: string, changes: Partial<${className}>) {
+        const updated = await http.patch<${className}>(\`/${name}s/\${id}\`, changes)
+        adapter.updateOne(state, { id, changes: updated })
+      },
+
+      async delete${className}(state, id: string) {
+        await http.delete(\`/${name}s/\${id}\`)
+        adapter.removeOne(state, id)
+      },
+`;
+}
+function generateSpecFile(className, name, options) {
+    return `import { describe, it, expect, vi } from 'vitest'
+import { createMockStore } from '@ngstato/testing'
+
+describe('${className}Store', () => {
+  function createTestStore(overrides = {}) {
+    return createMockStore({
+      ${options.entity ? `ids: [] as string[],
+      entities: {} as Record<string, any>,` : `${name}s: [] as any[],`}
+      loading: false,
+      error: null as string | null,
+
+      actions: {
+        load${className}s: vi.fn(),
+        create${className}: vi.fn(),
+        update${className}: vi.fn(),
+        delete${className}: vi.fn(),
+      }
+    }, overrides)
+  }
+
+  it('should create with initial state', () => {
+    const store = createTestStore()
+    expect(store.loading).toBe(false)
+    expect(store.error).toBe(null)
+  })
+
+  it('should set loading state', () => {
+    const store = createTestStore()
+    store.__setState({ loading: true })
+    expect(store.loading).toBe(true)
+  })
+
+  it('should set error state', () => {
+    const store = createTestStore()
+    store.__setState({ error: 'Something went wrong' })
+    expect(store.error).toBe('Something went wrong')
+  })
+
+  // TODO: Add your specific tests
+})
+`;
+}

package/dist/store/schema.d.ts

@@ -0,0 +1,9 @@
+export interface StoreSchema {
+    name: string;
+    path: string;
+    flat: boolean;
+    crud: boolean;
+    entity: boolean;
+    devtools: boolean;
+    spec: boolean;
+}

package/dist/store/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@ngstato/schematics",
+  "version": "0.4.0",
+  "private": false,
+  "description": "Angular CLI schematics for ngStato — generate stores, features, and entities",
+  "schematics": "./collection.json",
+  "files": [
+    "dist",
+    "collection.json",
+    "src/store/schema.json",
+    "src/feature/schema.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@angular-devkit/core": "^18.0.0",
+    "@angular-devkit/schematics": "^18.0.0"
+  },
+  "peerDependencies": {
+    "@ngstato/core": ">=0.3.0",
+    "@ngstato/angular": ">=0.3.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/becher/ngStato.git",
+    "directory": "packages/schematics"
+  },
+  "homepage": "https://github.com/becher/ngStato#readme",
+  "author": "becher",
+  "keywords": [
+    "angular",
+    "schematics",
+    "ngstato",
+    "store",
+    "generator",
+    "cli",
+    "ngrx"
+  ]
+}

package/src/feature/schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ngstato-feature-schema",
+  "title": "ngStato Feature Schematic",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the feature (e.g. 'loading', 'pagination')",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "What name would you like for the feature?"
+    },
+    "path": {
+      "type": "string",
+      "description": "Path to create the feature in",
+      "default": "src/app/store-features"
+    }
+  },
+  "required": ["name"]
+}

package/src/store/schema.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "ngstato-store-schema",
+  "title": "ngStato Store Schematic",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the store (e.g. 'users', 'products')",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "What name would you like to use for the store?"
+    },
+    "path": {
+      "type": "string",
+      "description": "The path to create the store in",
+      "default": "src/app/stores",
+      "visible": false
+    },
+    "flat": {
+      "type": "boolean",
+      "description": "Create the store file directly in the path without a subdirectory",
+      "default": false
+    },
+    "crud": {
+      "type": "boolean",
+      "description": "Generate CRUD actions (load, create, update, delete)",
+      "default": true,
+      "x-prompt": "Include CRUD actions?"
+    },
+    "entity": {
+      "type": "boolean",
+      "description": "Use entity adapter for normalized collections",
+      "default": false,
+      "x-prompt": "Use entity adapter?"
+    },
+    "devtools": {
+      "type": "boolean",
+      "description": "Connect to DevTools",
+      "default": true
+    },
+    "spec": {
+      "type": "boolean",
+      "description": "Generate a spec file for the store",
+      "default": true
+    }
+  },
+  "required": ["name"]
+}