feat(store): allow auto action generation per state using a service

Author: sheriffMoose

demo/src/app/app.component.ts

@@ -31,7 +31,7 @@ export class AppComponent implements OnInit {
         });
         break;
       case 'log':
-        this.store.dispatch('App', 'APP_LOG', { age: 123 }).subscribe((data) => {
+        this.store.dispatch('App', 'APP_LOG', { name: 'John Smith', age: 37 }).subscribe((data) => {
           this.logs.unshift({ action: 'log', type: 'subscribe', data });
         });
         break;

demo/src/app/app.service.ts

@@ -1,5 +1,5 @@
 import { HttpClient } from '@angular/common/http';
-import { Injectable } from '@angular/core';
+import { inject, Injectable } from '@angular/core';
 
 export type LogObject = { name: string, age: number };
 export type DispatchObject = {
@@ -14,7 +14,7 @@ export type DispatchObject = {
 
 @Injectable({ providedIn: 'root' })
 export class AppService {
-  constructor(private http: HttpClient) { }
+  http = inject(HttpClient);
 
   appLog(args: LogObject) {
     console.log('###', 'appLog', args);

demo/src/app/app.store.ts

@@ -34,17 +34,8 @@ export const AppStoreStates = [
     name: 'App',
     fallback: ['Shared'],
     initial: <AppState>{},
+    service: AppService,
     actions: [
-      new StoreAction({
-        name: 'APP_LOG',
-        service: AppService,
-        method: 'appLog',
-      }),
-      new StoreAction({
-        name: 'APP_DISPATCH',
-        service: AppService,
-        method: 'appDispatch',
-      }),
       new StoreAction({
         name: 'APP_DEPRECATED',
         deprecated: true,

src/models/store.action.ts

@@ -1,23 +1,23 @@
 import { ActionStatus, DefaultActions } from "../shared/store.enums";
-import { ActionMethod, ActionPayload, ActionService, RequireOnly } from "../shared/store.types";
+import { MethodArguments, RequireOnly, Service, ServiceClass, ServiceMethod } from "../shared/store.types";
 import { UpdateFlag } from "./store.options";
 
 
 
-type StoreActionInput<K extends string, S extends ActionService, M extends ActionMethod<S>, D extends boolean = boolean, F extends string = string> =
+type StoreActionInput<K extends string, S extends Service, M extends ServiceMethod<S>, D extends boolean = boolean, F extends string = string> =
   | RequireOnly<StoreAction<K, S, M, D, F>, 'name' | 'fallback'>
   | RequireOnly<StoreAction<K, S, M, D, F>, 'name' | 'service' | 'method'>
   | Partial<StoreAction<K, S, M, D, F>>;
 
 
-export class StoreAction<K extends string = string, S extends ActionService = ActionService, M extends ActionMethod<S> = ActionMethod<S>, D extends boolean = boolean, F extends string = string> {
+export class StoreAction<K extends string = string, S extends Service = Service, M extends ServiceMethod<S> = ServiceMethod<S>, D extends boolean = boolean, F extends string = string> {
   name!: K;
   state?: string;
 
-  service!: new (...args: any[]) => S;
+  service!: ServiceClass<S>;
   method!: M;
   fallback?: F[];
-  payload?: ActionPayload<S, M>;
+  payload?: MethodArguments<S, M>;
   uuid?: string;
   status?: ActionStatus = undefined as any;
 

src/models/store.state.ts

@@ -1,6 +1,7 @@
 import { Provider } from "@angular/core";
 import { DefaultActions } from "../shared/store.enums";
 import { provideStoreStates } from "../shared/store.providers";
+import { Service, ServiceClass } from "../shared/store.types";
 import { MergeReducer } from "../variations/merge.reducer";
 import { StorageReducer } from "../variations/storage.reducer";
 import { StoreAction } from "./store.action";
@@ -9,27 +10,47 @@ import { StoreReducer } from "./store.reducer";
 
 const DefaultReducers = [StoreReducer, MergeReducer, StorageReducer];
 
-export class StoreState<T extends any = any, A extends any[] = any[], K extends string = string, F extends string = string> {
+export class StoreState<M extends any = any, N extends string = string, S extends Service = Service, A extends any[] = any[], F extends string = string> {
   app?: string;
-  name: K;
-  initial: T;
+  name: N;
+  initial: M;
+  service: ServiceClass<S>;
   actions: A;
   fallback: F[] = [];
   options: StoreOptions;
   reducers: StoreReducer[] = [];
 
-  constructor(state?: Partial<StoreState<T, A, K, F>>, autoExtend = true) {
+  constructor(state?: Partial<StoreState<M, N, S, A, F>>, autoExtend = true) {
     this.app = state?.app;
     this.name = !state || typeof (state) === 'string' ? state as any : state.name;
-    this.initial = state?.initial || {} as T;
+    this.initial = state?.initial || {} as M;
+    this.service = state?.service as ServiceClass<S>;
     this.fallback = state?.fallback || [] as F[];
     this.options = state?.options || {};
     this.reducers = state?.reducers || [];
     this.actions = state?.actions as A || [];
 
+    if (this.service) {
+      Object.getOwnPropertyNames(this.service.prototype)
+        .forEach(key => {
+          const isFunction = key !== 'constructor' && typeof this.service.prototype[key] === 'function';
+          const name = key.split(/(?=[A-Z])/).join('_').toUpperCase();
+          const isNew = !this.actions.find(x => x.name == name);
+          if (isFunction && isNew) {
+            const action = new StoreAction({
+              name,
+              service: this.service,
+              method: key as any
+            }, this.name);
+            this.actions.push(action);
+          }
+        });
+    }
+
+
     Object.keys(DefaultActions).forEach(action => {
       if (!this.actions.find(x => x.name == action)) {
-        this.actions.push(new StoreAction(action as any, this.name));
+        this.actions.push(new StoreAction(action as any, this.name) as any);
       }
     });
 
@@ -41,30 +62,20 @@ export class StoreState<T extends any = any, A extends any[] = any[], K extends
 
   }
 
-  update(state: any, action: StoreAction): T {
-  this.reducers?.forEach(reducer => {
-       state = reducer.prePopulate(this as any, state, action as StoreAction);
-     });
-     this.reducers?.forEach(reducer => {
-       state = reducer.onPopulate(this as any, state, action as StoreAction);
-     });
-     this.reducers?.forEach(reducer => {
-       state = reducer.postPopulate(this as any, state, action as StoreAction);
-     });
-     return state;
+  update(state: any, action: StoreAction): M {
+    this.reducers?.forEach(reducer => {
+      state = reducer.prePopulate(this as any, state, action as StoreAction);
+    });
+    this.reducers?.forEach(reducer => {
+      state = reducer.onPopulate(this as any, state, action as StoreAction);
+    });
+    this.reducers?.forEach(reducer => {
+      state = reducer.postPopulate(this as any, state, action as StoreAction);
+    });
+    return state;
   }
 
   provideState(): Provider[] {
     return provideStoreStates([this], { app: this.app })
   }
-
-  private addAction() {
-
-  }
-  private addReducer(reducer: any) {
-    if (!this.reducers.find(x => x instanceof reducer)) {
-      this.reducers.push(new reducer());
-    }
-
-  }
 }

src/services/store.facade.ts

@@ -3,7 +3,7 @@ import { exhaustMap, Observable, of } from 'rxjs';
 import { UpdateFlag } from '../models/store.options';
 import { StoreState } from '../models/store.state';
 import { DefaultActions } from '../shared/store.enums';
-import { DeepPartial, DispatchPayload, DispatchResponse, State, StateActionNames, StateData, StateFormatter, StateKey } from '../shared/store.types';
+import { ActionKey, DeepPartial, DispatchArguments, DispatchPayload, DispatchResponse, State, StateAction, StateActionNames, StateActionPayload, StateData, StateFormatter, StateKey } from '../shared/store.types';
 import { isEmpty } from '../shared/store.utils';
 import { StoreDispatcher } from './store.dispatcher';
 import { StoreManager } from './store.manager';
@@ -36,7 +36,7 @@ export class StoreFacade<States extends StoreState[], Keys extends string = Stat
     }
   }
 
-  dispatch<K extends Keys, S extends StoreState = State<States, K>, N extends string = StateActionNames<S>, P = DispatchPayload<S, N>>(stateKey: K, actionKey: N, payload?: P, flag?: UpdateFlag): Observable<DispatchResponse<S, N>> {
+  dispatch<K extends Keys, S extends StoreState = State<States, K>, N extends string = StateActionNames<S>>(stateKey: K, actionKey: ActionKey<S, N>, ...[payload, flag]: DispatchArguments<S,N>): Observable<DispatchResponse<S, N>> {
     const action = this.dispatcher.dispatch(stateKey, actionKey, payload, flag);
     return this.manager.observable(stateKey, action);
   }

src/shared/store.types.ts

@@ -1,30 +1,37 @@
 import { Observable } from "rxjs";
 import { StoreAction } from "../models/store.action";
+import { UpdateFlag } from "../models/store.options";
 import { StoreState } from "../models/store.state";
 import { DefaultActions } from "./store.enums";
 
 export type StateKey<S extends StoreState[]> = S[number]['name'];
 export type State<S extends StoreState[], K extends StateKey<S>> = Extract<S[number], { name: K; }>;
 export type StateData<S extends StoreState> = S['initial'];
-export type StateActions<S extends StoreState> = S['actions'];
-export type StateActionNames<S extends StoreState> = S['actions'][number]['name'] | keyof typeof DefaultActions;
+export type StateActions<S extends StoreState, SV = InstanceType<S['service']>> = SV extends never ? S['actions'] : ServiceActions<SV> | S['actions'];
+export type StateActionNames<S extends StoreState> = StateActions<S>[number]['name'];
+export type ActionKey<S extends StoreState, N extends string> = N extends (StateActionNames<S> | DefaultActions) ? N : never;
 export type StateAction<S extends StoreState, N extends StateActionNames<S>> = Extract<StateActions<S>[number], { name: N }>;
 
-export type StateActionPayload<A extends StoreAction> = A['payload'];
-export type StateActionReturn<A extends StoreAction> = ActionResponse<InstanceType<A['service']>, A['method']>;
+export type StateActionPayload<A extends StoreAction> = MethodArguments<InstanceType<A['service']>, A['method']>;
+export type StateActionReturn<A extends StoreAction> = MethodReturnType<InstanceType<A['service']>, A['method']>;
 export type DeprecatedActions<S extends StoreState> = Extract<StateActions<S>[number], { deprecated: true; }>['name'];
 export type ActiveActions<S extends StoreState> = Exclude<StateActions<S>[number]['name'], DeprecatedActions<S>>;
 
-export type DispatchPayload<S extends StoreState, N extends StateActionNames<S>, A extends StoreAction = StateAction<S, N>> = StateActionPayload<A> extends undefined ? DeepPartial<StateData<S>> | string | number | boolean : DeepPartial<StateActionPayload<A>>;
+export type DispatchArguments<S extends StoreState, N extends StateActionNames<S>, A extends StoreAction = StateAction<S, N>> = StateActionPayload<A> extends undefined ? [DispatchPayload<S, N>?, UpdateFlag?] : [DispatchPayload<S, N>, UpdateFlag?];
+export type DispatchPayload<S extends StoreState, N extends StateActionNames<S>, A extends StoreAction = StateAction<S, N>> = StateActionPayload<A> extends undefined ? DeepPartial<StateData<S>> | string | number | boolean : StateActionPayload<A>;
 export type DispatchResponse<S extends StoreState, N extends StateActionNames<S>, A extends StoreAction = StateAction<S, N>, R = StateActionReturn<A>> = N extends keyof typeof DefaultActions ? StateData<S> : `Object` extends R ? StateData<S> : StateData<S> & R;
 
 export type StateFormatter<S extends StoreState> = (payload: StateData<S>) => StateData<S>;
 
 
-export type ActionService = any;
-export type ActionMethod<S extends ActionService> = keyof S;
-export type ActionPayload<S extends ActionService, M extends keyof S> = S[M] extends (...args: any[]) => any ? Parameters<S[M]>[0] : never;
-export type ActionResponse<S extends ActionService, M extends keyof S> = S[M] extends (...args: any[]) => any ? (ReturnType<S[M]> extends Observable<infer R> ? R : ReturnType<S[M]>) : never;
+export type Service = unknown;
+export type ServiceClass<S extends Service> = new (...args: any[]) => S;
+export type ServiceMethod<S extends Service> = { [K in keyof S]: S[K] extends (...args: any[]) => any ? K : never; }[keyof S];
+export type ServiceActions<S extends Service> = { [K in ServiceMethod<S>]: StoreAction<CamelToSnakeCase<string & K>, S, string & K> }[ServiceMethod<S>][];
+export type MethodArguments<S extends Service, M extends keyof S> = S[M] extends (...args: any[]) => any ? Parameters<S[M]>[0] : never;
+export type MethodReturnType<S extends Service, M extends keyof S> = S[M] extends (...args: any[]) => any ? (ReturnType<S[M]> extends Observable<infer R> ? R : ReturnType<S[M]>) : never;
 
 export type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]; };
 export type RequireOnly<T, R extends keyof T> = Required<Pick<T, R>> & Partial<Omit<T, R>>;
+
+export type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? `${T extends Capitalize<T> ? "_" : ""}${Uppercase<T>}${CamelToSnakeCase<U>}` : S;