About to fix __internal_getter__ issues

Author: michaelolof

src/getters.legacy.ts

@@ -3,4 +3,9 @@
  * The getter decorator exists just for backward compatibility.
  * Not doing anything.
  */
-export const getter = (target:any, propertyKey:string) => undefined
+export const getter = (target:any, propertyKey:string) => {
+  if( target.__decorator_getter_names__  === undefined ) {
+    target.__decorator_getter_names__ = [ propertyKey ];
+  }
+  else target.__decorator_getter_names__.push( propertyKey );
+}

src/interfaces.ts

@@ -41,6 +41,7 @@ export interface VuexModuleInternalsPrototype {
     __setter_mutations__: {},
   };
   __explicit_getter_names__ :string[];
+  __decorator_getter_names__ :string[];
   __explicit_mutations_names__: string[],
   __actions__: {
     __name__ :string,

src/module.legacy.ts

@@ -2,6 +2,7 @@ import { VuexModuleConstructor, VuexModule, VuexModuleAddons, Map } from "./inte
 import { createModule, extractVuexModule } from "./module";
 import { createProxy, clearProxyCache } from './proxy';
 import { createSubModule } from './submodule';
+import { getClassPath, toCamelCase } from "./utils";
 
 const defaultModuleOptions :ModuleOptions = {
   namespacedPath: "",
@@ -44,15 +45,16 @@ export class LegacyVuexModule {
     const VuexClass = cls as VuexModule & VuexModuleConstructor;
 
     const vxmodule = extractVuexModule( VuexClass );
-
-    return vxmodule[ VuexClass.prototype.__namespacedPath__ ];
+    const path = getClassPath( VuexClass.prototype.__namespacedPath__ ) || toCamelCase( VuexClass.name );
+    console.log( "Module", vxmodule, "Path", path );
+    return vxmodule[ path ];
   }
 
   static CreateProxy<T extends typeof VuexModule>( $store :Map, cls :T ) {
     return createProxy( $store, cls );
   }
 
-  static CreateSubModule( cls :typeof VuexModule ) {
+  static CreateSubModule<T extends typeof VuexModule>( cls :T ) {
     return createSubModule( cls );
   }
 

src/module.ts

@@ -30,6 +30,7 @@ export function createModule( options ?:VuexModuleOptions ) {
   (VuexModule as VuexModuleConstructor).prototype.__actions__ = [];
   (VuexModule as VuexModuleConstructor).prototype.__watch__ = {};
   (VuexModule as VuexModuleConstructor).prototype.__explicit_getter_names__ = [];
+  (VuexModule as VuexModuleConstructor).prototype.__decorator_getter_names__ = [];
 
   return VuexModule;
 
@@ -57,17 +58,18 @@ export function extractVuexModule( cls :typeof VuexModule ) {
     namespaced: VuexClass.prototype.__options__ && VuexClass.prototype.__options__.namespaced ? true : false,
     state: fromInstance.state,
     mutations: { ...fromPrototype.mutations.explicitMutations, ...fromPrototype.mutations.setterMutations, __internal_mutator__: internalMutator },
-    getters: { ...fromPrototype.getters, __internal_getter__: internalGetter },
+    getters: { ...fromPrototype.getters, ...fromInstance.getters , __internal_getter__: internalGetter },
     actions: { ...fromPrototype.actions, __internal_action__: internalAction },
     modules: fromInstance.submodules,
   };
 
-  // Cache the vuex module on the class.
-  const className = getNamespacedPath( VuexClass );
 
-  const rtn = { [ className ]: vuexModule }
-  VuexClass.prototype.__vuex_module_cache__ = rtn;
+  // Cache the vuex module on the class.
+  const path = getNamespacedPath( VuexClass ) || toCamelCase( VuexClass.name );
 
+  const rtn = { [ path ]: vuexModule }
+  VuexClass.prototype.__vuex_module_cache__ = rtn;
+  
   return rtn;
 
 }
@@ -121,6 +123,7 @@ function extractModulesFromInstance( cls :VuexModuleConstructor ) {
   return {
     submodules,
     mutations,
+    getters: extractDecoratorGetterNames( cls.prototype.__decorator_getter_names__ ),
     // Check if the vuex module is targeting nuxt return state as function. if not define state as normal.    
     state: moduleOptions.target === "nuxt" ? () => state : state,
   }
@@ -256,4 +259,12 @@ function extractModulesFromPrototype( cls :VuexModuleConstructor ) {
     getters
   }
 
+}
+
+function extractDecoratorGetterNames( names :string[] ) {
+  const decorator = {};
+  for( let name of names ) {
+    decorator[ name ] = new Function("state", `return state.${name}`);
+  }
+  return decorator;
 }

src/proxy.ts

@@ -1,5 +1,6 @@
 import { extractVuexModule } from "./module";
 import { VuexModuleConstructor, Map, VuexModule, ProxyWatchers } from "./interfaces";
+import { getClassPath, toCamelCase } from "./utils";
 
 
 export function clearProxyCache<T extends typeof VuexModule>( cls :T ) {
@@ -114,7 +115,9 @@ export function _createProxy<T>(cls: T, $store: any, namespacedPath = "") {
   //@ts-ignore
   const VuexClass = cls as VuexModuleConstructor;
   const proxy = {};
-  const { state, mutations, actions, getters, modules } = extractVuexModule( VuexClass )[ VuexClass.prototype.__namespacedPath__ ];
+  
+  const classPath = getClassPath( VuexClass.prototype.__namespacedPath__ ) || toCamelCase( VuexClass.name );
+  const { state, mutations, actions, getters, modules } = extractVuexModule( VuexClass )[ classPath ];
 
   createGettersAndMutationProxyFromState({ cls: VuexClass, proxy, state, $store, namespacedPath, maxDepth: 7 });
   createExplicitMutationsProxy( VuexClass, proxy, $store, namespacedPath );
@@ -261,7 +264,8 @@ function createLocalWatchers( cls :VuexModuleConstructor, $store :Map, namespace
 function createSubModuleProxy( $store :Map, cls:VuexModuleConstructor, proxy :Map, modules :Map ) {
   const store = cls.prototype.__store_cache__ || $store;
   for( let field in modules ) {
-    const subModuleClass = cls.prototype.__submodules_cache__[ field ];
+    const subModuleClass = cls.prototype.__submodules_cache__[ field ] as VuexModuleConstructor;
+    subModuleClass.prototype.__namespacedPath__ = cls.prototype.__namespacedPath__ + "/" + subModuleClass.prototype.__namespacedPath__;
     proxy[ field ] = createProxy( store, subModuleClass );
   }
 
@@ -365,6 +369,8 @@ function createGettersAndGetterMutationsProxy({ cls, getters, mutations, proxy,
     }
 
     // The field has only a getter.
+    if( proxy[ field ] ) continue;
+    
     Object.defineProperty( proxy, field, {
       get: () => { 
         if( $store.getters ) return $store.getters[ namespacedPath + field ];
@@ -391,7 +397,6 @@ function runSetterCheck( cls :VuexModuleConstructor, getters :Map ) {
   // if there are setters defined that are not in getters.
   // throw an error.
   const setterMutations = cls.prototype.__mutations_cache__.__setter_mutations__;
-  console.log( "Setter Mutations", cls.name, setterMutations );
   for( let field in setterMutations ) {
     const setterIsNotInGetters = Object.keys( getters ).indexOf( field ) < 0;
     if( setterIsNotInGetters ) {

src/submodule.ts

@@ -1,6 +1,6 @@
-import { VuexModule, SubModuleType, Map, VuexObject } from "./interfaces";
+import { VuexModule, SubModuleType, Map, VuexObject, VuexModuleConstructor } from "./interfaces";
 import { extractVuexModule } from "./module";
-import { toCamelCase } from "./utils"
+import { toCamelCase, getClassPath } from "./utils"
 
 export function isFieldASubModule( instance :VuexModule & Map, field :string ) {
   return( 
@@ -10,8 +10,10 @@ export function isFieldASubModule( instance :VuexModule & Map, field :string ) {
 }
 
 export function extractVuexSubModule( instance :VuexModule & Map, field :string ) {
-  const subModuleClass = instance[ field ][ "__submodule_class__" ];  
-  return extractVuexModule( subModuleClass  )[ toCamelCase( subModuleClass.name ) ] as VuexObject
+  const subModuleClass = instance[ field ][ "__submodule_class__" ] as VuexModule & VuexModuleConstructor;
+  const extract = extractVuexModule( subModuleClass  );
+  const path = getClassPath( subModuleClass.prototype.__namespacedPath__ ) || toCamelCase( subModuleClass.name );
+  return extract[ path ];
 }
 
 export function createSubModule<T>( Cls :T ) {

src/utils.ts

@@ -1,3 +1,8 @@
 export function toCamelCase(str :string){
   return str[ 0 ].toLocaleLowerCase() + str.substring( 1 );
-}
+}
+
+export function getClassPath( path :string ) {
+  const arr = path.split( "/" );
+  return arr[ arr.length - 1 ];
+}

test-ts

@@ -1 +1 @@
-Subproject commit 7549bff4f3e48f5b58d1ebcfdc369dbdbc43eb9d
+Subproject commit 5343f33db3f06798e3bbf6a817e74193422cfa8d