@hedhog/admin 0.0.36 → 0.0.38

package/src/migrations/migrate-07.ts

@@ -1,4 +1,4 @@
-import { timestampColumn } from '@hedhog/utils';
+import { idColumn, timestampColumn } from '@hedhog/utils';
 import {
   MigrationInterface,
   QueryRunner,
@@ -10,45 +10,111 @@ export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
     await queryRunner.createTable(
       new Table({
-        name: 'route_screens',
+        name: 'roles',
+        columns: [idColumn(), timestampColumn(), timestampColumn('updated_at')],
+      }),
+    );
+
+    await queryRunner.createTable(
+      new Table({
+        name: 'role_translations',
         columns: [
           {
-            name: 'route_id',
+            name: 'role_id',
             type: 'int',
             unsigned: true,
             isPrimary: true,
           },
           {
-            name: 'screen_id',
+            name: 'locale_id',
             type: 'int',
             unsigned: true,
             isPrimary: true,
           },
+          {
+            name: 'name',
+            type: 'varchar',
+            isNullable: false,
+          },
+          {
+            name: 'description',
+            type: 'varchar',
+          },
           timestampColumn(),
           timestampColumn('updated_at'),
         ],
+        foreignKeys: [
+          new TableForeignKey({
+            columnNames: ['role_id'],
+            referencedTableName: 'roles',
+            referencedColumnNames: ['id'],
+            onDelete: 'CASCADE',
+          }),
+          new TableForeignKey({
+            columnNames: ['locale_id'],
+            referencedTableName: 'locales',
+            referencedColumnNames: ['id'],
+            onDelete: 'CASCADE',
+          }),
+        ],
       }),
     );
 
-    await queryRunner.createForeignKeys('route_screens', [
-      new TableForeignKey({
-        columnNames: ['route_id'],
-        referencedColumnNames: ['id'],
-        referencedTableName: 'routes',
-        onDelete: 'CASCADE',
-        name: 'fk_route_screens_routes',
-      }),
-      new TableForeignKey({
-        columnNames: ['screen_id'],
-        referencedColumnNames: ['id'],
-        referencedTableName: 'screens',
-        onDelete: 'CASCADE',
-        name: 'fk_route_screens_screens',
-      }),
-    ]);
+    const roles = [
+      {
+        id: 1,
+        name_en: 'Administrator',
+        name_pt: 'Administrador',
+        description_en: 'System administrator',
+        description_pt: 'Administrador do sistema',
+      },
+      {
+        id: 2,
+        name_en: 'Screen Manager',
+        name_pt: 'Gerenciador de telas',
+        description_en: 'Screen manager',
+        description_pt: 'Gerenciador de telas',
+      },
+    ];
+
+    for (const role of roles) {
+      await queryRunner.manager
+        .createQueryBuilder()
+        .insert()
+        .into('roles', ['id'])
+        .values({
+          id: role.id,
+        })
+        .execute();
+
+      await queryRunner.manager
+        .createQueryBuilder()
+        .insert()
+        .into('role_translations', [
+          'role_id',
+          'locale_id',
+          'name',
+          'description',
+        ])
+        .values([
+          {
+            role_id: role.id,
+            locale_id: 1,
+            name: role.name_en,
+            description: role.description_en,
+          },
+          {
+            role_id: role.id,
+            locale_id: 2,
+            name: role.name_pt,
+            description: role.description_pt,
+          },
+        ])
+        .execute();
+    }
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.dropTable('route_screens');
+    await queryRunner.dropTable('roles');
   }
 }

package/src/migrations/migrate-08.ts

