@@ -64,168 +64,168 @@  | 
                                                    ||
| 64 | 64 |      { | 
                                                        
| 65 | 65 | $this->app->singleton(  | 
                                                        
| 66 | 66 | 'artomator.publish',  | 
                                                        
| 67 | -            function ($app) { | 
                                                        |
| 67 | +            function($app) { | 
                                                        |
| 68 | 68 | return new GeneratorPublishCommand();  | 
                                                        
| 69 | 69 | }  | 
                                                        
| 70 | 70 | );  | 
                                                        
| 71 | 71 | |
| 72 | 72 | $this->app->singleton(  | 
                                                        
| 73 | 73 | 'artomator.api',  | 
                                                        
| 74 | -            function ($app) { | 
                                                        |
| 74 | +            function($app) { | 
                                                        |
| 75 | 75 | return new APIGeneratorCommand();  | 
                                                        
| 76 | 76 | }  | 
                                                        
| 77 | 77 | );  | 
                                                        
| 78 | 78 | |
| 79 | 79 | $this->app->singleton(  | 
                                                        
| 80 | 80 | 'artomator.scaffold',  | 
                                                        
| 81 | -            function ($app) { | 
                                                        |
| 81 | +            function($app) { | 
                                                        |
| 82 | 82 | return new ScaffoldGeneratorCommand();  | 
                                                        
| 83 | 83 | }  | 
                                                        
| 84 | 84 | );  | 
                                                        
| 85 | 85 | |
| 86 | 86 | $this->app->singleton(  | 
                                                        
| 87 | 87 | 'artomator.publish.layout',  | 
                                                        
| 88 | -            function ($app) { | 
                                                        |
| 88 | +            function($app) { | 
                                                        |
| 89 | 89 | return new LayoutPublishCommand();  | 
                                                        
| 90 | 90 | }  | 
                                                        
| 91 | 91 | );  | 
                                                        
| 92 | 92 | |
| 93 | 93 | $this->app->singleton(  | 
                                                        
| 94 | 94 | 'artomator.publish.templates',  | 
                                                        
| 95 | -            function ($app) { | 
                                                        |
| 95 | +            function($app) { | 
                                                        |
| 96 | 96 | return new PublishTemplateCommand();  | 
                                                        
| 97 | 97 | }  | 
                                                        
| 98 | 98 | );  | 
                                                        
| 99 | 99 | |
| 100 | 100 | $this->app->singleton(  | 
                                                        
| 101 | 101 | 'artomator.api_scaffold',  | 
                                                        
| 102 | -            function ($app) { | 
                                                        |
| 102 | +            function($app) { | 
                                                        |
| 103 | 103 | return new APIScaffoldGeneratorCommand();  | 
                                                        
| 104 | 104 | }  | 
                                                        
| 105 | 105 | );  | 
                                                        
| 106 | 106 | |
| 107 | 107 | $this->app->singleton(  | 
                                                        
| 108 | 108 | 'artomator.migration',  | 
                                                        
| 109 | -            function ($app) { | 
                                                        |
| 109 | +            function($app) { | 
                                                        |
| 110 | 110 | return new MigrationGeneratorCommand();  | 
                                                        
| 111 | 111 | }  | 
                                                        
| 112 | 112 | );  | 
                                                        
| 113 | 113 | |
| 114 | 114 | $this->app->singleton(  | 
                                                        
| 115 | 115 | 'artomator.model',  | 
                                                        
| 116 | -            function ($app) { | 
                                                        |
| 116 | +            function($app) { | 
                                                        |
| 117 | 117 | return new ModelGeneratorCommand();  | 
                                                        
| 118 | 118 | }  | 
                                                        
| 119 | 119 | );  | 
                                                        
| 120 | 120 | |
| 121 | 121 | $this->app->singleton(  | 
                                                        
| 122 | 122 | 'artomator.repository',  | 
                                                        
| 123 | -            function ($app) { | 
                                                        |
| 123 | +            function($app) { | 
                                                        |
| 124 | 124 | return new RepositoryGeneratorCommand();  | 
                                                        
| 125 | 125 | }  | 
                                                        
| 126 | 126 | );  | 
                                                        
| 127 | 127 | |
| 128 | 128 | $this->app->singleton(  | 
                                                        
| 129 | 129 | 'artomator.api.controller',  | 
                                                        
| 130 | -            function ($app) { | 
                                                        |
| 130 | +            function($app) { | 
                                                        |
| 131 | 131 | return new APIControllerGeneratorCommand();  | 
                                                        
| 132 | 132 | }  | 
                                                        
| 133 | 133 | );  | 
                                                        
| 134 | 134 | |
| 135 | 135 | $this->app->singleton(  | 
                                                        
| 136 | 136 | 'artomator.api.requests',  | 
                                                        
| 137 | -            function ($app) { | 
                                                        |
| 137 | +            function($app) { | 
                                                        |
| 138 | 138 | return new APIRequestsGeneratorCommand();  | 
                                                        
| 139 | 139 | }  | 
                                                        
| 140 | 140 | );  | 
                                                        
| 141 | 141 | |
| 142 | 142 | $this->app->singleton(  | 
                                                        
| 143 | 143 | 'artomator.api.tests',  | 
                                                        
| 144 | -            function ($app) { | 
                                                        |
| 144 | +            function($app) { | 
                                                        |
| 145 | 145 | return new TestsGeneratorCommand();  | 
                                                        
| 146 | 146 | }  | 
                                                        
| 147 | 147 | );  | 
                                                        
| 148 | 148 | |
| 149 | 149 | $this->app->singleton(  | 
                                                        
| 150 | 150 | 'artomator.scaffold.controller',  | 
                                                        
| 151 | -            function ($app) { | 
                                                        |
| 151 | +            function($app) { | 
                                                        |
| 152 | 152 | return new ControllerGeneratorCommand();  | 
                                                        
| 153 | 153 | }  | 
                                                        
| 154 | 154 | );  | 
                                                        
| 155 | 155 | |
| 156 | 156 | $this->app->singleton(  | 
                                                        
| 157 | 157 | 'artomator.scaffold.requests',  | 
                                                        
| 158 | -            function ($app) { | 
                                                        |
| 158 | +            function($app) { | 
                                                        |
| 159 | 159 | return new RequestsGeneratorCommand();  | 
                                                        
| 160 | 160 | }  | 
                                                        
| 161 | 161 | );  | 
                                                        
| 162 | 162 | |
| 163 | 163 | $this->app->singleton(  | 
                                                        
| 164 | 164 | 'artomator.scaffold.views',  | 
                                                        
| 165 | -            function ($app) { | 
                                                        |
| 165 | +            function($app) { | 
                                                        |
| 166 | 166 | return new ViewsGeneratorCommand();  | 
                                                        
| 167 | 167 | }  | 
                                                        
| 168 | 168 | );  | 
                                                        
| 169 | 169 | |
| 170 | 170 | $this->app->singleton(  | 
                                                        
| 171 | 171 | 'artomator.scaffold.routes',  | 
                                                        
| 172 | -            function ($app) { | 
                                                        |
| 172 | +            function($app) { | 
                                                        |
| 173 | 173 | return new RoutesGeneratorCommand();  | 
                                                        
| 174 | 174 | }  | 
                                                        
| 175 | 175 | );  | 
                                                        
| 176 | 176 | |
| 177 | 177 | $this->app->singleton(  | 
                                                        
| 178 | 178 | 'artomator.rollback',  | 
                                                        
| 179 | -            function ($app) { | 
                                                        |
| 179 | +            function($app) { | 
                                                        |
| 180 | 180 | return new RollbackGeneratorCommand();  | 
                                                        
| 181 | 181 | }  | 
                                                        
| 182 | 182 | );  | 
                                                        
| 183 | 183 | |
| 184 | 184 | $this->app->singleton(  | 
                                                        
| 185 | 185 | 'artomator.publish.user',  | 
                                                        
| 186 | -            function ($app) { | 
                                                        |
| 186 | +            function($app) { | 
                                                        |
| 187 | 187 | return new PublishUserCommand();  | 
                                                        
| 188 | 188 | }  | 
                                                        
| 189 | 189 | );  | 
                                                        
| 190 | 190 | |
| 191 | 191 | $this->app->singleton(  | 
                                                        
| 192 | 192 | 'artomator.graphql',  | 
                                                        
| 193 | -            function ($app) { | 
                                                        |
| 193 | +            function($app) { | 
                                                        |
| 194 | 194 | return new GraphQLGeneratorCommand();  | 
                                                        
| 195 | 195 | }  | 
                                                        
| 196 | 196 | );  | 
                                                        
| 197 | 197 | |
| 198 | 198 | $this->app->singleton(  | 
                                                        
| 199 | 199 | 'artomator.graphql_scaffold',  | 
                                                        
| 200 | -            function ($app) { | 
                                                        |
| 200 | +            function($app) { | 
                                                        |
| 201 | 201 | return new GraphQLScaffoldGeneratorCommand();  | 
                                                        
| 202 | 202 | }  | 
                                                        
| 203 | 203 | );  | 
                                                        
| 204 | 204 | |
| 205 | 205 | $this->app->singleton(  | 
                                                        
| 206 | 206 | 'artomator.graphql.query',  | 
                                                        
| 207 | -            function ($app) { | 
                                                        |
| 207 | +            function($app) { | 
                                                        |
| 208 | 208 | return new GraphQLQueryGeneratorCommand();  | 
                                                        
| 209 | 209 | }  | 
                                                        
| 210 | 210 | );  | 
                                                        
| 211 | 211 | |
| 212 | 212 | $this->app->singleton(  | 
                                                        
| 213 | 213 | 'artomator.graphql.mutations',  | 
                                                        
| 214 | -            function ($app) { | 
                                                        |
| 214 | +            function($app) { | 
                                                        |
| 215 | 215 | return new GraphQLMutationsGeneratorCommand();  | 
                                                        
| 216 | 216 | }  | 
                                                        
| 217 | 217 | );  | 
                                                        
| 218 | 218 | |
| 219 | 219 | $this->app->singleton(  | 
                                                        
| 220 | 220 | 'artomator.graphql.type',  | 
                                                        
| 221 | -            function ($app) { | 
                                                        |
| 221 | +            function($app) { | 
                                                        |
| 222 | 222 | return new GraphQLTypeGeneratorCommand();  | 
                                                        
| 223 | 223 | }  | 
                                                        
| 224 | 224 | );  | 
                                                        
| 225 | 225 | |
| 226 | 226 | $this->app->singleton(  | 
                                                        
| 227 | 227 | 'artomator.graphql.subscription',  | 
                                                        
| 228 | -            function ($app) { | 
                                                        |
| 228 | +            function($app) { | 
                                                        |
| 229 | 229 | return new GraphQLSubscriptionGeneratorCommand();  | 
                                                        
| 230 | 230 | }  | 
                                                        
| 231 | 231 | );  | 
                                                        
@@ -144,7 +144,7 @@ discard block  | 
                                                    ||
| 144 | 144 | (new Process($command, base_path(), ['COMPOSER_MEMORY_LIMIT' => '-1']))  | 
                                                        
| 145 | 145 | ->setTimeout(null)  | 
                                                        
| 146 | 146 | ->run(  | 
                                                        
| 147 | -                function ($type, $output) { | 
                                                        |
| 147 | +                function($type, $output) { | 
                                                        |
| 148 | 148 | $this->output->write($output);  | 
                                                        
| 149 | 149 | }  | 
                                                        
| 150 | 150 | );  | 
                                                        
@@ -190,7 +190,7 @@ discard block  | 
                                                    ||
| 190 | 190 |      { | 
                                                        
| 191 | 191 | tap(  | 
                                                        
| 192 | 192 | new Filesystem,  | 
                                                        
| 193 | -            function ($files) { | 
                                                        |
| 193 | +            function($files) { | 
                                                        |
| 194 | 194 |                  $files->deleteDirectory(base_path('node_modules')); | 
                                                        
| 195 | 195 | |
| 196 | 196 |                  $files->delete(base_path('yarn.lock')); |