├── composer.json
├── readme.md
└── src
    ├── config
        └── vueApi.php
    ├── generate.php
    ├── templates
        ├── controller.blade.php
        ├── model.blade.php
        ├── vue-list.blade.php
        └── vue-single.blade.php
    └── vueApiServiceProvider.php


/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "lummy/laravel-vue-api-crud-generator",
 3 |     "description": "Creates a basic skeleton for a CRUD app in both Laravel & Vue.js single file components.",
 4 |     "authors": [
 5 |         {
 6 |             "name": "Aaron Lumsden",
 7 |             "email": "aaronlumsden@me.com"
 8 |         }
 9 |     ],
10 |     "license": "MIT",
11 |     "require": {},
12 |     "autoload": {
13 |         "psr-4": {
14 |             "lummy\\": "src/"
15 |         }
16 |     },
17 |     "extra": {
18 |     "laravel": {
19 |           "providers": [
20 |               "lummy\\vueApi\\vueApiServiceProvider"
21 |           ]
22 |     }
23 |   }
24 | }
25 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | ## Laravel Vue API Crud Generator
  2 | 
  3 | #### Overview
  4 | A Laravel package that lets you generate boilerplate code for a Vue.js/Laravel app. Simply enter the name of a database table and based on that it will create:
  5 | 
  6 | - A Laravel model
  7 | - A Laravel controller (with get, list, create, update, delete as well as validation based on a chosen DB table)
  8 | - Laravel routes (get, list, create, update, delete)
  9 | - 2 Vue.js single file components to create, update, list, delete and show (using Vform & axios)
 10 | 
 11 | This package aims to speed up the process of communicating between backend (Laravel) and frontend (Vue.js).
 12 | 
 13 | ### Installation
 14 | `composer require lummy/laravel-vue-api-crud-generator`
 15 | 
 16 | 
 17 | ## Usage
 18 | 
 19 | Firstly you should create a new migration in the same way that you usually would. For example if creating a posts table use the command 
 20 | 
 21 | `php artisan make:migration create_posts_table`
 22 | 
 23 | Then in your migration file add your fields as usual
 24 | 
 25 | ```
 26 | Schema::create('posts', function (Blueprint $table) {
 27 |     $table->id();
 28 |     $table->string('title',200);
 29 |     $table->text('content')->nullable();
 30 |     $table->timestamps();
 31 | });
 32 | ```
 33 | 
 34 | Then run the migrate command to create the posts table 
 35 | 
 36 | `php artisan migrate`
 37 | 
 38 | Once you have done that you just need to run one `vueapi` command. Add the name of your table to the end of the command so in this case it's posts.
 39 | 
 40 | `php artisan vueapi:generate posts`
 41 | 
 42 | This will then generate all the files mentioned above.
 43 | 
 44 | Once you have run this command, using the `posts` example above, it will create the following boilerplate files:
 45 | 
 46 | ### Routes 
 47 | 
 48 | Based on a `posts` DB table it will produce these routes
 49 | 
 50 | ```
 51 | Route::get('posts', 'PostsController@list');
 52 | Route::get('posts/{id}', 'PostsController@get');
 53 | Route::post('posts', 'PostsController@create');
 54 | Route::put('posts/{id}', 'PostsController@update');
 55 | Route::delete('posts/{id}', 'PostsController@delete');
 56 | 
 57 | ```
 58 | 
 59 | ### Controller
 60 | 
 61 | Based on a `posts` DB table it will produce this controller
 62 | 
 63 | ```
 64 | <?php 
 65 | namespace App\Http\Controllers;
 66 | 
 67 | use Illuminate\Http\Request;
 68 | use App\Posts;
 69 | 
 70 | class PostsController extends Controller
 71 | {
 72 |     public function get(Request $request, $id){
 73 |       return Posts::findOrFail($id);
 74 |     }
 75 |     
 76 |     public function list(Request $request){
 77 |       return Posts::get();
 78 |     }
 79 |     
 80 |     public function create(Request $request){
 81 |         
 82 |       $validatedData = $request->validate([
 83 |         'title' => 'required |max:200 ',
 84 |         'content' => 'required ',
 85 |         'meta_description' => 'required |max:160 ',
 86 |       ],[
 87 |         'title.required' => 'title is a required field.',
 88 |         'title.max' => 'title can only be 200 characters.',
 89 |         'content.required' => 'content is a required field.',
 90 |         'meta_description.required' => 'meta_description is a required field.',
 91 |         'meta_description.max' => 'meta_description can only be 160 characters.',
 92 |       ]);
 93 | 
 94 |         $posts = Posts::create($request->all());    
 95 |         return $posts;
 96 |     }
 97 |     
 98 |     public function update(Request $request, $id){
 99 |       
100 |       $validatedData = $request->validate([
101 |         'title' => 'required |max:200 ',
102 |         'content' => 'required ',
103 |         'meta_description' => 'required |max:160 ',
104 |       ],[
105 |         'title.required' => 'title is a required field.',
106 |         'title.max' => 'title can only be 200 characters.',
107 |         'content.required' => 'content is a required field.',
108 |         'meta_description.required' => 'meta_description is a required field.',
109 |         'meta_description.max' => 'meta_description can only be 160 characters.',
110 |       ]);
111 | 
112 |         $posts = Posts::findOrFail($id);
113 |         $input = $request->all();
114 |         $posts->fill($input)->save();
115 |         return $posts;
116 |     }
117 |     
118 |     public function delete(Request $request, $id){
119 |         $posts = Posts::findOrFail($id);
120 |         $posts->delete();
121 |     }
122 | }
123 |  ?>
124 | 
125 | ```
126 | ### Model 
127 | 
128 | Based on a `posts` DB table it will produce this model
129 | 
130 | ```
131 | <?php 
132 | namespace App;
133 | 
134 | use Illuminate\Database\Eloquent\Model;
135 | 
136 | class Posts extends Model
137 | {
138 | 
139 |     /**
140 |      * The attributes that should be hidden for arrays.
141 |      *
142 |      * @var  array
143 |      */
144 |     protected $guarded = [
145 |         'id'
146 |     ];
147 | 
148 |     /**
149 |      * The attributes that should be cast to native types.
150 |      *
151 |      * @var  array
152 |      */
153 |     protected $casts = [
154 |         ''
155 |     ];
156 | }?>
157 | 
158 | ```
159 | 
160 | ### Vue (List template)
161 | 
162 | Based on a `posts` DB table it will produce this Vue.js list single file component (Posts-list.vue)
163 | 
164 | ```
165 | <template lang="html">
166 |       <div class="posts">
167 |         
168 |         <div class="half">
169 |           
170 |           <h1>Create post</h1>
171 |           
172 |           <form @submit.prevent="createPost">
173 |             
174 |             <div class="form-group">
175 |    
176 |                   <input type="hidden" v-model="form.id"></input>
177 |             </div>
178 |             <div class="form-group">
179 |                   <label>title</label>
180 |                   <input type="text" v-model="form.title"  maxlength="200" ></input>
181 |                   <has-error :form="form" field="title"></has-error>
182 |             </div>
183 |             <div class="form-group">
184 |                   <label>content</label>
185 |                   <textarea v-model="form.content" ></textarea>
186 |                   <has-error :form="form" field="content"></has-error>
187 |             </div>
188 |             <div class="form-group">
189 |                   <label>meta_description</label>
190 |                   <input type="text" v-model="form.meta_description"  maxlength="160" ></input>
191 |                   <has-error :form="form" field="meta_description"></has-error>
192 |             </div>
193 |             <div class="form-group">
194 |    
195 |                   <input type="hidden" v-model="form.created_at"></input>
196 |             </div>
197 |             <div class="form-group">
198 |    
199 |                   <input type="hidden" v-model="form.updated_at"></input>
200 |             </div>
201 |         
202 |             <div class="form-group">
203 |                 <button class="button" type="submit" :disabled="form.busy" name="button">{{ (form.busy) ? 'Please wait...' : 'Submit'}}</button>
204 |             </div>
205 |           </form>
206 |           
207 |         </div><!-- End first half -->
208 |         
209 |         <div class="half">
210 |           
211 |           <h1>List posts</h1>
212 |           
213 |           <ul v-if="posts.length > 0">
214 |             <li v-for="(post,index) in posts" :key="post.id">
215 |               
216 |             <router-link :to="'/post/'+post.id">
217 |               
218 |               post {{ index }}
219 | 
220 |               <button @click.prevent="deletePost(post,index)" type="button" :disabled="form.busy" name="button">{{ (form.busy) ? 'Please wait...' : 'Delete'}}</button>
221 |               
222 |             </router-link>
223 |               
224 |             </li>
225 |           </ul>
226 |           
227 |           <span v-else-if="!posts">Loading...</span>
228 |           <span v-else>No posts exist</span>
229 |           
230 |         </div><!-- End 2nd half -->
231 |         
232 |       </div>
233 | </template>
234 | 
235 | <script>
236 | import { Form, HasError, AlertError } from 'vform'
237 | export default {
238 |   name: 'Post',
239 |   components: {HasError},
240 |   data: function(){
241 |     return {
242 |       posts : false,
243 |       form: new Form({
244 |           "id" : "",
245 |           "title" : "",
246 |           "content" : "",
247 |           "meta_description" : "",
248 |           "created_at" : "",
249 |           "updated_at" : "",
250 |       })
251 |     }
252 |   },
253 |   created: function(){
254 |     this.listPosts();
255 |   },
256 |   methods: {
257 |     listPosts: function(){
258 |       
259 |       var that = this;
260 |       this.form.get('/posts').then(function(response){
261 |         that.posts = response.data;
262 |       })
263 |       
264 |     },
265 |     createPost: function(){
266 |       
267 |       var that = this;
268 |       this.form.post('/posts').then(function(response){
269 |         that.posts.push(response.data);
270 |       })
271 |       
272 |     },
273 |     deletePost: function(post, index){
274 |       
275 |       var that = this;
276 |       this.form.delete('/posts/'+post.id).then(function(response){
277 |         that.posts.splice(index,1);
278 |       })
279 |       
280 |     }
281 |   }
282 | }
283 | </script>
284 | 
285 | <style lang="less">
286 | .posts{
287 |     margin:0 auto;
288 |     width:700px;
289 |     display:flex;
290 |     .half{
291 |       flex:1;
292 |       &:first-of-type{
293 |         margin-right:20px;
294 |       }
295 |     }
296 |     form{
297 |       .form-group{
298 |         margin-bottom:20px;
299 |         label{
300 |           display:block;
301 |           margin-bottom:5px;
302 |           text-transform: capitalize;
303 |         }
304 |         input[type="text"],input[type="number"],textarea{
305 |           width:100%;
306 |           max-width:100%;
307 |           min-width:100%;
308 |           padding:10px;
309 |           border-radius:3px;
310 |           border:1px solid silver;
311 |           font-size:1rem;
312 |           &:focus{
313 |             outline:0;
314 |             border-color:blue;
315 |           }
316 |         }
317 |         .invalid-feedback{
318 |           color:red;
319 |           &::first-letter{
320 |             text-transform:capitalize;
321 |           }
322 |         }
323 |       }
324 |       .button{
325 |         appearance: none;
326 |         background: #3bdfd9;
327 |         font-size: 1rem;
328 |         border: 0px;
329 |         padding: 10px 20px;
330 |         border-radius: 3px;
331 |         font-weight: bold;
332 |         &:hover{
333 |           cursor:pointer;
334 |           background: darken(#3bdfd9,10);
335 |         }
336 |       }
337 |     }
338 | }
339 | </style>
340 | ```
341 | 
342 | ### Vue (Single template)
343 | 
344 | Based on a `posts` DB table it will produce this Vue.js single file component (Posts-single.vue)
345 | 
346 | ```
347 | <template lang="html">
348 |       <div class="PostSingle">
349 |         <h1>Update Post</h1>
350 |         
351 |         <form @submit.prevent="updatePost" v-if="loaded">
352 |           
353 |           <router-link to="/posts">< Back to posts</router-link>
354 |           
355 |             <div class="form-group">
356 |    
357 |                   <input type="hidden" v-model="form.id"></input>
358 |             </div>
359 |             <div class="form-group">
360 |                   <label>title</label>
361 |                   <input type="text" v-model="form.title"  maxlength="200" ></input>
362 |                   <has-error :form="form" field="title"></has-error>
363 |             </div>
364 |             <div class="form-group">
365 |                   <label>content</label>
366 |                   <textarea v-model="form.content" ></textarea>
367 |                   <has-error :form="form" field="content"></has-error>
368 |             </div>
369 |             <div class="form-group">
370 |                   <label>meta_description</label>
371 |                   <input type="text" v-model="form.meta_description"  maxlength="160" ></input>
372 |                   <has-error :form="form" field="meta_description"></has-error>
373 |             </div>
374 |             <div class="form-group">
375 |    
376 |                   <input type="hidden" v-model="form.created_at"></input>
377 |             </div>
378 |             <div class="form-group">
379 |    
380 |                   <input type="hidden" v-model="form.updated_at"></input>
381 |             </div>
382 |       
383 |           <div class="form-group">
384 |               <button class="button" type="submit" :disabled="form.busy" name="button">{{ (form.busy) ? 'Please wait...' : 'Update'}}</button>
385 |               <button @click.prevent="deletePost">{{ (form.busy) ? 'Please wait...' : 'Delete'}}</button>
386 |           </div>
387 |         </form>
388 |         
389 |         <span v-else>Loading post...</span>
390 |       </div>
391 | </template>
392 | 
393 | <script>
394 | import { Form, HasError, AlertError } from 'vform'
395 | export default {
396 |   name: 'Post',
397 |   components: {HasError},
398 |   data: function(){
399 |     return {
400 |       loaded: false,
401 |       form: new Form({
402 |           "id" : "",
403 |           "title" : "",
404 |           "content" : "",
405 |           "meta_description" : "",
406 |           "created_at" : "",
407 |           "updated_at" : "",
408 |         
409 |       })
410 |     }
411 |   },
412 |   created: function(){
413 |     this.getPost();
414 |   },
415 |   methods: {
416 |     getPost: function(Post){
417 |       
418 |       var that = this;
419 |       this.form.get('/posts/'+this.$route.params.id).then(function(response){
420 |         that.form.fill(response.data);
421 |         that.loaded = true;
422 |       }).catch(function(e){
423 |           if (e.response && e.response.status == 404) {
424 |               that.$router.push('/404');
425 |           }
426 |       });
427 |       
428 |     },
429 |     updatePost: function(){
430 |       
431 |       var that = this;
432 |       this.form.put('/posts/'+this.$route.params.id).then(function(response){
433 |         that.form.fill(response.data);
434 |       })
435 |       
436 |     },
437 |     deletePost: function(){
438 |       
439 |       var that = this;
440 |       this.form.delete('/posts/'+this.$route.params.id).then(function(response){
441 |         that.form.fill(response.data);
442 |         that.$router.push('/posts');
443 |       })
444 |       
445 |     }
446 |   }
447 | }
448 | </script>
449 | 
450 | <style lang="less">
451 | .PostSingle{
452 |   margin:0 auto;
453 |   width:700px;
454 |   form{
455 |     .form-group{
456 |       margin-bottom:20px;
457 |       label{
458 |         display:block;
459 |         margin-bottom:5px;
460 |         text-transform: capitalize;
461 |       }
462 |       input[type="text"],input[type="number"],textarea{
463 |         width:100%;
464 |         max-width:100%;
465 |         min-width:100%;
466 |         padding:10px;
467 |         border-radius:3px;
468 |         border:1px solid silver;
469 |         font-size:1rem;
470 |         &:focus{
471 |           outline:0;
472 |           border-color:blue;
473 |         }
474 |       }
475 |       .button{
476 |         appearance: none;
477 |         background: #3bdfd9;
478 |         font-size: 1rem;
479 |         border: 0px;
480 |         padding: 10px 20px;
481 |         border-radius: 3px;
482 |         font-weight: bold;
483 |         &:hover{
484 |           cursor:pointer;
485 |           background: darken(#3bdfd9,10);
486 |         }
487 |       }
488 |       .invalid-feedback{
489 |         color:red;
490 |         &::first-letter{
491 |           text-transform:capitalize;
492 |         }
493 |       }
494 |     }
495 |   }
496 | }
497 | </style>
498 | ```
499 | 
500 | ## Configuration
501 | 
502 | Here are the configuration settings with their default values.
503 | 
504 | ```
505 | <?php 
506 | return [
507 |     'model_dir' => base_path('app'),
508 |     'controller_dir' => base_path('app/Http/Controllers'),
509 |     'vue_files_dir' => base_path('resources/views/vue'),
510 |     'routes_dir' => base_path('routes'),
511 |     'routes_file' => 'api.php'
512 | ];
513 | ?>
514 | ```
515 | To copy the config file to your working Laravel project enter the following artisan command
516 | 
517 | `php artisan vendor:publish --provider="lummy\vueApi\vueApiServiceProvider" --tag="config"`
518 | 
519 | ##### model_dir
520 | Specifies the location where the generated model files should be stored
521 | 
522 | #### controller_dir
523 | 
524 | Specifies the location where the generated controller files should be stored
525 | 
526 | #### vue_files_dir
527 | 
528 | Specifies the location where the Vue single file templates should be stored
529 | 
530 | #### vue_url_prefix
531 | Specifies what prefix should be added to the URL in your view files. The default is `/api` ie `/api/posts`
532 | 
533 | #### routes_dir
534 | Specifies the location of the routes directory
535 | 
536 | #### routes_file
537 | Specifies the name of the routes file
538 | 
539 | ### Customising the templates
540 | 
541 | If you use another frontend framework such as React or you want to adjust the structure of the templates then you can customise the templates by publishing them to your working Laravel project
542 | 
543 | `php artisan vendor:publish --provider="lummy\vueApi\vueApiServiceProvider" --tag="templates"``
544 | 
545 | They will then appear in
546 | 
547 | `\resources\views\vendor\vueApi`
548 | 
549 | 
550 | ### Variables in the templates
551 | 
552 | Each template file passes a data array with the following fields
553 | 
554 | ##### $data['singular']
555 | The singular name for the DB table eg Post
556 | 
557 | ##### $data['plural']
558 | The plural name for the DB table eg Posts
559 | 
560 | ##### $data['singular_lower']
561 | The singular name for the DB table (lowercase) eg post
562 | 
563 | ##### $data['plural_lower']
564 | The plural name for the DB table eg (lowercase) eg posts
565 | 
566 | ##### $data['fields']
567 | An array of the fields that are part of the model.
568 | 
569 |  - name (the field name)
570 |  - type (the mysql varchar, int etc)
571 |  - simplified_type (text, textarea, number)
572 |  - required (is the field required)
573 |  - max (the maximum number of characters)
574 |  
575 | ### Other things to note
576 |  
577 | I have only tested this on Laravel MYSQL driver so I'm not sure if it will work on other databases.
578 |  
579 | In Vue.js files the routes are presumed to be: using the posts example. You can easily configure these from the templates generated
580 |  
581 | /posts (Posts-list.vue)
582 | /posts/{id} (Posts-single.vue)
583 | 
584 | Please feel free to contact me with any  feedback or suggestions https://github.com/aarondo
585 | 
586 | 
587 | 
588 | 
589 | 
590 | 


--------------------------------------------------------------------------------
/src/config/vueApi.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | return [
 3 |     'model_dir' => base_path('app'),
 4 |     'controller_dir' => base_path('app/Http/Controllers'),
 5 |     'vue_files_dir' => base_path('resources/views/vue'),
 6 |     'vue_url_prefix' => '/api',
 7 |     'routes_dir' => base_path('routes'),
 8 |     'routes_file' => 'api.php'
 9 | ];
10 | ?>


--------------------------------------------------------------------------------
/src/generate.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace lummy\vueApi;
  4 | 
  5 | use Illuminate\Console\Command;
  6 | use Str;
  7 | use Storage;
  8 | use View;
  9 | use DB;
 10 | use Artisan;
 11 | 
 12 | 
 13 | class generate extends Command
 14 | {
 15 |     /**
 16 |      * The name and signature of the console command.
 17 |      *
 18 |      * @var string
 19 |      */
 20 |     protected $signature = 'vueapi:generate {model}';
 21 | 
 22 |     /**
 23 |      * The console command description.
 24 |      *
 25 |      * @var string
 26 |      */
 27 |     protected $description = 'Generated the routes, controller & Vue.js single file templates';
 28 | 
 29 |     /**
 30 |      * Create a new command instance.
 31 |      *
 32 |      * @return void
 33 |      */
 34 |     public function __construct()
 35 |     {
 36 |         parent::__construct();
 37 |     }
 38 |     
 39 |     public function createModel($data){
 40 |       
 41 |       $client = Storage::createLocalDriver(['root' => config('vueApi.model_dir')]);
 42 |       
 43 |       // Check if file already exists. If it does ask if we want to overwrite
 44 |       if ($client->exists($data['singular'])) {    
 45 |         if (!$this->confirm($data['singular'].' model already exists. Would you like to overwrite this model?')){
 46 |             return false;    
 47 |         } 
 48 |       } 
 49 |         
 50 |       // Create the file
 51 |       $modelTemplate = view::make('vueApi::model',['data' => $data])->render();
 52 |       $modelTemplate = "<?php \n".$modelTemplate." ?>";
 53 |       $client->put($data['plural'].'.php', $modelTemplate );
 54 | 
 55 |       return;
 56 |       
 57 |     }
 58 |     
 59 |   
 60 |     
 61 |     public function createController($data){
 62 |       
 63 |       $client = Storage::createLocalDriver(['root' => config('vueApi.controller_dir')]);
 64 |       
 65 |       // Check if file already exists. If it does ask if we want to overwrite
 66 |       if ($client->exists($data['plural'].'Controller.php')) {    
 67 |         if (!$this->confirm($data['plural'].'Controller.php already exists. Would you like to overwrite this controller?')){
 68 |             return false;    
 69 |         } 
 70 |       } 
 71 |     
 72 |       
 73 |       // Create the file
 74 |       $controllerTemplate = view::make('vueApi::controller',['data' => $data])->render();
 75 |       $controllerTemplate = "<?php \n".$controllerTemplate." ?>";
 76 |       $client->put($data['plural'].'Controller.php', $controllerTemplate );
 77 | 
 78 |       return;
 79 |       
 80 |     }
 81 |     
 82 |     
 83 |     public function createVueListTemplate($data){
 84 |       
 85 |       $client = Storage::createLocalDriver(['root' => config('vueApi.vue_files_dir')]);
 86 |       
 87 |       // Check if file already exists. If it does ask if we want to overwrite
 88 |       if ($client->exists($data['plural'].'-list.vue')) {
 89 |         if (!$this->confirm($data['plural'].'-list.vue already exists. Would you like to overwrite this component?')) {
 90 |           return false;
 91 |         }
 92 |       } 
 93 | 
 94 |       // Create the file
 95 |       $vueTemplate = view::make('vueApi::vue-list',['data' => $data])->render();
 96 |       $client->put($data['plural'].'-list.vue', $vueTemplate );
 97 |       
 98 |       return;
 99 |       
100 |     }
101 |     
102 |     public function createVueSingleTemplate($data){
103 |       
104 |       $client = Storage::createLocalDriver(['root' => config('vueApi.vue_files_dir')]);
105 |       
106 |       // Check if file already exists. If it does ask if we want to overwrite
107 |       if ($client->exists($data['plural'].'-single.vue')) {
108 |         if (!$this->confirm($data['plural'].'-single.vue already exists. Would you like to overwrite this component?')) {
109 |           return false;
110 |         }
111 |       }   
112 |   
113 |       // Create the file
114 |       $vueTemplate = view::make('vueApi::vue-single',['data' =>$data])->render();
115 |       $client->put($data['plural'].'-single.vue', $vueTemplate );
116 |       
117 |       return;
118 |       
119 |       
120 |     }
121 |     
122 |     public function createRoutes($data){
123 |       
124 |       $client = Storage::createLocalDriver(['root' => config('vueApi.routes_dir')]);
125 |       
126 |       $routes = "\nRoute::get('".$data['plural_lower']."', '".$data['plural']."Controller@list');\n";
127 |       $routes .= "Route::get('".$data['plural_lower']."/{id}', '".$data['plural']."Controller@get');\n";
128 |       $routes .= "Route::post('".$data['plural_lower']."', '".$data['plural']."Controller@create');\n";
129 |       $routes .= "Route::put('".$data['plural_lower']."/{id}', '".$data['plural']."Controller@update');\n";
130 |       $routes .= "Route::delete('".$data['plural_lower']."/{id}', '".$data['plural']."Controller@delete');\n";
131 |       
132 |       if ($client->exists(config('vueApi.routes_file'))) {
133 |         $routeFile = $client->get('/'.config('vueApi.routes_file'));
134 |         $appendedRoutes = $routeFile.$routes;
135 |         $client->put(config('vueApi.routes_file'), $appendedRoutes);
136 |       } else {
137 |         $routeFile = $client->get('/'.config('vueApi.routes_file'));
138 |         $client->put(config('vueApi.routes_file'), $routes);
139 |       }
140 |       
141 |       
142 |       
143 |       
144 |     }
145 |     
146 |     public function getFieldsData($singular, $plural){
147 |       
148 |       $data = DB::select('DESCRIBE '.strtolower($plural));
149 |       
150 |       
151 |       $fieldsArray = array();
152 |       $i = 0;
153 |       foreach ($data as $key) {
154 |           
155 |           // Extract if its required
156 |           $required = ($key->Null == 'NO') ? true : false ;
157 |           
158 |           //Extract the field type
159 |           $type = $typeArr = explode("(", $key->Type, 2)[0];
160 | 
161 |           //extract the number for the max attribute
162 |           preg_match_all('!\d+!', $key->Type, $matches);
163 |           
164 |           // Setup simplified type arrays
165 |           $stringArray = ['char','varchar','tinystring'];
166 |           $textAreaArray = ['text','mediumtext','longtext'];
167 |           $simplifiedType = 'number';
168 |           
169 |           if (in_array($type, $stringArray)) {
170 |             $simplifiedType = 'text';
171 |           } else if(in_array($type, $textAreaArray)){
172 |             $simplifiedType = 'textarea';
173 |           }
174 |           
175 |           $fieldsArray[$i]['name'] = $key->Field;
176 |           $fieldsArray[$i]['type'] = $type;
177 |           $fieldsArray[$i]['simplified_type'] = $simplifiedType;
178 |           $fieldsArray[$i]['required'] = $required;
179 |           $fieldsArray[$i]['max'] = (isset($matches[0][0])) ? (int)$matches[0][0] : false;
180 |         
181 |         $i++;
182 |       };
183 |       
184 |       return array(
185 |         'singular' => $singular,
186 |         'plural' => $plural,
187 |         'singular_lower' => strtolower($singular),
188 |         'plural_lower' => strtolower($plural),
189 |         'fields' => $fieldsArray
190 |       );
191 |       
192 |       
193 |       
194 |     }
195 |     
196 |     public function createFormData($plural){
197 |       
198 |       $validatorArray = array();
199 |       $vform = '';
200 |       $fieldsArray = array();
201 |       
202 |       $data = DB::select('DESCRIBE '.strtolower($plural));
203 | 
204 |       foreach ($data as $key) {
205 |         
206 | 
207 |         
208 |         $vform .= "\t\t\t\t\t<div class='form-group'>\n";
209 |         $vform .= "\t\t\t\t\t\t<label>".$key->Field."</label>\n";
210 |         
211 |         $thisValidations = array();
212 |         ($key->Null == 'NO') ? '' : array_push($thisValidations,'required');
213 |         
214 |         preg_match_all('!\d+!', $key->Type, $matches);
215 |         
216 |         
217 |       
218 |         $lengthValue = (isset($matches[0][0])) ? 'max:'.array_push($thisValidations,'max:'.$matches[0][0]) : '';
219 |         
220 |         $inputLength = (isset($matches[0][0])) ? "maxlength='".$matches[0][0]."'" : '';
221 |         
222 |         $fieldsArray[$key->Field] = '';
223 |         
224 |         
225 |         if ($thisValidations && $key->Field !== 'id' && $key->Field !== 'created_at' && $key->Field !== 'updated_at') {
226 |           $validatorArray[0][$key->Field] = implode('|',$thisValidations);
227 |           
228 |           if ($key->Null == 'YES') {
229 |             $validatorArray[1][$key->Field.'.required'] = 'Please ensure you have filled in '.$key->Field;
230 |           }
231 |         }
232 |         
233 |         $numericArray = ['tinyiny','smallint','mediumint','int','bigint','decimal','float','double','bit'];
234 |         
235 |         $typeArr = explode("(", $key->Type, 2);
236 |         $type = $typeArr[0];
237 |         
238 |         if (in_array($type,$numericArray)) {
239 |           $vform.="\t\t\t\t\t\t<input type='number' ".$inputLength." placeholder='".$key->Field."' v-model='form.".$key->Field."'/>\n";
240 |         }
241 |         
242 |         
243 |         $stringArray = ['char','varchar','tinystring'];
244 |         
245 |         
246 |         if (in_array($type,$stringArray)) {
247 |           $vform.="\t\t\t\t\t\t<input type='text' ".$inputLength." placeholder='".$key->Field."' v-model='form.".$key->Field."'/>\n";
248 |         }
249 |         
250 |         $textAreaArray = ['text','mediumtext','longtext'];
251 |         
252 |         
253 |         if (in_array($type,$textAreaArray)) {
254 |           
255 |           $vform.="\t\t\t\t\t\t<textarea ".$inputLength." placeholder='".$key->Field."' v-model='form.".$key->Field."'/></textarea>\n";
256 |         }
257 |         
258 |         $dateArray = ['date','timestamp','date','datetime','year'];
259 |         
260 |         if (in_array($type,$dateArray)) {
261 |           $vform.="\t\t\t\t\t\t<input type='date' placeholder='".$key->Field."' v-model='form.".$key->Field."'/>\n";
262 |         }
263 |         
264 |         $enumArray = ['enum'];
265 |         
266 |         if ($type == 'enum') {
267 |           $values = str_replace("'",'',str_replace(')','',str_replace('enum(','',$key->Type)));
268 |           $valuesAr = explode(',',$values);
269 |           $vform.="\t\t\t\t\t\t<select v-model='form.".$key->Field."'>";
270 |           foreach ($valuesAr as $key2) {
271 |             $vform.="<option>".$key2."</option>";
272 |           }
273 |           
274 |           $vform.="</select>\n";
275 |         }
276 |         
277 |         if ($thisValidations) {
278 |           $vform.="\t\t\t\t\t\t<has-error :form='form' field='".$key->Field."'></has-error>\n";
279 |         }
280 |         
281 |         
282 |         $vform .= "\t\t\t\t\t</div>\n\n";
283 | 
284 |       }
285 |       
286 |       
287 |     
288 |       
289 |       //$validatorArray 
290 |       //$vform 
291 |       //$fieldsArray 
292 |       
293 |       return ['htmlForm'=>$vform,'validator' => $validatorArray,'fields'=>$fieldsArray];
294 |       
295 |       
296 |     }
297 |     
298 |     
299 |     
300 | 
301 |     /**
302 |      * Execute the console command.
303 |      *
304 |      * @return mixed
305 |      */
306 |     public function handle()
307 |     {
308 |       
309 |       
310 |         
311 |         $singular = strtolower(Str::camel($this->argument('model')));
312 |         $singular = Ucfirst(Str::singular($singular));
313 |         $plural = Ucfirst(Str::plural($singular));
314 |         
315 |         $data = $this->getFieldsData($singular, $plural);
316 |         
317 |     
318 |         $this->createRoutes($data);
319 |         $this->createModel($data);
320 |         $this->createController($data);
321 |         $this->createVueListTemplate($data);
322 |         $this->createVueSingleTemplate($data);
323 |         
324 |         return $this->info('Created '.$singular.'Controller.php, '.$singular.'.vue and the routes in '.config('vueApi.routes_file'));
325 |     
326 |     }
327 | }
328 | 


--------------------------------------------------------------------------------
/src/templates/controller.blade.php:
--------------------------------------------------------------------------------
 1 | namespace App\Http\Controllers;
 2 | 
 3 | use Illuminate\Http\Request;
 4 | use App\{{ $data['plural'] }};
 5 | 
 6 | class {{ $data['plural'] }}Controller extends Controller
 7 | {
 8 |     public function get(Request $request, $id){
 9 |       return {{ $data['plural'] }}::findOrFail($id);
10 |     }
11 |     
12 |     public function list(Request $request){
13 |       return {{ $data['plural'] }}::get();
14 |     }
15 |     
16 |     public function create(Request $request){
17 |         
18 |       $validatedData = $request->validate([
19 | @foreach($data['fields'] as $field)
20 | @if($field['required'] && $field['name'] !== 'id')
21 |         '{{ $field['name'] }}' => 'required @if($field['max'])|max:{{$field['max']}} @endif',
22 | @endif
23 | @endforeach
24 |       ],[
25 | @foreach($data['fields'] as $field)
26 | @if($field['required'] && $field['name'] !== 'id')
27 |         '{{ $field['name'] }}.required' => '{{ $field['name'] }} is a required field.',
28 | @if($field['max'])
29 |         '{{ $field['name'] }}.max' => '{{ $field['name'] }} can only be {{$field['max']}} characters.',
30 | @endif
31 | @endif
32 | @endforeach
33 |       ]);
34 | 
35 |         ${{ $data['plural_lower'] }} = {{ $data['plural'] }}::create($request->all());    
36 |         return ${{ $data['plural_lower'] }};
37 |     }
38 |     
39 |     public function update(Request $request, $id){
40 |       
41 |       $validatedData = $request->validate([
42 | @foreach($data['fields'] as $field)
43 | @if($field['required'] && $field['name'] !== 'id')
44 |         '{{ $field['name'] }}' => 'required @if($field['max'])|max:{{$field['max']}} @endif',
45 | @endif
46 | @endforeach
47 |       ],[
48 | @foreach($data['fields'] as $field)
49 | @if($field['required'] && $field['name'] !== 'id')
50 |         '{{ $field['name'] }}.required' => '{{ $field['name'] }} is a required field.',
51 | @if($field['max'])
52 |         '{{ $field['name'] }}.max' => '{{ $field['name'] }} can only be {{$field['max']}} characters.',
53 | @endif
54 | @endif
55 | @endforeach
56 |       ]);
57 | 
58 |         ${{ $data['plural_lower'] }} = {{ $data['plural'] }}::findOrFail($id);
59 |         $input = $request->all();
60 |         ${{ $data['plural_lower'] }}->fill($input)->save();
61 |         return ${{ $data['plural_lower'] }};
62 |     }
63 |     
64 |     public function delete(Request $request, $id){
65 |         ${{$data['plural_lower']}} = {{$data['plural']}}::findOrFail($id);
66 |         ${{$data['plural_lower']}}->delete();
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/templates/model.blade.php:
--------------------------------------------------------------------------------
 1 | namespace App;
 2 | 
 3 | use Illuminate\Database\Eloquent\Model;
 4 | 
 5 | class {{ $data['plural'] }} extends Model
 6 | {
 7 | 
 8 |     /**
 9 |      * The attributes that should be hidden for arrays.
10 |      *
11 |      * @var array
12 |      */
13 |     protected $guarded = [
14 |         'id'
15 |     ];
16 | 
17 |     /**
18 |      * The attributes that should be cast to native types.
19 |      *
20 |      * @var array
21 |      */
22 |     protected $casts = [
23 |         ''
24 |     ];
25 | }


--------------------------------------------------------------------------------
/src/templates/vue-list.blade.php:
--------------------------------------------------------------------------------
  1 | <template lang="html">
  2 |       <div class="{{ $data['plural_lower'] }}">
  3 |         
  4 |         <div class="half">
  5 |           
  6 |           <h1>Create {{$data['singular_lower']}}</h1>
  7 |           
  8 |           <form @submit.prevent="create{{ $data['singular'] }}">
  9 |             
 10 | @foreach($data['fields'] as $field)
 11 |             <div class="form-group">
 12 | @if($field['name'] == 'id' || $field['name'] == 'updated_at' || $field['name'] == 'created_at' )   
 13 |                   <input type="hidden" v-model="form.{{$field['name']}}"></input>
 14 | @elseif($field['simplified_type'] == 'text')
 15 |                   <label>{{ $field['name'] }}</label>
 16 |                   <input type="text" v-model="form.{{$field['name']}}" @if($field['max']) maxlength="{{$field['max']}}" @endif></input>
 17 | @if($field['required'] && $field['name'] !== 'id')
 18 |                   <has-error :form="form" field="{{$field['name']}}"></has-error>
 19 | @endif
 20 | @elseif($field['simplified_type'] == 'textarea')
 21 |                   <label>{{ $field['name'] }}</label>
 22 |                   <textarea v-model="form.{{$field['name']}}" @if($field['max']) maxlength="{{$field['max']}}" @endif></textarea>
 23 | @if($field['required'] && $field['name'] !== 'id')
 24 |                   <has-error :form="form" field="{{$field['name']}}"></has-error>
 25 | @endif
 26 | @else
 27 |                   <label>{{ $field['name'] }}</label>
 28 |                   <input type="number" v-model="form.{{$field['name']}}"></input>
 29 | @if($field['required'] && $field['name'] !== 'id')
 30 |                   <has-error :form="form" field="{{$field['name']}}"></has-error>
 31 | @endif
 32 | @endif
 33 |             </div>
 34 | @endforeach
 35 |         
 36 |             <div class="form-group">
 37 |                 <button class="button" type="submit" :disabled="form.busy" name="button">@{{ (form.busy) ? 'Please wait...' : 'Submit'}}</button>
 38 |             </div>
 39 |           </form>
 40 |           
 41 |         </div><!-- End first half -->
 42 |         
 43 |         <div class="half">
 44 |           
 45 |           <h1>List {{ $data['plural_lower'] }}</h1>
 46 |           
 47 |           <ul v-if="{{ $data['plural_lower'] }}.length > 0">
 48 |             <li v-for="({{ $data['singular_lower'] }},index) in {{ $data['plural_lower'] }}" :key="{{ $data['singular_lower'] }}.id">
 49 |               
 50 |             <router-link :to="'/{{ $data['singular_lower'] }}/'+{{ $data['singular_lower'] }}.id">
 51 |               
 52 |               {{ $data['singular_lower']}} @{{ index }}
 53 | 
 54 |               <button @click.prevent="delete{{$data['singular']}}({{ $data['singular_lower'] }},index)" type="button" :disabled="form.busy" name="button">@{{ (form.busy) ? 'Please wait...' : 'Delete'}}</button>
 55 |               
 56 |             </router-link>
 57 |               
 58 |             </li>
 59 |           </ul>
 60 |           
 61 |           <span v-else-if="!{{ $data['plural_lower'] }}">Loading...</span>
 62 |           <span v-else>No {{ $data['plural_lower'] }} exist</span>
 63 |           
 64 |         </div><!-- End 2nd half -->
 65 |         
 66 |       </div>
 67 | </template>
 68 | 
 69 | <script>
 70 | import { Form, HasError, AlertError } from 'vform'
 71 | export default {
 72 |   name: '{{ $data['singular'] }}',
 73 |   components: {HasError},
 74 |   data: function(){
 75 |     return {
 76 |       {{ $data['plural_lower'] }} : false,
 77 |       form: new Form({
 78 | @foreach($data['fields'] as $field)
 79 |           "{{$field['name']}}" : "",
 80 | @endforeach
 81 |       })
 82 |     }
 83 |   },
 84 |   created: function(){
 85 |     this.list{{$data['plural']}}();
 86 |   },
 87 |   methods: {
 88 |     list{{ $data['plural'] }}: function(){
 89 |       
 90 |       var that = this;
 91 |       this.form.get('{{config('vueApi.vue_url_prefix')}}/{{ $data['plural_lower'] }}').then(function(response){
 92 |         that.{{ $data['plural_lower'] }} = response.data;
 93 |       })
 94 |       
 95 |     },
 96 |     create{{ $data['singular'] }}: function(){
 97 |       
 98 |       var that = this;
 99 |       this.form.post('{{config('vueApi.vue_url_prefix')}}/{{ $data['plural_lower'] }}').then(function(response){
100 |         that.{{ $data['plural_lower'] }}.push(response.data);
101 |       })
102 |       
103 |     },
104 |     delete{{$data['singular']}}: function({{ $data['singular_lower'] }}, index){
105 |       
106 |       var that = this;
107 |       this.form.delete('{{config('vueApi.vue_url_prefix')}}/{{ $data['plural_lower'] }}/'+{{ $data['singular_lower'] }}.id).then(function(response){
108 |         that.{{ $data['plural_lower'] }}.splice(index,1);
109 |       })
110 |       
111 |     }
112 |   }
113 | }
114 | </script>
115 | 
116 | <style lang="less">
117 | .{{ $data['plural_lower'] }}{
118 |     margin:0 auto;
119 |     width:700px;
120 |     display:flex;
121 |     .half{
122 |       flex:1;
123 |       &:first-of-type{
124 |         margin-right:20px;
125 |       }
126 |     }
127 |     form{
128 |       .form-group{
129 |         margin-bottom:20px;
130 |         label{
131 |           display:block;
132 |           margin-bottom:5px;
133 |           text-transform: capitalize;
134 |         }
135 |         input[type="text"],input[type="number"],textarea{
136 |           width:100%;
137 |           max-width:100%;
138 |           min-width:100%;
139 |           padding:10px;
140 |           border-radius:3px;
141 |           border:1px solid silver;
142 |           font-size:1rem;
143 |           &:focus{
144 |             outline:0;
145 |             border-color:blue;
146 |           }
147 |         }
148 |         .invalid-feedback{
149 |           color:red;
150 |           &::first-letter{
151 |             text-transform:capitalize;
152 |           }
153 |         }
154 |       }
155 |       .button{
156 |         appearance: none;
157 |         background: #3bdfd9;
158 |         font-size: 1rem;
159 |         border: 0px;
160 |         padding: 10px 20px;
161 |         border-radius: 3px;
162 |         font-weight: bold;
163 |         &:hover{
164 |           cursor:pointer;
165 |           background: darken(#3bdfd9,10);
166 |         }
167 |       }
168 |     }
169 | }
170 | </style>


--------------------------------------------------------------------------------
/src/templates/vue-single.blade.php:
--------------------------------------------------------------------------------
  1 | <template lang="html">
  2 |       <div class="{{ $data['singular'] }}Single">
  3 |         <h1>Update {{ $data['singular'] }}</h1>
  4 |         
  5 |         <form @submit.prevent="update{{$data['singular']}}" v-if="loaded">
  6 |           
  7 |           <router-link to="/{{ $data['plural_lower'] }}">< Back to {{ $data['plural_lower'] }}</router-link>
  8 |           
  9 | @foreach($data['fields'] as $field)
 10 |             <div class="form-group">
 11 | @if($field['name'] == 'id' || $field['name'] == 'updated_at' || $field['name'] == 'created_at' )   
 12 |                   <input type="hidden" v-model="form.{{$field['name']}}"></input>
 13 | @elseif($field['simplified_type'] == 'text')
 14 |                   <label>{{ $field['name'] }}</label>
 15 |                   <input type="text" v-model="form.{{$field['name']}}" @if($field['max']) maxlength="{{$field['max']}}" @endif></input>
 16 | @if($field['required'] && $field['name'] !== 'id')
 17 |                   <has-error :form="form" field="{{$field['name']}}"></has-error>
 18 | @endif
 19 | @elseif($field['simplified_type'] == 'textarea')
 20 |                   <label>{{ $field['name'] }}</label>
 21 |                   <textarea v-model="form.{{$field['name']}}" @if($field['max']) maxlength="{{$field['max']}}" @endif></textarea>
 22 | @if($field['required'] && $field['name'] !== 'id')
 23 |                   <has-error :form="form" field="{{$field['name']}}"></has-error>
 24 | @endif
 25 | @else
 26 |                   <label>{{ $field['name'] }}</label>
 27 |                   <input type="number" v-model="form.{{$field['name']}}"></input>
 28 | @if($field['required'] && $field['name'] !== 'id')
 29 |                   <has-error :form="form" field="{{$field['name']}}"></has-error>
 30 | @endif
 31 | @endif
 32 |             </div>
 33 | @endforeach
 34 |       
 35 |           <div class="form-group">
 36 |               <button class="button" type="submit" :disabled="form.busy" name="button">@{{ (form.busy) ? 'Please wait...' : 'Update'}}</button>
 37 |               <button @click.prevent="delete{{$data['singular']}}">@{{ (form.busy) ? 'Please wait...' : 'Delete'}}</button>
 38 |           </div>
 39 |         </form>
 40 |         
 41 |         <span v-else>Loading {{ $data['singular_lower'] }}...</span>
 42 |       </div>
 43 | </template>
 44 | 
 45 | <script>
 46 | import { Form, HasError, AlertError } from 'vform'
 47 | export default {
 48 |   name: '{{ $data['singular'] }}',
 49 |   components: {HasError},
 50 |   data: function(){
 51 |     return {
 52 |       loaded: false,
 53 |       form: new Form({
 54 | @foreach($data['fields'] as $field)
 55 |           "{{$field['name']}}" : "",
 56 | @endforeach        
 57 |       })
 58 |     }
 59 |   },
 60 |   created: function(){
 61 |     this.get{{$data['singular']}}();
 62 |   },
 63 |   methods: {
 64 |     get{{$data['singular']}}: function({{$data['singular']}}){
 65 |       
 66 |       var that = this;
 67 |       this.form.get('{{config('vueApi.vue_url_prefix')}}/{{ $data['plural_lower'] }}/'+this.$route.params.id).then(function(response){
 68 |         that.form.fill(response.data);
 69 |         that.loaded = true;
 70 |       }).catch(function(e){
 71 |           if (e.response && e.response.status == 404) {
 72 |               that.$router.push('/404');
 73 |           }
 74 |       });
 75 |       
 76 |     },
 77 |     update{{$data['singular']}}: function(){
 78 |       
 79 |       var that = this;
 80 |       this.form.put('{{config('vueApi.vue_url_prefix')}}/{{ $data['plural_lower'] }}/'+this.$route.params.id).then(function(response){
 81 |         that.form.fill(response.data);
 82 |       })
 83 |       
 84 |     },
 85 |     delete{{$data['singular']}}: function(){
 86 |       
 87 |       var that = this;
 88 |       this.form.delete('{{config('vueApi.vue_url_prefix')}}/{{ $data['plural_lower'] }}/'+this.$route.params.id).then(function(response){
 89 |         that.form.fill(response.data);
 90 |         that.$router.push('/{{$data['plural_lower']}}');
 91 |       })
 92 |       
 93 |     }
 94 |   }
 95 | }
 96 | </script>
 97 | 
 98 | <style lang="less">
 99 | .{{ $data['singular'] }}Single{
100 |   margin:0 auto;
101 |   width:700px;
102 |   form{
103 |     .form-group{
104 |       margin-bottom:20px;
105 |       label{
106 |         display:block;
107 |         margin-bottom:5px;
108 |         text-transform: capitalize;
109 |       }
110 |       input[type="text"],input[type="number"],textarea{
111 |         width:100%;
112 |         max-width:100%;
113 |         min-width:100%;
114 |         padding:10px;
115 |         border-radius:3px;
116 |         border:1px solid silver;
117 |         font-size:1rem;
118 |         &:focus{
119 |           outline:0;
120 |           border-color:blue;
121 |         }
122 |       }
123 |       .button{
124 |         appearance: none;
125 |         background: #3bdfd9;
126 |         font-size: 1rem;
127 |         border: 0px;
128 |         padding: 10px 20px;
129 |         border-radius: 3px;
130 |         font-weight: bold;
131 |         &:hover{
132 |           cursor:pointer;
133 |           background: darken(#3bdfd9,10);
134 |         }
135 |       }
136 |       .invalid-feedback{
137 |         color:red;
138 |         &::first-letter{
139 |           text-transform:capitalize;
140 |         }
141 |       }
142 |     }
143 |   }
144 | }
145 | </style>


--------------------------------------------------------------------------------
/src/vueApiServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace lummy\vueApi;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | 
 7 | class vueApiServiceProvider extends ServiceProvider
 8 | {
 9 |   
10 |   protected $commands = [
11 |       'lummy\vueApi\generate'
12 |   ];
13 |   
14 |     /**
15 |      * Register services.
16 |      *
17 |      * @return void
18 |      */
19 |     public function register()
20 |     {
21 |       
22 |       $this->mergeConfigFrom(
23 |           __DIR__ . '/config/vueApi.php', 'vueApi'
24 |       );
25 |     
26 |         $this->commands($this->commands);
27 |     }
28 | 
29 |     /**
30 |      * Bootstrap services.
31 |      *
32 |      * @return void
33 |      */
34 |     public function boot()
35 |     {
36 | 
37 |         
38 |          $this->loadViewsFrom(__DIR__.'/templates', 'vueApi');
39 |         
40 |         $this->publishes([
41 |              __DIR__ . '/config/vueApi.php' => config_path('vueApi.php'),
42 |          ], 'config');
43 |          
44 |     
45 |         
46 |         $this->publishes([
47 |          __DIR__.'/templates' => resource_path('views/vendor/vueApi'),
48 |        ],'templates');
49 |          
50 |     }
51 |     
52 |     
53 |     
54 | }
55 | 


--------------------------------------------------------------------------------