@@ -10,7 +10,7 @@ export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
     await queryRunner.createTable(
       new Table({
-        name: 'role_screens',
+        name: 'role_menus',
         columns: [
           {
             name: 'role_id',
@@ -19,7 +19,7 @@ export class Migrate implements MigrationInterface {
             unsigned: true,
           },
           {
-            name: 'screen_id',
+            name: 'menu_id',
             type: 'int',
             isPrimary: true,
             unsigned: true,
@@ -30,25 +30,25 @@ export class Migrate implements MigrationInterface {
       }),
     );
 
-    await queryRunner.createForeignKeys('role_screens', [
+    await queryRunner.createForeignKeys('role_menus', [
       new TableForeignKey({
         columnNames: ['role_id'],
         referencedColumnNames: ['id'],
         referencedTableName: 'roles',
         onDelete: 'CASCADE',
-        name: 'fk_role_screens_roles',
+        name: 'fk_role_menus_roles',
       }),
       new TableForeignKey({
-        columnNames: ['screen_id'],
+        columnNames: ['menu_id'],
         referencedColumnNames: ['id'],
-        referencedTableName: 'screens',
+        referencedTableName: 'menus',
         onDelete: 'CASCADE',
-        name: 'fk_role_screens_screens',
+        name: 'fk_role_menus_menus',
       }),
     ]);
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.dropTable('role_screens');
+    await queryRunner.dropTable('role_menus');
   }
 }

package/src/migrations/migrate-09.ts

@@ -10,19 +10,19 @@ export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
     await queryRunner.createTable(
       new Table({
-        name: 'role_users',
+        name: 'route_screens',
         columns: [
           {
-            name: 'role_id',
+            name: 'route_id',
             type: 'int',
-            isPrimary: true,
             unsigned: true,
+            isPrimary: true,
           },
           {
-            name: 'user_id',
+            name: 'screen_id',
             type: 'int',
-            isPrimary: true,
             unsigned: true,
+            isPrimary: true,
           },
           timestampColumn(),
           timestampColumn('updated_at'),
@@ -30,26 +30,25 @@ export class Migrate implements MigrationInterface {
       }),
     );
 
-    await queryRunner.createForeignKeys('role_users', [
+    await queryRunner.createForeignKeys('route_screens', [
       new TableForeignKey({
-        columnNames: ['role_id'],
+        columnNames: ['route_id'],
         referencedColumnNames: ['id'],
-        referencedTableName: 'roles',
+        referencedTableName: 'routes',
         onDelete: 'CASCADE',
-        name: 'fk_role_users_roles',
+        name: 'fk_route_screens_routes',
       }),
-
       new TableForeignKey({
-        columnNames: ['user_id'],
+        columnNames: ['screen_id'],
         referencedColumnNames: ['id'],
-        referencedTableName: 'users',
+        referencedTableName: 'screens',
         onDelete: 'CASCADE',
-        name: 'fk_role_users_users',
+        name: 'fk_route_screens_screens',
       }),
     ]);
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.dropTable('role_users');
+    await queryRunner.dropTable('route_screens');
   }
 }

package/src/migrations/migrate-10.ts

@@ -10,7 +10,7 @@ export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
     await queryRunner.createTable(
       new Table({
-        name: 'role_routes',
+        name: 'role_screens',
         columns: [
           {
             name: 'role_id',
@@ -19,7 +19,7 @@ export class Migrate implements MigrationInterface {
             unsigned: true,
           },
           {
-            name: 'route_id',
+            name: 'screen_id',
             type: 'int',
             isPrimary: true,
             unsigned: true,
@@ -30,25 +30,25 @@ export class Migrate implements MigrationInterface {
       }),
     );
 
-    await queryRunner.createForeignKeys('role_routes', [
+    await queryRunner.createForeignKeys('role_screens', [
       new TableForeignKey({
         columnNames: ['role_id'],
         referencedColumnNames: ['id'],
         referencedTableName: 'roles',
         onDelete: 'CASCADE',
-        name: 'fk_role_routes_roles',
+        name: 'fk_role_screens_roles',
       }),
       new TableForeignKey({
-        columnNames: ['route_id'],
+        columnNames: ['screen_id'],
         referencedColumnNames: ['id'],
-        referencedTableName: 'routes',
+        referencedTableName: 'screens',
         onDelete: 'CASCADE',
-        name: 'fk_role_routes_routes',
+        name: 'fk_role_screens_screens',
       }),
     ]);
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.dropTable('role_routes');
+    await queryRunner.dropTable('role_screens');
   }
 }

package/src/migrations/migrate-11.ts

@@ -1,26 +1,55 @@
-import { MigrationInterface, QueryRunner } from 'typeorm';
+import { timestampColumn } from '@hedhog/utils';
+import {
+  MigrationInterface,
+  QueryRunner,
+  Table,
+  TableForeignKey,
+} from 'typeorm';
 
 export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
-    const menus = await queryRunner.manager
-      .createQueryBuilder()
-      .select()
-      .from('menus', 'm')
-      .execute();
+    await queryRunner.createTable(
+      new Table({
+        name: 'role_users',
+        columns: [
+          {
+            name: 'role_id',
+            type: 'int',
+            isPrimary: true,
+            unsigned: true,
+          },
+          {
+            name: 'user_id',
+            type: 'int',
+            isPrimary: true,
+            unsigned: true,
+          },
+          timestampColumn(),
+          timestampColumn('updated_at'),
+        ],
+      }),
+    );
 
-    for (const menu of menus) {
-      await queryRunner.manager
-        .createQueryBuilder()
-        .insert()
-        .into('role_menus')
-        .values({
-          role_id: 1,
-          menu_id: menu.id,
-        });
-    }
+    await queryRunner.createForeignKeys('role_users', [
+      new TableForeignKey({
+        columnNames: ['role_id'],
+        referencedColumnNames: ['id'],
+        referencedTableName: 'roles',
+        onDelete: 'CASCADE',
+        name: 'fk_role_users_roles',
+      }),
+
+      new TableForeignKey({
+        columnNames: ['user_id'],
+        referencedColumnNames: ['id'],
+        referencedTableName: 'users',
+        onDelete: 'CASCADE',
+        name: 'fk_role_users_users',
+      }),
+    ]);
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.manager.delete('role_menus', { role_id: 1 });
+    await queryRunner.dropTable('role_users');
   }
 }

package/src/migrations/migrate-12.ts

@@ -1,79 +1,54 @@
-import { MigrationInterface, QueryRunner } from 'typeorm';
+import { timestampColumn } from '@hedhog/utils';
+import {
+  MigrationInterface,
+  QueryRunner,
+  Table,
+  TableForeignKey,
+} from 'typeorm';
 
 export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
-    const screenIdScreen = await queryRunner.manager
-      .createQueryBuilder()
-      .select()
-      .from('screens', 's')
-      .where('slug = :slug', { slug: '/management/screens' })
-      .execute();
-
-    const screenIdRole = await queryRunner.manager
-      .createQueryBuilder()
-      .select()
-      .from('screens', 's')
-      .where('slug = :slug', { slug: '/management/roles' })
-      .execute();
-
-    const screenIdUser = await queryRunner.manager
-      .createQueryBuilder()
-      .select()
-      .from('screens', 's')
-      .where('slug = :slug', { slug: '/management/users' })
-      .execute();
-
-    const screenIdMenu = await queryRunner.manager
-      .createQueryBuilder()
-      .select()
-      .from('screens', 's')
-      .where('slug = :slug', { slug: '/management/menus' })
-      .execute();
-
-    const screenIdRoute = await queryRunner.manager
-      .createQueryBuilder()
-      .select()
-      .from('screens', 's')
-      .where('slug = :slug', { slug: '/management/routes' })
-      .execute();
-
-    const screenIdSetting = await queryRunner.manager
-      .createQueryBuilder()
-      .select()
-      .from('screens', 's')
-      .where('slug = :slug', { slug: '/management/settings' })
-      .execute();
-
-    for (const { url, screendId } of [
-      { url: '/screens%', screendId: screenIdScreen[0].id },
-      { url: '/roles%', screendId: screenIdRole[0].id },
-      { url: '/users%', screendId: screenIdUser[0].id },
-      { url: '/menus%', screendId: screenIdMenu[0].id },
-      { url: '/routes%', screendId: screenIdRoute[0].id },
-      { url: '/settings%', screendId: screenIdSetting[0].id },
-    ]) {
-      const routesScreens = await queryRunner.manager
-        .createQueryBuilder()
-        .select()
-        .from('routes', 's')
-        .where('s.url LIKE :url', { url })
-        .execute();
-
-      for (const route of routesScreens) {
-        await queryRunner.manager
-          .createQueryBuilder()
-          .insert()
-          .into('route_screens')
-          .values({
-            route_id: route.id,
-            screen_id: screendId,
-          })
-          .execute();
-      }
-    }
+    await queryRunner.createTable(
+      new Table({
+        name: 'role_routes',
+        columns: [
+          {
+            name: 'role_id',
+            type: 'int',
+            isPrimary: true,
+            unsigned: true,
+          },
+          {
+            name: 'route_id',
+            type: 'int',
+            isPrimary: true,
+            unsigned: true,
+          },
+          timestampColumn(),
+          timestampColumn('updated_at'),
+        ],
+      }),
+    );
+
+    await queryRunner.createForeignKeys('role_routes', [
+      new TableForeignKey({
+        columnNames: ['role_id'],
+        referencedColumnNames: ['id'],
+        referencedTableName: 'roles',
+        onDelete: 'CASCADE',
+        name: 'fk_role_routes_roles',
+      }),
+      new TableForeignKey({
+        columnNames: ['route_id'],
+        referencedColumnNames: ['id'],
+        referencedTableName: 'routes',
+        onDelete: 'CASCADE',
+        name: 'fk_role_routes_routes',
+      }),
+    ]);
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.manager.delete('route_screens', {});
+    await queryRunner.dropTable('role_routes');
   }
 }

package/src/migrations/migrate-13.ts

@@ -2,19 +2,25 @@ import { MigrationInterface, QueryRunner } from 'typeorm';
 
 export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
-    await queryRunner.manager
+    const menus = await queryRunner.manager
       .createQueryBuilder()
-      .insert()
-      .into('role_users')
-      .values([
-        { role_id: 1, user_id: 1 },
-        { role_id: 2, user_id: 2 },
-      ])
+      .select()
+      .from('menus', 'm')
       .execute();
+
+    for (const menu of menus) {
+      await queryRunner.manager
+        .createQueryBuilder()
+        .insert()
+        .into('role_menus')
+        .values({
+          role_id: 1,
+          menu_id: menu.id,
+        });
+    }
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.manager.delete('role_users', { role_id: 1 });
-    await queryRunner.manager.delete('role_users', { role_id: 2 });
+    await queryRunner.manager.delete('role_menus', { role_id: 1 });
   }
 }

package/src/migrations/migrate-14.ts

@@ -2,56 +2,78 @@ import { MigrationInterface, QueryRunner } from 'typeorm';
 
 export class Migrate implements MigrationInterface {
   async up(queryRunner: QueryRunner) {
-    const routes = await queryRunner.manager
+    const screenIdScreen = await queryRunner.manager
       .createQueryBuilder()
       .select()
-      .from('routes', 'r')
+      .from('screens', 's')
+      .where('slug = :slug', { slug: '/management/screens' })
       .execute();
 
-    for (const route of routes) {
-      await queryRunner.manager
-        .createQueryBuilder()
-        .insert()
-        .into('role_routes')
-        .values({
-          role_id: 1,
-          route_id: route.id,
-        })
-        .execute();
-    }
+    const screenIdRole = await queryRunner.manager
+      .createQueryBuilder()
+      .select()
+      .from('screens', 's')
+      .where('slug = :slug', { slug: '/management/roles' })
+      .execute();
+
+    const screenIdUser = await queryRunner.manager
+      .createQueryBuilder()
+      .select()
+      .from('screens', 's')
+      .where('slug = :slug', { slug: '/management/users' })
+      .execute();
+
+    const screenIdMenu = await queryRunner.manager
+      .createQueryBuilder()
+      .select()
+      .from('screens', 's')
+      .where('slug = :slug', { slug: '/management/menus' })
+      .execute();
 
-    await queryRunner.manager
+    const screenIdRoute = await queryRunner.manager
       .createQueryBuilder()
-      .insert()
-      .into('role_routes')
-      .values({
-        role_id: 2,
-        route_id: 3,
-      })
+      .select()
+      .from('screens', 's')
+      .where('slug = :slug', { slug: '/management/routes' })
       .execute();
 
-    const routesScreens = await queryRunner.manager
+    const screenIdSetting = await queryRunner.manager
       .createQueryBuilder()
       .select()
-      .from('routes', 's')
-      .where('s.url LIKE :url', { url: '/screens%' })
+      .from('screens', 's')
+      .where('slug = :slug', { slug: '/management/settings' })
       .execute();
 
-    for (const route of routesScreens) {
-      await queryRunner.manager
+    for (const { url, screendId } of [
+      { url: '/screens%', screendId: screenIdScreen[0].id },
+      { url: '/roles%', screendId: screenIdRole[0].id },
+      { url: '/users%', screendId: screenIdUser[0].id },
+      { url: '/menus%', screendId: screenIdMenu[0].id },
+      { url: '/routes%', screendId: screenIdRoute[0].id },
+      { url: '/settings%', screendId: screenIdSetting[0].id },
+    ]) {
+      const routesScreens = await queryRunner.manager
         .createQueryBuilder()
-        .insert()
-        .into('role_routes')
-        .values({
-          role_id: 2,
-          route_id: route.id,
-        })
+        .select()
+        .from('routes', 's')
+        .where('s.url LIKE :url', { url })
         .execute();
+
+      for (const route of routesScreens) {
+        await queryRunner.manager
+          .createQueryBuilder()
+          .insert()
+          .into('route_screens')
+          .values({
+            route_id: route.id,
+            screen_id: screendId,
+          })
+          .execute();
+      }
     }
   }
 
   async down(queryRunner: QueryRunner) {
-    await queryRunner.manager.delete('role_routes', { role_id: 1 });
-    await queryRunner.manager.delete('role_routes', { role_id: 2 });
+    await queryRunner.manager.delete('route_screens', {});
   }
 }