feat: 🎸 add store structure generator

Author: Jarek Kuliga

generators/structure-inner/index.ts

@@ -11,7 +11,7 @@ const moduleListMessage = (task: string) =>
 const moduleInputMessage = (task: string) =>
   `What's the new Module name to put the ${task} into?`;
 
-const tasksToModuleNameIdentityCheck = [Task.API, Task.MODEL];
+const tasksToModuleNameIdentityCheck = [Task.API, Task.MODEL, Task.STORE];
 
 export = class StructureInnerGenerator extends Generator {
   private module: string;

generators/structure-store/index.ts

@@ -0,0 +1,40 @@
+import camelCase from "lodash/fp/camelCase";
+import toUpper from "lodash/fp/toUpper";
+import Generator from "yeoman-generator";
+
+import { nameQuestion } from "../../src/questions";
+
+export = class StructureApiGenerator extends Generator {
+  private name: string;
+  private module: string;
+
+  public async prompting() {
+    const { name } = await this.prompt(
+      nameQuestion("Store", this.options.name)
+    );
+
+    this.name = this.options.name || name;
+  }
+
+  public makeModule() {
+    this.module = this.options.module || this.name;
+  }
+
+  public writing() {
+    ["action", "detector", "reducer", "selector", "state"].forEach(file => {
+      this.fs.copyTpl(
+        this.templatePath(`${file}.ts`),
+        this.destinationPath(
+          `./${this.config.get("rootDir")}/${this.module}/store/${this.name}/${
+            this.name
+          }.${file}.ts`
+        ),
+        {
+          name: this.name,
+          nameCamelCase: camelCase(this.name),
+          nameUpperCase: toUpper(this.name)
+        }
+      );
+    });
+  }
+};

generators/structure-store/templates/action.ts

@@ -0,0 +1 @@
+export namespace <%= name %>Action {}

generators/structure-store/templates/detector.ts

@@ -0,0 +1 @@
+export const <%= nameCamelCase %>Detector;

generators/structure-store/templates/reducer.ts

@@ -0,0 +1,4 @@
+import { combineReducers } from "redux";
+import { <%= name %>State } from './<%= name %>.state';
+
+export const <%= nameCamelCase %>Reducer = combineReducers<<%= name %>State>({});

generators/structure-store/templates/selector.ts

@@ -0,0 +1,5 @@
+import { <%= name %>MountedState, <%= name %>State } from './<%= name %>.state';
+
+export namespace <%= name %>Selector {
+  const getDomain = (state?: <%= name %>MountedState) => (state && state.<%= nameCamelCase %>) || ({} as <%= name %>State)
+}

generators/structure-store/templates/state.ts

@@ -0,0 +1,10 @@
+export type <%= name %>State = {};
+
+export namespace <%= name %>State {
+  export const INITIAL: <%= name %>State = {};
+  export const DOMAIN = "<%= nameUpperCase %>";
+}
+
+export type <%= name %>MountedState = {
+  <%= nameCamelCase %>?: <%= name %>State;
+};

generators/structure/index.ts

@@ -28,6 +28,10 @@ export = class StructureGenerator extends Generator {
           {
             name: `Module ${emoji.get("large_orange_diamond")}`,
             value: Task.MODULE
+          },
+          {
+            name: `Store`,
+            value: Task.STORE
           }
         ]
       }
@@ -40,6 +44,7 @@ export = class StructureGenerator extends Generator {
       case Task.COMPONENT:
       case Task.API:
       case Task.MODEL:
+      case Task.STORE:
         this.composeWith(require.resolve(`../structure-inner`), { task });
     }
   }

src/enum/Task.ts

@@ -4,15 +4,17 @@ export enum Task {
   COMPONENT = "component",
   API = "api",
   MODEL = "model",
-  MODULE = "module"
+  MODULE = "module",
+  STORE = "store"
 }
 
 export namespace Task {
   const LABELS = {
     [Task.COMPONENT]: upperFirst(Task.COMPONENT),
     [Task.API]: upperFirst(Task.API),
     [Task.MODEL]: upperFirst(Task.MODEL),
-    [Task.MODULE]: upperFirst(Task.MODULE)
+    [Task.MODULE]: upperFirst(Task.MODULE),
+    [Task.STORE]: upperFirst(Task.STORE)
   };
 
   export function getLabel(task: Task): string {

tests/structure-store.spec.ts

@@ -0,0 +1,75 @@
+import assert from "yeoman-assert";
+import helpers from "yeoman-test";
+
+describe("yo codibly-ts:structure-store", () => {
+  beforeAll(async () => {
+    await helpers
+      .run(require("../generators/structure"), {
+        resolved: require.resolve("../generators/structure/index.js"),
+        namespace: "codibly-ts:structure"
+      })
+      .withLocalConfig({ rootDir: "tmp" })
+      .withPrompts({
+        task: "store",
+        isTaskNameSameAsModule: false,
+        module: "UserDetails",
+        name: "User"
+      });
+  });
+
+  const path = "tmp/UserDetails/store/User/User";
+
+  const actionPath = `${path}.action.ts`;
+  const detectorPath = `${path}.detector.ts`;
+  const reducerPath = `${path}.reducer.ts`;
+  const selectorPath = `${path}.selector.ts`;
+  const statePath = `${path}.state.ts`;
+
+  it("generates required files", () => {
+    assert.file([
+      actionPath,
+      detectorPath,
+      reducerPath,
+      selectorPath,
+      statePath
+    ]);
+  });
+
+  it("creates proper content in Action", () => {
+    assert.fileContent(actionPath, "namespace UserAction {}");
+  });
+
+  it("creates proper content in Detector", () => {
+    assert.fileContent(detectorPath, "const userDetector;");
+  });
+
+  it("creates proper content in Reducer", () => {
+    assert.fileContent(
+      reducerPath,
+      "import { UserState } from './User.state';"
+    );
+    assert.fileContent(
+      reducerPath,
+      "export const userReducer = combineReducers<UserState>({});"
+    );
+  });
+
+  it("create proper content in Selector", () => {
+    assert.fileContent(
+      selectorPath,
+      "import { UserMountedState, UserState } from './User.state';"
+    );
+    assert.fileContent(selectorPath, "namespace UserSelector");
+    assert.fileContent(
+      selectorPath,
+      "const getDomain = (state?: UserMountedState) => (state && state.user) || ({} as UserState)"
+    );
+  });
+
+  it("create proper content in State", () => {
+    assert.fileContent(statePath, "namespace UserState");
+    assert.fileContent(statePath, "const INITIAL: UserState = {};");
+    assert.fileContent(statePath, 'const DOMAIN = "USER";');
+    assert.fileContent(statePath, "type UserMountedState");
+  });
+});