feat: 统一sql命名、函数命名

2026-08-02 12:02:04 +08:00
parent d39342ce5f
commit 0e674e9d56
68 changed files with 1985 additions and 1720 deletions
--- a/internal/db/migrations/000011_add_column_to_files.down.sql
+++ b/internal/db/migrations/000011_add_column_to_files.down.sql
@@ -0,0 +1 @@
+ALTER TABLE files DROP COLUMN IF EXISTS file_url;
--- a/internal/db/migrations/000011_add_column_to_files.up.sql
+++ b/internal/db/migrations/000011_add_column_to_files.up.sql
@@ -0,0 +1,10 @@
+ALTER TABLE files
+ADD COLUMN IF NOT EXISTS file_url TEXT;
+
+UPDATE files
+SET file_url = '';
+
+ALTER TABLE files
+ALTER COLUMN file_url SET NOT NULL;
+
+COMMENT ON COLUMN files.file_url IS '完整路径';
--- a/internal/db/query/files.sql
+++ b/internal/db/query/files.sql
@@ -1,12 +1,13 @@
 -- name: CreateFile :one
-INSERT INTO files(file_name, file_path, original_name, folder_name, mime_type, file_size)
-VALUES ($1, $2, $3, $4, $5, $6) RETURNING id,file_path,file_name;
+INSERT INTO files(file_name, file_path, original_name, folder_name, mime_type, file_size, file_url)
+VALUES ($1, $2, $3, $4, $5, $6, $7)
+RETURNING id,file_url,file_name;

-- name: GetFiles :many
+-- name: ListFiles :many
 SELECT *
 FROM files
-ORDER BY id LIMIT $1
-OFFSET $2;
+ORDER BY id
+LIMIT $1 OFFSET $2;

 -- name: CountFiles :one
 SELECT COUNT(*)
--- a/internal/db/query/post.sql
+++ b/internal/db/query/post.sql
@@ -22,7 +22,7 @@ WITH paginated_posts AS (
 )
 -- 第二步：用这极少量的记录去进行 JOIN
 SELECT p.*,
-       f.file_path          AS cover,
+       f.file_url          AS cover,
       c.name               AS category_name,
       c.id                 AS category_id,
       COALESCE(ps.view, 0) AS view,
@@ -54,7 +54,7 @@ GROUP BY p.id,
         p.published_at,
         p.created_at,
         p.updated_at,
-         f.file_path,
+         f.file_url,
         c.name,
         c.id,
         ps.view
@@ -64,9 +64,9 @@ ORDER BY p.sort DESC, p.published_at DESC, p.id DESC;
 SELECT COUNT(*)
 FROM posts;

-- name: GetPostById :one
+-- name: GetPostByID :one
 SELECT p.*,
-       f.file_path AS cover,
+       f.file_url AS cover,
       c.name      AS category_name,
       c.id        AS category_id,
       COALESCE(
@@ -80,7 +80,7 @@ FROM posts p
         LEFT JOIN post_tag pt ON pt.post_id = p.id
 WHERE p.id = $1
 GROUP BY p.id,
-         f.file_path,
+         f.file_url,
         c.name,
         c.id
 LIMIT 1;
@@ -106,7 +106,7 @@ WHERE id = $1;

 -- name: GetPublicPostBySlug :one
 SELECT p.*,
-       f.file_path          AS cover,
+       f.file_url          AS cover,
       COALESCE(ps.view, 0) AS view
 FROM posts p
         LEFT JOIN files f ON f.id = p.cover_id
@@ -132,7 +132,7 @@ WITH paginated_posts AS (
    ORDER BY sort DESC, published_at DESC, id DESC
    LIMIT $1 OFFSET $2)
 SELECT p.*,
-       f.file_path          AS cover,
+       f.file_url          AS cover,
       c.name               AS category_name,
       c.id                 AS category_id,
       COALESCE(ps.view, 0) AS view,
@@ -161,7 +161,7 @@ GROUP BY p.id,
         p.summary,
         p.sort,
         p.published_at,
-         f.file_path,
+         f.file_url,
         c.name,
         c.id,
         ps.view
--- a/internal/db/query/sys_apis.sql
+++ b/internal/db/query/sys_apis.sql
@@ -1,28 +1,35 @@
-- name: CreateSysApi :one
+-- name: CreateApi :one
 INSERT INTO sys_apis (name, group_name, method, path, sort)
 VALUES ($1, $2, $3, $4, $5)
 RETURNING id;

-- name: GetSysApis :many
+-- name: ListAllApis :many
 SELECT *
 FROM sys_apis
-WHERE (sqlc.arg('group_name')::text = '' OR group_name ILIKE '%' || sqlc.arg('group_name') || '%')
+ORDER BY sort ASC;
+
+-- name: ListApis :many
+SELECT *
+FROM sys_apis
+WHERE (sqlc.arg('name')::text = '' OR name ILIKE '%' || sqlc.arg('name') || '%')
+  AND (sqlc.arg('group_name')::text = '' OR group_name ILIKE '%' || sqlc.arg('group_name') || '%')
  AND (sqlc.arg('method')::text = '' OR method = sqlc.arg('method'))
 ORDER BY id
 LIMIT $1 OFFSET $2;

-- name: CountSysApis :one
+-- name: CountApis :one
 SELECT COUNT(*)
 FROM sys_apis
-WHERE (sqlc.arg('group_name')::text = '' OR group_name ILIKE '%' || sqlc.arg('group_name') || '%')
+WHERE (sqlc.arg('name')::text = '' OR name ILIKE '%' || sqlc.arg('name') || '%')
+  AND (sqlc.arg('group_name')::text = '' OR group_name ILIKE '%' || sqlc.arg('group_name') || '%')
  AND (sqlc.arg('method')::text = '' OR method = sqlc.arg('method'));

-- name: GetSysApiByID :one
+-- name: GetApiByID :one
 SELECT *
 FROM sys_apis
 WHERE id = $1;

-- name: UpdateSysApi :execrows
+-- name: UpdateApi :execrows
 UPDATE sys_apis
 SET name       = $2,
    method     = $3,
@@ -31,25 +38,21 @@ SET name       = $2,
    group_name = $6
 WHERE id = $1;

-- name: DeleteSysApi :execrows
+-- name: DeleteApi :execrows
 DELETE
 FROM sys_apis
 WHERE id = $1;

-- name: CreateSysApiPermission :exec
+-- name: CreateApiPermission :exec
 INSERT INTO sys_api_permission (api_id, permission_id)
 VALUES ($1, $2);

-- name: DeleteSysApiPermission :exec
+-- name: DeleteApiPermission :exec
 DELETE
 FROM sys_api_permission
 WHERE api_id = $1;

-- name: GetSysApiGroupNames :many
+-- name: ListApiGroups :many
 SELECT DISTINCT group_name
 FROM sys_apis;

-- name: GetAllSysApis :many
-SELECT *
-FROM sys_apis
-ORDER BY sort ASC;
--- a/internal/db/query/sys_menus.sql
+++ b/internal/db/query/sys_menus.sql
@@ -1,9 +1,9 @@
-- name: CreateSysMenu :one
+-- name: CreateMenu :one
 INSERT INTO sys_menus (name, path, component, type, hidden, sort, status, parent_id, icon)
 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
 RETURNING id;

-- name: ListSysMenus :many
+-- name: ListMenus :many
 SELECT m.*, p.code AS permission_code
 FROM sys_menus m
         LEFT JOIN sys_menu_permission mp ON m.id = mp.menu_id
@@ -11,11 +11,11 @@ FROM sys_menus m
 ORDER BY m.id
 LIMIT $1 OFFSET $2;

-- name: CountSysMenus :one
+-- name: CountMenus :one
 SELECT COUNT(*)
 FROM sys_menus;

-- name: GetAllSysMenus :many
+-- name: ListAllMenus :many
 SELECT m.*,
       p.code AS permission_code
 FROM sys_menus m
@@ -24,12 +24,12 @@ FROM sys_menus m
 ORDER BY m.sort ASC,
         m.id ASC;

-- name: GetSysMenuByID :one
+-- name: GetMenuByID :one
 SELECT *
 FROM sys_menus
 WHERE id = $1;

-- name: UpdateSysMenu :execrows
+-- name: UpdateMenu :execrows
 UPDATE sys_menus
 SET name      = coalesce(sqlc.narg('name'), name),
    path      = coalesce(sqlc.narg('path'), path),
@@ -42,28 +42,28 @@ SET name      = coalesce(sqlc.narg('name'), name),
    parent_id = CASE WHEN @update_parent_id::boolean THEN @parent_id ELSE parent_id END
 WHERE id = sqlc.arg('id');

-- name: DeleteSysMenu :execrows
+-- name: DeleteMenu :execrows
 DELETE
 FROM sys_menus
 WHERE id = $1;

-- name: CreateSysMenuPermission :exec
+-- name: CreateMenuPermission :exec
 INSERT INTO sys_menu_permission (menu_id, permission_id)
 VALUES ($1, $2);

-- name: DeleteSysMenuPermission :exec
+-- name: DeleteMenuPermission :exec
 DELETE
 FROM sys_menu_permission
 WHERE menu_id = $1;

-- name: DeleteSysPermissionByMenuID :exec
+-- name: DeletePermissionsByMenuID :exec
 DELETE
 FROM sys_permissions
 WHERE id IN (SELECT permission_id
             FROM sys_menu_permission
             WHERE menu_id = $1);

-- name: UpdateSysMenuPermissionCode :exec
+-- name: UpdateMenuPermissionCode :exec
 UPDATE sys_permissions p
 SET code = coalesce(sqlc.narg('code'), code)
 FROM sys_menu_permission mp
--- a/internal/db/query/sys_permissions.sql
+++ b/internal/db/query/sys_permissions.sql
@@ -1,23 +1,23 @@
-- name: CreateSysPermission :one
+-- name: CreatePermission :one
 INSERT INTO sys_permissions(type,code)
 VALUES ($1,$2) RETURNING id;

-- name: UpdateSysPermission :exec
+-- name: UpdatePermission :exec
 UPDATE sys_permissions
 SET code = $2
 WHERE id = $1;

-- name: DeleteSysPermission :exec
+-- name: DeletePermission :exec
 DELETE
 FROM sys_permissions
 WHERE id = $1;

-- name: GetSysPermissionIDBySysApiID :one
+-- name: GetPermissionIDBySysApiID :one
 SELECT permission_id
 FROM sys_api_permission
 WHERE api_id = $1;

-- name: GetSysPermissionIDBySysMenuID :one
+-- name: GetPermissionIDBySysMenuID :one
 SELECT permission_id
 FROM sys_menu_permission
 WHERE menu_id = $1;
--- a/internal/db/query/sys_roles.sql
+++ b/internal/db/query/sys_roles.sql
@@ -1,23 +1,27 @@
-- name: CreateSysRole :exec
+-- name: CreateRole :exec
 INSERT INTO sys_roles (name, code, status)
 VALUES ($1, $2, $3);

-- name: ListSysRoles :many
+-- name: ListAllRoles :many
+SELECT *
+from sys_roles;
+
+-- name: ListRoles :many
 SELECT *
 FROM sys_roles
 ORDER BY id
 LIMIT $1 OFFSET $2;

-- name: CountSysRoles :one
+-- name: CountRoles :one
 SELECT COUNT(*)
 FROM sys_roles;

-- name: GetSysRoleByID :one
+-- name: GetRoleByID :one
 SELECT *
 FROM sys_roles
 WHERE id = $1;

-- name: ExistsSysRoleCode :one
+-- name: ExistsRoleCode :one
 SELECT EXISTS(SELECT 1
              FROM sys_roles
              WHERE code = sqlc.arg(code)
@@ -26,67 +30,65 @@ SELECT EXISTS(SELECT 1
                      OR id <> sqlc.narg(id)::integer
                  ));

-- name: UpdateSysRole :execrows
+-- name: UpdateRole :execrows
 UPDATE sys_roles
 SET name   = coalesce(sqlc.narg('name'), name),
    status = coalesce(sqlc.narg('status'), status)
 WHERE id = sqlc.arg('id');

-- name: DeleteSysRole :execrows
+-- name: DeleteRole :execrows
 DELETE
 FROM sys_roles
 WHERE id = $1;

-- name: CreateSysRolePermission :copyfrom
+-- name: CreateRolePermission :copyfrom
 INSERT INTO sys_role_permission (role_id, permission_id)
 VALUES ($1, $2);

-- name: GetSysPermissionIdsByMenuIDs :many
+-- name: ListPermissionIDsByMenuIDs :many
 SELECT permission_id
 FROM sys_menu_permission
 WHERE menu_id = ANY ($1::int[]);

-- name: GetSysPermissionIdsByApiIDs :many
+-- name: ListPermissionIDsByApiIDs :many
 SELECT permission_id
 FROM sys_api_permission
 WHERE api_id = ANY ($1::int[]);

-- name: GetAllSysRoles :many
-SELECT *
-from sys_roles;

-- name: GetSysRoleMenus :many
+
+-- name: ListRoleMenus :many
 SELECT m.id, m.name
 FROM sys_role_permission rp
         JOIN sys_menu_permission mp ON mp.permission_id = rp.permission_id
         JOIN sys_menus m ON m.id = mp.menu_id
 WHERE rp.role_id = $1;

-- name: GetSysRoleApis :many
+-- name: ListRoleApis :many
 SELECT a.id, a."name"
 FROM sys_role_permission rp
         JOIN sys_api_permission ap ON ap.permission_id = rp.permission_id
         JOIN sys_apis a ON a.id = ap.api_id
 WHERE rp.role_id = $1;

-- name: DeleteSysRolePermissionByType :exec
+-- name: DeleteRolePermissionsByType :exec
 DELETE
 FROM sys_role_permission rp USING sys_permissions p
 WHERE rp.permission_id = p.id
  AND rp.role_id = $1
  AND p."type" = $2;

-- name: DeleteSysRolePermissionByRoleID :exec
+-- name: DeleteRolePermissionsByRoleID :exec
 DELETE
 FROM sys_role_permission
 WHERE role_id = $1;

-- name: DeleteSysRolePermissionByPermissionID :exec
+-- name: DeleteRolePermissionByPermissionID :exec
 DELETE
 FROM sys_role_permission
 WHERE permission_id = $1;

-- name: DeleteSysUserRoleByRoleID :exec
+-- name: DeleteUserRoleByRoleID :exec
 DELETE
 FROM sys_user_role
 WHERE role_id = $1;
--- a/internal/db/query/sys_users.sql
+++ b/internal/db/query/sys_users.sql
@@ -1,48 +1,48 @@
-- name: CreateSysUser :exec
+-- name: CreateUser :exec
 INSERT INTO sys_users (account, username, password_hash, status, avatar_id)
 VALUES ($1, $2, $3, $4, $5);

-- name: GetActiveSysUserByID :one
+-- name: GetActiveUserByID :one
 -- 场景：用户登录、获取个人信息、刷新 Token（严格校验 status = 1）
 SELECT id, account, username, status
 FROM sys_users
 WHERE id = $1
  AND status = 1;

-- name: GetSysUserByID :one
+-- name: GetUserByID :one
 SELECT u.id,
       u.account,
       u.username,
       u.avatar_id,
       u.status,
-       f.file_path AS avatar_url,
+       f.file_url AS avatar_url,
       u.created_at,
       u.updated_at
 FROM sys_users u
         LEFT JOIN files f ON u.avatar_id = f.id
 WHERE u.id = $1;

-- name: GetSysUserByAccount :one
+-- name: GetUserByAccount :one
 SELECT u.id,
       u.account,
       u.username,
       u.password_hash,
       u.status,
       u.avatar_id,
-       f.file_path AS avatar_url,
+       f.file_url AS avatar_url,
       u.created_at,
       u.updated_at
 FROM sys_users u
         LEFT JOIN files f ON u.avatar_id = f.id
 WHERE u.account = $1;

-- name: ListSysUsers :many
+-- name: ListUsers :many
 SELECT u.id,
       u.account,
       u.username,
       u.status,
       u.avatar_id,
-       f.file_path AS avatar_url,
+       f.file_url AS avatar_url,
       u.created_at,
       u.updated_at
 FROM sys_users u
@@ -51,57 +51,57 @@ WHERE (sqlc.arg('username')::text = '' OR u.username ILIKE '%' || sqlc.arg('user
 ORDER BY u.id
 LIMIT $1 OFFSET $2;

-- name: CountSysUsers :one
+-- name: CountUsers :one
 SELECT COUNT(*)
 FROM sys_users
 WHERE (sqlc.arg('username')::text = '' OR username ILIKE '%' || sqlc.arg('username') || '%');

-- name: UpdateSysUser :execrows
+-- name: UpdateUser :execrows
 UPDATE sys_users
 SET username  = coalesce(sqlc.narg('username'), username),
    status    = coalesce(sqlc.narg('status'), status),
    avatar_id = CASE WHEN @update_avatar_id::boolean THEN @avatar_id ELSE avatar_id END
 WHERE id = sqlc.arg('id');

-- name: UpdateSysUserPassword :execrows
+-- name: UpdateUserPassword :execrows
 UPDATE sys_users
 SET password_hash = $2
 WHERE id = $1;

-- name: DeleteSysUser :execrows
+-- name: DeleteUser :execrows
 DELETE
 FROM sys_users
 WHERE id = $1
  AND id <> 1;

-- name: ClearSysUserRoles :exec
+-- name: ClearUserRoles :exec
 DELETE
 FROM sys_user_role
 WHERE user_id = $1;

-- name: CreateSysUserRole :copyfrom
+-- name: CreateUserRole :copyfrom
 INSERT INTO sys_user_role (user_id, role_id)
 VALUES ($1, $2);

-- name: GetSysUserRoles :many
+-- name: ListUserRoles :many
 SELECT r.*
 FROM sys_roles r
         JOIN sys_user_role ur ON r.id = ur.role_id
 WHERE ur.user_id = $1;

-- name: GetSysAdminMenus :many
+-- name: ListAdminMenus :many
 SELECT *
 FROM sys_menus
 WHERE status = 1
  AND type <> 2
 ORDER BY sort, id;

-- name: GetSysAdminPermissions :many
+-- name: ListAdminPermissionCodes :many
 SELECT code
 FROM sys_permissions
 WHERE type = 0;

-- name: GetSysUserMenus :many
+-- name: ListUserMenus :many
 SELECT DISTINCT m.*
 FROM sys_users u
         JOIN sys_user_role ur ON ur.user_id = u.id
@@ -116,7 +116,7 @@ WHERE u.id = $1
  AND m.type <> 2
 ORDER BY m.sort, m.id;

-- name: GetSysUserPermissions :many
+-- name: ListUserPermissionCodes :many
 SELECT DISTINCT p.code
 FROM sys_users u
         JOIN sys_user_role ur ON u.id = ur.user_id
@@ -131,7 +131,7 @@ WHERE u.id = $1
  AND m.status = 1
  AND p."type" = 0;

-- name: GetSysUserApis :many
+-- name: ListUserApis :many
 SELECT DISTINCT a.id,
                a.PATH,
                a.METHOD
--- a/internal/db/schema/files.sql
+++ b/internal/db/schema/files.sql
@@ -1,12 +1,13 @@
 CREATE TABLE files
 (
    id            INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-    file_name     TEXT      NOT NULL,
-    file_path     TEXT      NOT NULL,
-    original_name TEXT      NOT NULL,
-    folder_name   TEXT      NOT NULL,
-    mime_type     TEXT      NOT NULL,
-    file_size     BIGINT    NOT NULL,
+    file_name     TEXT        NOT NULL,
+    file_path     TEXT        NOT NULL,
+    file_url      TEXT        NOT NULL,
+    original_name TEXT        NOT NULL,
+    folder_name   TEXT        NOT NULL,
+    mime_type     TEXT        NOT NULL,
+    file_size     BIGINT      NOT NULL,
    created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at    TIMESTAMPTZ
 );
@@ -20,6 +21,7 @@ EXECUTE FUNCTION update_updated_at_column();
 COMMENT ON COLUMN files.id IS '主键ID';
 COMMENT ON COLUMN files.file_name IS '文件名 xxx.jpg';
 COMMENT ON COLUMN files.file_path IS '文件路径 带path /xxx/xxx.jpg';
+COMMENT ON COLUMN files.file_url IS '完整路径';
 COMMENT ON COLUMN files.original_name IS '原始文件名';
 COMMENT ON COLUMN files.folder_name IS '文件夹名称';
 COMMENT ON COLUMN files.mime_type IS 'mime_type';
--- a/internal/db/sqlc/copyfrom.go
+++ b/internal/db/sqlc/copyfrom.go
@@ -42,13 +42,13 @@ func (q *Queries) CreatePostTag(ctx context.Context, arg []CreatePostTagParams)
 	return q.db.CopyFrom(ctx, []string{"post_tag"}, []string{"post_id", "tag_id"}, &iteratorForCreatePostTag{rows: arg})
 }

-// iteratorForCreateSysRolePermission implements pgx.CopyFromSource.
-type iteratorForCreateSysRolePermission struct {
-	rows                 []CreateSysRolePermissionParams
+// iteratorForCreateRolePermission implements pgx.CopyFromSource.
+type iteratorForCreateRolePermission struct {
+	rows                 []CreateRolePermissionParams
 	skippedFirstNextCall bool
 }

-func (r *iteratorForCreateSysRolePermission) Next() bool {
+func (r *iteratorForCreateRolePermission) Next() bool {
 	if len(r.rows) == 0 {
 		return false
 	}
@@ -60,28 +60,28 @@ func (r *iteratorForCreateSysRolePermission) Next() bool {
 	return len(r.rows) > 0
 }

-func (r iteratorForCreateSysRolePermission) Values() ([]interface{}, error) {
+func (r iteratorForCreateRolePermission) Values() ([]interface{}, error) {
 	return []interface{}{
 		r.rows[0].RoleID,
 		r.rows[0].PermissionID,
 	}, nil
 }

-func (r iteratorForCreateSysRolePermission) Err() error {
+func (r iteratorForCreateRolePermission) Err() error {
 	return nil
 }

-func (q *Queries) CreateSysRolePermission(ctx context.Context, arg []CreateSysRolePermissionParams) (int64, error) {
-	return q.db.CopyFrom(ctx, []string{"sys_role_permission"}, []string{"role_id", "permission_id"}, &iteratorForCreateSysRolePermission{rows: arg})
+func (q *Queries) CreateRolePermission(ctx context.Context, arg []CreateRolePermissionParams) (int64, error) {
+	return q.db.CopyFrom(ctx, []string{"sys_role_permission"}, []string{"role_id", "permission_id"}, &iteratorForCreateRolePermission{rows: arg})
 }

-// iteratorForCreateSysUserRole implements pgx.CopyFromSource.
-type iteratorForCreateSysUserRole struct {
-	rows                 []CreateSysUserRoleParams
+// iteratorForCreateUserRole implements pgx.CopyFromSource.
+type iteratorForCreateUserRole struct {
+	rows                 []CreateUserRoleParams
 	skippedFirstNextCall bool
 }

-func (r *iteratorForCreateSysUserRole) Next() bool {
+func (r *iteratorForCreateUserRole) Next() bool {
 	if len(r.rows) == 0 {
 		return false
 	}
@@ -93,17 +93,17 @@ func (r *iteratorForCreateSysUserRole) Next() bool {
 	return len(r.rows) > 0
 }

-func (r iteratorForCreateSysUserRole) Values() ([]interface{}, error) {
+func (r iteratorForCreateUserRole) Values() ([]interface{}, error) {
 	return []interface{}{
 		r.rows[0].UserID,
 		r.rows[0].RoleID,
 	}, nil
 }

-func (r iteratorForCreateSysUserRole) Err() error {
+func (r iteratorForCreateUserRole) Err() error {
 	return nil
 }

-func (q *Queries) CreateSysUserRole(ctx context.Context, arg []CreateSysUserRoleParams) (int64, error) {
-	return q.db.CopyFrom(ctx, []string{"sys_user_role"}, []string{"user_id", "role_id"}, &iteratorForCreateSysUserRole{rows: arg})
+func (q *Queries) CreateUserRole(ctx context.Context, arg []CreateUserRoleParams) (int64, error) {
+	return q.db.CopyFrom(ctx, []string{"sys_user_role"}, []string{"user_id", "role_id"}, &iteratorForCreateUserRole{rows: arg})
 }
--- a/internal/db/sqlc/files.sql.go
+++ b/internal/db/sqlc/files.sql.go
@@ -22,8 +22,9 @@ func (q *Queries) CountFiles(ctx context.Context) (int64, error) {
 }

 const createFile = `-- name: CreateFile :one
-INSERT INTO files(file_name, file_path, original_name, folder_name, mime_type, file_size)
-VALUES ($1, $2, $3, $4, $5, $6) RETURNING id,file_path,file_name
+INSERT INTO files(file_name, file_path, original_name, folder_name, mime_type, file_size, file_url)
+VALUES ($1, $2, $3, $4, $5, $6, $7)
+RETURNING id,file_url,file_name
 `

 type CreateFileParams struct {
@@ -33,11 +34,12 @@ type CreateFileParams struct {
 	FolderName   string `json:"folder_name"`
 	MimeType     string `json:"mime_type"`
 	FileSize     int64  `json:"file_size"`
+	FileUrl      string `json:"file_url"`
 }

 type CreateFileRow struct {
 	ID       int32  `json:"id"`
-	FilePath string `json:"file_path"`
+	FileUrl  string `json:"file_url"`
 	FileName string `json:"file_name"`
 }

@@ -49,26 +51,27 @@ func (q *Queries) CreateFile(ctx context.Context, arg CreateFileParams) (CreateF
 		arg.FolderName,
 		arg.MimeType,
 		arg.FileSize,
+		arg.FileUrl,
 	)
 	var i CreateFileRow
-	err := row.Scan(&i.ID, &i.FilePath, &i.FileName)
+	err := row.Scan(&i.ID, &i.FileUrl, &i.FileName)
 	return i, err
 }

-const getFiles = `-- name: GetFiles :many
-SELECT id, file_name, file_path, original_name, folder_name, mime_type, file_size, created_at, updated_at
+const listFiles = `-- name: ListFiles :many
+SELECT id, file_name, file_path, file_url, original_name, folder_name, mime_type, file_size, created_at, updated_at
 FROM files
-ORDER BY id LIMIT $1
-OFFSET $2
+ORDER BY id
+LIMIT $1 OFFSET $2
 `

-type GetFilesParams struct {
+type ListFilesParams struct {
 	Limit  int32 `json:"limit"`
 	Offset int32 `json:"offset"`
 }

-func (q *Queries) GetFiles(ctx context.Context, arg GetFilesParams) ([]File, error) {
-	rows, err := q.db.Query(ctx, getFiles, arg.Limit, arg.Offset)
+func (q *Queries) ListFiles(ctx context.Context, arg ListFilesParams) ([]File, error) {
+	rows, err := q.db.Query(ctx, listFiles, arg.Limit, arg.Offset)
 	if err != nil {
 		return nil, err
 	}
@@ -80,6 +83,7 @@ func (q *Queries) GetFiles(ctx context.Context, arg GetFilesParams) ([]File, err
 			&i.ID,
 			&i.FileName,
 			&i.FilePath,
+			&i.FileUrl,
 			&i.OriginalName,
 			&i.FolderName,
 			&i.MimeType,
--- a/internal/db/sqlc/models.go
+++ b/internal/db/sqlc/models.go
@@ -29,6 +29,8 @@ type File struct {
 	FileName string `json:"file_name"`
 	// 文件路径 带path /xxx/xxx.jpg
 	FilePath string `json:"file_path"`
+	// 完整路径
+	FileUrl string `json:"file_url"`
 	// 原始文件名
 	OriginalName string `json:"original_name"`
 	// 文件夹名称
--- a/internal/db/sqlc/post.sql.go
+++ b/internal/db/sqlc/post.sql.go
@@ -83,9 +83,9 @@ func (q *Queries) DeletePost(ctx context.Context, id int32) (int64, error) {
 	return result.RowsAffected(), nil
 }

-const getPostById = `-- name: GetPostById :one
+const getPostByID = `-- name: GetPostByID :one
 SELECT p.id, p.title, p.cover_id, p.slug, p.content, p.summary, p.status, p.sort, p.published_at, p.created_at, p.updated_at,
-       f.file_path AS cover,
+       f.file_url AS cover,
       c.name      AS category_name,
       c.id        AS category_id,
       COALESCE(
@@ -99,13 +99,13 @@ FROM posts p
         LEFT JOIN post_tag pt ON pt.post_id = p.id
 WHERE p.id = $1
 GROUP BY p.id,
-         f.file_path,
+         f.file_url,
         c.name,
         c.id
 LIMIT 1
 `

-type GetPostByIdRow struct {
+type GetPostByIDRow struct {
 	ID           int32       `json:"id"`
 	Title        string      `json:"title"`
 	CoverID      *int32      `json:"cover_id"`
@@ -123,9 +123,9 @@ type GetPostByIdRow struct {
 	Tags         interface{} `json:"tags"`
 }

-func (q *Queries) GetPostById(ctx context.Context, id int32) (GetPostByIdRow, error) {
-	row := q.db.QueryRow(ctx, getPostById, id)
-	var i GetPostByIdRow
+func (q *Queries) GetPostByID(ctx context.Context, id int32) (GetPostByIDRow, error) {
+	row := q.db.QueryRow(ctx, getPostByID, id)
+	var i GetPostByIDRow
 	err := row.Scan(
 		&i.ID,
 		&i.Title,
@@ -149,7 +149,7 @@ func (q *Queries) GetPostById(ctx context.Context, id int32) (GetPostByIdRow, er
 const getPublicPostBySlug = `-- name: GetPublicPostBySlug :one

 SELECT p.id, p.title, p.cover_id, p.slug, p.content, p.summary, p.status, p.sort, p.published_at, p.created_at, p.updated_at,
-       f.file_path          AS cover,
+       f.file_url          AS cover,
       COALESCE(ps.view, 0) AS view
 FROM posts p
         LEFT JOIN files f ON f.id = p.cover_id
@@ -312,7 +312,7 @@ WITH paginated_posts AS (
    LIMIT $1 OFFSET $2
 )
 SELECT p.id, p.title, p.cover_id, p.slug, p.summary, p.status, p.sort, p.published_at, p.created_at, p.updated_at,
-       f.file_path          AS cover,
+       f.file_url          AS cover,
       c.name               AS category_name,
       c.id                 AS category_id,
       COALESCE(ps.view, 0) AS view,
@@ -344,7 +344,7 @@ GROUP BY p.id,
         p.published_at,
         p.created_at,
         p.updated_at,
-         f.file_path,
+         f.file_url,
         c.name,
         c.id,
         ps.view
@@ -427,7 +427,7 @@ WITH paginated_posts AS (
    ORDER BY sort DESC, published_at DESC, id DESC
    LIMIT $1 OFFSET $2)
 SELECT p.id, p.title, p.cover_id, p.slug, p.summary, p.sort, p.published_at,
-       f.file_path          AS cover,
+       f.file_url          AS cover,
       c.name               AS category_name,
       c.id                 AS category_id,
       COALESCE(ps.view, 0) AS view,
@@ -456,7 +456,7 @@ GROUP BY p.id,
         p.summary,
         p.sort,
         p.published_at,
-         f.file_path,
+         f.file_url,
         c.name,
         c.id,
         ps.view
--- a/internal/db/sqlc/sys_apis.sql.go
+++ b/internal/db/sqlc/sys_apis.sql.go
@@ -9,32 +9,34 @@ import (
 	"context"
 )

-const countSysApis = `-- name: CountSysApis :one
+const countApis = `-- name: CountApis :one
 SELECT COUNT(*)
 FROM sys_apis
-WHERE ($1::text = '' OR group_name ILIKE '%' || $1 || '%')
-  AND ($2::text = '' OR method = $2)
+WHERE ($1::text = '' OR name ILIKE '%' || $1 || '%')
+  AND ($2::text = '' OR group_name ILIKE '%' || $2 || '%')
+  AND ($3::text = '' OR method = $3)
 `

-type CountSysApisParams struct {
+type CountApisParams struct {
+	Name      string `json:"name"`
 	GroupName string `json:"group_name"`
 	Method    string `json:"method"`
 }

-func (q *Queries) CountSysApis(ctx context.Context, arg CountSysApisParams) (int64, error) {
-	row := q.db.QueryRow(ctx, countSysApis, arg.GroupName, arg.Method)
+func (q *Queries) CountApis(ctx context.Context, arg CountApisParams) (int64, error) {
+	row := q.db.QueryRow(ctx, countApis, arg.Name, arg.GroupName, arg.Method)
 	var count int64
 	err := row.Scan(&count)
 	return count, err
 }

-const createSysApi = `-- name: CreateSysApi :one
+const createApi = `-- name: CreateApi :one
 INSERT INTO sys_apis (name, group_name, method, path, sort)
 VALUES ($1, $2, $3, $4, $5)
 RETURNING id
 `

-type CreateSysApiParams struct {
+type CreateApiParams struct {
 	Name      string `json:"name"`
 	GroupName string `json:"group_name"`
 	Method    string `json:"method"`
@@ -42,8 +44,8 @@ type CreateSysApiParams struct {
 	Sort      *int32 `json:"sort"`
 }

-func (q *Queries) CreateSysApi(ctx context.Context, arg CreateSysApiParams) (int32, error) {
-	row := q.db.QueryRow(ctx, createSysApi,
+func (q *Queries) CreateApi(ctx context.Context, arg CreateApiParams) (int32, error) {
+	row := q.db.QueryRow(ctx, createApi,
 		arg.Name,
 		arg.GroupName,
 		arg.Method,
@@ -55,54 +57,76 @@ func (q *Queries) CreateSysApi(ctx context.Context, arg CreateSysApiParams) (int
 	return id, err
 }

-const createSysApiPermission = `-- name: CreateSysApiPermission :exec
+const createApiPermission = `-- name: CreateApiPermission :exec
 INSERT INTO sys_api_permission (api_id, permission_id)
 VALUES ($1, $2)
 `

-type CreateSysApiPermissionParams struct {
+type CreateApiPermissionParams struct {
 	ApiID        int32 `json:"api_id"`
 	PermissionID int32 `json:"permission_id"`
 }

-func (q *Queries) CreateSysApiPermission(ctx context.Context, arg CreateSysApiPermissionParams) error {
-	_, err := q.db.Exec(ctx, createSysApiPermission, arg.ApiID, arg.PermissionID)
+func (q *Queries) CreateApiPermission(ctx context.Context, arg CreateApiPermissionParams) error {
+	_, err := q.db.Exec(ctx, createApiPermission, arg.ApiID, arg.PermissionID)
 	return err
 }

-const deleteSysApi = `-- name: DeleteSysApi :execrows
+const deleteApi = `-- name: DeleteApi :execrows
 DELETE
 FROM sys_apis
 WHERE id = $1
 `

-func (q *Queries) DeleteSysApi(ctx context.Context, id int32) (int64, error) {
-	result, err := q.db.Exec(ctx, deleteSysApi, id)
+func (q *Queries) DeleteApi(ctx context.Context, id int32) (int64, error) {
+	result, err := q.db.Exec(ctx, deleteApi, id)
 	if err != nil {
 		return 0, err
 	}
 	return result.RowsAffected(), nil
 }

-const deleteSysApiPermission = `-- name: DeleteSysApiPermission :exec
+const deleteApiPermission = `-- name: DeleteApiPermission :exec
 DELETE
 FROM sys_api_permission
 WHERE api_id = $1
 `

-func (q *Queries) DeleteSysApiPermission(ctx context.Context, apiID int32) error {
-	_, err := q.db.Exec(ctx, deleteSysApiPermission, apiID)
+func (q *Queries) DeleteApiPermission(ctx context.Context, apiID int32) error {
+	_, err := q.db.Exec(ctx, deleteApiPermission, apiID)
 	return err
 }

-const getAllSysApis = `-- name: GetAllSysApis :many
+const getApiByID = `-- name: GetApiByID :one
+SELECT id, group_name, name, method, path, sort, created_at, updated_at
+FROM sys_apis
+WHERE id = $1
+`
+
+func (q *Queries) GetApiByID(ctx context.Context, id int32) (SysApi, error) {
+	row := q.db.QueryRow(ctx, getApiByID, id)
+	var i SysApi
+	err := row.Scan(
+		&i.ID,
+		&i.GroupName,
+		&i.Name,
+		&i.Method,
+		&i.Path,
+		&i.Sort,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const listAllApis = `-- name: ListAllApis :many
 SELECT id, group_name, name, method, path, sort, created_at, updated_at
 FROM sys_apis
 ORDER BY sort ASC
 `

-func (q *Queries) GetAllSysApis(ctx context.Context) ([]SysApi, error) {
-	rows, err := q.db.Query(ctx, getAllSysApis)
+func (q *Queries) ListAllApis(ctx context.Context) ([]SysApi, error) {
+	rows, err := q.db.Query(ctx, listAllApis)
 	if err != nil {
 		return nil, err
 	}
@@ -130,35 +154,13 @@ func (q *Queries) GetAllSysApis(ctx context.Context) ([]SysApi, error) {
 	return items, nil
 }

-const getSysApiByID = `-- name: GetSysApiByID :one
-SELECT id, group_name, name, method, path, sort, created_at, updated_at
-FROM sys_apis
-WHERE id = $1
-`
-
-func (q *Queries) GetSysApiByID(ctx context.Context, id int32) (SysApi, error) {
-	row := q.db.QueryRow(ctx, getSysApiByID, id)
-	var i SysApi
-	err := row.Scan(
-		&i.ID,
-		&i.GroupName,
-		&i.Name,
-		&i.Method,
-		&i.Path,
-		&i.Sort,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getSysApiGroupNames = `-- name: GetSysApiGroupNames :many
+const listApiGroups = `-- name: ListApiGroups :many
 SELECT DISTINCT group_name
 FROM sys_apis
 `

-func (q *Queries) GetSysApiGroupNames(ctx context.Context) ([]string, error) {
-	rows, err := q.db.Query(ctx, getSysApiGroupNames)
+func (q *Queries) ListApiGroups(ctx context.Context) ([]string, error) {
+	rows, err := q.db.Query(ctx, listApiGroups)
 	if err != nil {
 		return nil, err
 	}
@@ -177,26 +179,29 @@ func (q *Queries) GetSysApiGroupNames(ctx context.Context) ([]string, error) {
 	return items, nil
 }

-const getSysApis = `-- name: GetSysApis :many
+const listApis = `-- name: ListApis :many
 SELECT id, group_name, name, method, path, sort, created_at, updated_at
 FROM sys_apis
-WHERE ($3::text = '' OR group_name ILIKE '%' || $3 || '%')
-  AND ($4::text = '' OR method = $4)
+WHERE ($3::text = '' OR name ILIKE '%' || $3 || '%')
+  AND ($4::text = '' OR group_name ILIKE '%' || $4 || '%')
+  AND ($5::text = '' OR method = $5)
 ORDER BY id
 LIMIT $1 OFFSET $2
 `

-type GetSysApisParams struct {
+type ListApisParams struct {
 	Limit     int32  `json:"limit"`
 	Offset    int32  `json:"offset"`
+	Name      string `json:"name"`
 	GroupName string `json:"group_name"`
 	Method    string `json:"method"`
 }

-func (q *Queries) GetSysApis(ctx context.Context, arg GetSysApisParams) ([]SysApi, error) {
-	rows, err := q.db.Query(ctx, getSysApis,
+func (q *Queries) ListApis(ctx context.Context, arg ListApisParams) ([]SysApi, error) {
+	rows, err := q.db.Query(ctx, listApis,
 		arg.Limit,
 		arg.Offset,
+		arg.Name,
 		arg.GroupName,
 		arg.Method,
 	)
@@ -227,7 +232,7 @@ func (q *Queries) GetSysApis(ctx context.Context, arg GetSysApisParams) ([]SysAp
 	return items, nil
 }

-const updateSysApi = `-- name: UpdateSysApi :execrows
+const updateApi = `-- name: UpdateApi :execrows
 UPDATE sys_apis
 SET name       = $2,
    method     = $3,
@@ -237,7 +242,7 @@ SET name       = $2,
 WHERE id = $1
 `

-type UpdateSysApiParams struct {
+type UpdateApiParams struct {
 	ID        int32  `json:"id"`
 	Name      string `json:"name"`
 	Method    string `json:"method"`
@@ -246,8 +251,8 @@ type UpdateSysApiParams struct {
 	GroupName string `json:"group_name"`
 }

-func (q *Queries) UpdateSysApi(ctx context.Context, arg UpdateSysApiParams) (int64, error) {
-	result, err := q.db.Exec(ctx, updateSysApi,
+func (q *Queries) UpdateApi(ctx context.Context, arg UpdateApiParams) (int64, error) {
+	result, err := q.db.Exec(ctx, updateApi,
 		arg.ID,
 		arg.Name,
 		arg.Method,
--- a/internal/db/sqlc/sys_menus.sql.go
+++ b/internal/db/sqlc/sys_menus.sql.go
@@ -10,25 +10,25 @@ import (
 	"time"
 )

-const countSysMenus = `-- name: CountSysMenus :one
+const countMenus = `-- name: CountMenus :one
 SELECT COUNT(*)
 FROM sys_menus
 `

-func (q *Queries) CountSysMenus(ctx context.Context) (int64, error) {
-	row := q.db.QueryRow(ctx, countSysMenus)
+func (q *Queries) CountMenus(ctx context.Context) (int64, error) {
+	row := q.db.QueryRow(ctx, countMenus)
 	var count int64
 	err := row.Scan(&count)
 	return count, err
 }

-const createSysMenu = `-- name: CreateSysMenu :one
+const createMenu = `-- name: CreateMenu :one
 INSERT INTO sys_menus (name, path, component, type, hidden, sort, status, parent_id, icon)
 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
 RETURNING id
 `

-type CreateSysMenuParams struct {
+type CreateMenuParams struct {
 	Name      string  `json:"name"`
 	Path      *string `json:"path"`
 	Component *string `json:"component"`
@@ -40,8 +40,8 @@ type CreateSysMenuParams struct {
 	Icon      *int32  `json:"icon"`
 }

-func (q *Queries) CreateSysMenu(ctx context.Context, arg CreateSysMenuParams) (int32, error) {
-	row := q.db.QueryRow(ctx, createSysMenu,
+func (q *Queries) CreateMenu(ctx context.Context, arg CreateMenuParams) (int32, error) {
+	row := q.db.QueryRow(ctx, createMenu,
 		arg.Name,
 		arg.Path,
 		arg.Component,
@@ -57,47 +57,47 @@ func (q *Queries) CreateSysMenu(ctx context.Context, arg CreateSysMenuParams) (i
 	return id, err
 }

-const createSysMenuPermission = `-- name: CreateSysMenuPermission :exec
+const createMenuPermission = `-- name: CreateMenuPermission :exec
 INSERT INTO sys_menu_permission (menu_id, permission_id)
 VALUES ($1, $2)
 `

-type CreateSysMenuPermissionParams struct {
+type CreateMenuPermissionParams struct {
 	MenuID       int32 `json:"menu_id"`
 	PermissionID int32 `json:"permission_id"`
 }

-func (q *Queries) CreateSysMenuPermission(ctx context.Context, arg CreateSysMenuPermissionParams) error {
-	_, err := q.db.Exec(ctx, createSysMenuPermission, arg.MenuID, arg.PermissionID)
+func (q *Queries) CreateMenuPermission(ctx context.Context, arg CreateMenuPermissionParams) error {
+	_, err := q.db.Exec(ctx, createMenuPermission, arg.MenuID, arg.PermissionID)
 	return err
 }

-const deleteSysMenu = `-- name: DeleteSysMenu :execrows
+const deleteMenu = `-- name: DeleteMenu :execrows
 DELETE
 FROM sys_menus
 WHERE id = $1
 `

-func (q *Queries) DeleteSysMenu(ctx context.Context, id int32) (int64, error) {
-	result, err := q.db.Exec(ctx, deleteSysMenu, id)
+func (q *Queries) DeleteMenu(ctx context.Context, id int32) (int64, error) {
+	result, err := q.db.Exec(ctx, deleteMenu, id)
 	if err != nil {
 		return 0, err
 	}
 	return result.RowsAffected(), nil
 }

-const deleteSysMenuPermission = `-- name: DeleteSysMenuPermission :exec
+const deleteMenuPermission = `-- name: DeleteMenuPermission :exec
 DELETE
 FROM sys_menu_permission
 WHERE menu_id = $1
 `

-func (q *Queries) DeleteSysMenuPermission(ctx context.Context, menuID int32) error {
-	_, err := q.db.Exec(ctx, deleteSysMenuPermission, menuID)
+func (q *Queries) DeleteMenuPermission(ctx context.Context, menuID int32) error {
+	_, err := q.db.Exec(ctx, deleteMenuPermission, menuID)
 	return err
 }

-const deleteSysPermissionByMenuID = `-- name: DeleteSysPermissionByMenuID :exec
+const deletePermissionsByMenuID = `-- name: DeletePermissionsByMenuID :exec
 DELETE
 FROM sys_permissions
 WHERE id IN (SELECT permission_id
@@ -105,79 +105,19 @@ WHERE id IN (SELECT permission_id
             WHERE menu_id = $1)
 `

-func (q *Queries) DeleteSysPermissionByMenuID(ctx context.Context, menuID int32) error {
-	_, err := q.db.Exec(ctx, deleteSysPermissionByMenuID, menuID)
+func (q *Queries) DeletePermissionsByMenuID(ctx context.Context, menuID int32) error {
+	_, err := q.db.Exec(ctx, deletePermissionsByMenuID, menuID)
 	return err
 }

-const getAllSysMenus = `-- name: GetAllSysMenus :many
-SELECT m.id, m.name, m.path, m.component, m.type, m.hidden, m.sort, m.status, m.parent_id, m.icon, m.created_at, m.updated_at,
-       p.code AS permission_code
-FROM sys_menus m
-         LEFT JOIN sys_menu_permission mp ON m.id = mp.menu_id
-         LEFT JOIN sys_permissions p ON p.id = mp.permission_id
-ORDER BY m.sort ASC,
-         m.id ASC
-`
-
-type GetAllSysMenusRow struct {
-	ID             int32      `json:"id"`
-	Name           string     `json:"name"`
-	Path           *string    `json:"path"`
-	Component      *string    `json:"component"`
-	Type           int16      `json:"type"`
-	Hidden         *bool      `json:"hidden"`
-	Sort           *int32     `json:"sort"`
-	Status         int16      `json:"status"`
-	ParentID       *int32     `json:"parent_id"`
-	Icon           *int32     `json:"icon"`
-	CreatedAt      time.Time  `json:"created_at"`
-	UpdatedAt      *time.Time `json:"updated_at"`
-	PermissionCode *string    `json:"permission_code"`
-}
-
-func (q *Queries) GetAllSysMenus(ctx context.Context) ([]GetAllSysMenusRow, error) {
-	rows, err := q.db.Query(ctx, getAllSysMenus)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []GetAllSysMenusRow{}
-	for rows.Next() {
-		var i GetAllSysMenusRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.Name,
-			&i.Path,
-			&i.Component,
-			&i.Type,
-			&i.Hidden,
-			&i.Sort,
-			&i.Status,
-			&i.ParentID,
-			&i.Icon,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-			&i.PermissionCode,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getSysMenuByID = `-- name: GetSysMenuByID :one
+const getMenuByID = `-- name: GetMenuByID :one
 SELECT id, name, path, component, type, hidden, sort, status, parent_id, icon, created_at, updated_at
 FROM sys_menus
 WHERE id = $1
 `

-func (q *Queries) GetSysMenuByID(ctx context.Context, id int32) (SysMenu, error) {
-	row := q.db.QueryRow(ctx, getSysMenuByID, id)
+func (q *Queries) GetMenuByID(ctx context.Context, id int32) (SysMenu, error) {
+	row := q.db.QueryRow(ctx, getMenuByID, id)
 	var i SysMenu
 	err := row.Scan(
 		&i.ID,
@@ -196,21 +136,17 @@ func (q *Queries) GetSysMenuByID(ctx context.Context, id int32) (SysMenu, error)
 	return i, err
 }

-const listSysMenus = `-- name: ListSysMenus :many
-SELECT m.id, m.name, m.path, m.component, m.type, m.hidden, m.sort, m.status, m.parent_id, m.icon, m.created_at, m.updated_at, p.code AS permission_code
+const listAllMenus = `-- name: ListAllMenus :many
+SELECT m.id, m.name, m.path, m.component, m.type, m.hidden, m.sort, m.status, m.parent_id, m.icon, m.created_at, m.updated_at,
+       p.code AS permission_code
 FROM sys_menus m
         LEFT JOIN sys_menu_permission mp ON m.id = mp.menu_id
-         LEFT JOIN sys_permissions p ON mp.permission_id = p.id
-ORDER BY m.id
-LIMIT $1 OFFSET $2
+         LEFT JOIN sys_permissions p ON p.id = mp.permission_id
+ORDER BY m.sort ASC,
+         m.id ASC
 `

-type ListSysMenusParams struct {
-	Limit  int32 `json:"limit"`
-	Offset int32 `json:"offset"`
-}
-
-type ListSysMenusRow struct {
+type ListAllMenusRow struct {
 	ID             int32      `json:"id"`
 	Name           string     `json:"name"`
 	Path           *string    `json:"path"`
@@ -226,15 +162,15 @@ type ListSysMenusRow struct {
 	PermissionCode *string    `json:"permission_code"`
 }

-func (q *Queries) ListSysMenus(ctx context.Context, arg ListSysMenusParams) ([]ListSysMenusRow, error) {
-	rows, err := q.db.Query(ctx, listSysMenus, arg.Limit, arg.Offset)
+func (q *Queries) ListAllMenus(ctx context.Context) ([]ListAllMenusRow, error) {
+	rows, err := q.db.Query(ctx, listAllMenus)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	items := []ListSysMenusRow{}
+	items := []ListAllMenusRow{}
 	for rows.Next() {
-		var i ListSysMenusRow
+		var i ListAllMenusRow
 		if err := rows.Scan(
 			&i.ID,
 			&i.Name,
@@ -260,7 +196,71 @@ func (q *Queries) ListSysMenus(ctx context.Context, arg ListSysMenusParams) ([]L
 	return items, nil
 }

-const updateSysMenu = `-- name: UpdateSysMenu :execrows
+const listMenus = `-- name: ListMenus :many
+SELECT m.id, m.name, m.path, m.component, m.type, m.hidden, m.sort, m.status, m.parent_id, m.icon, m.created_at, m.updated_at, p.code AS permission_code
+FROM sys_menus m
+         LEFT JOIN sys_menu_permission mp ON m.id = mp.menu_id
+         LEFT JOIN sys_permissions p ON mp.permission_id = p.id
+ORDER BY m.id
+LIMIT $1 OFFSET $2
+`
+
+type ListMenusParams struct {
+	Limit  int32 `json:"limit"`
+	Offset int32 `json:"offset"`
+}
+
+type ListMenusRow struct {
+	ID             int32      `json:"id"`
+	Name           string     `json:"name"`
+	Path           *string    `json:"path"`
+	Component      *string    `json:"component"`
+	Type           int16      `json:"type"`
+	Hidden         *bool      `json:"hidden"`
+	Sort           *int32     `json:"sort"`
+	Status         int16      `json:"status"`
+	ParentID       *int32     `json:"parent_id"`
+	Icon           *int32     `json:"icon"`
+	CreatedAt      time.Time  `json:"created_at"`
+	UpdatedAt      *time.Time `json:"updated_at"`
+	PermissionCode *string    `json:"permission_code"`
+}
+
+func (q *Queries) ListMenus(ctx context.Context, arg ListMenusParams) ([]ListMenusRow, error) {
+	rows, err := q.db.Query(ctx, listMenus, arg.Limit, arg.Offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListMenusRow{}
+	for rows.Next() {
+		var i ListMenusRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.Name,
+			&i.Path,
+			&i.Component,
+			&i.Type,
+			&i.Hidden,
+			&i.Sort,
+			&i.Status,
+			&i.ParentID,
+			&i.Icon,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+			&i.PermissionCode,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const updateMenu = `-- name: UpdateMenu :execrows
 UPDATE sys_menus
 SET name      = coalesce($1, name),
    path      = coalesce($2, path),
@@ -274,7 +274,7 @@ SET name      = coalesce($1, name),
 WHERE id = $12
 `

-type UpdateSysMenuParams struct {
+type UpdateMenuParams struct {
 	Name           *string `json:"name"`
 	Path           *string `json:"path"`
 	Component      *string `json:"component"`
@@ -289,8 +289,8 @@ type UpdateSysMenuParams struct {
 	ID             int32   `json:"id"`
 }

-func (q *Queries) UpdateSysMenu(ctx context.Context, arg UpdateSysMenuParams) (int64, error) {
-	result, err := q.db.Exec(ctx, updateSysMenu,
+func (q *Queries) UpdateMenu(ctx context.Context, arg UpdateMenuParams) (int64, error) {
+	result, err := q.db.Exec(ctx, updateMenu,
 		arg.Name,
 		arg.Path,
 		arg.Component,
@@ -310,7 +310,7 @@ func (q *Queries) UpdateSysMenu(ctx context.Context, arg UpdateSysMenuParams) (i
 	return result.RowsAffected(), nil
 }

-const updateSysMenuPermissionCode = `-- name: UpdateSysMenuPermissionCode :exec
+const updateMenuPermissionCode = `-- name: UpdateMenuPermissionCode :exec
 UPDATE sys_permissions p
 SET code = coalesce($2, code)
 FROM sys_menu_permission mp
@@ -318,12 +318,12 @@ WHERE p.id = mp.permission_id
  AND mp.menu_id = $1
 `

-type UpdateSysMenuPermissionCodeParams struct {
+type UpdateMenuPermissionCodeParams struct {
 	MenuID int32   `json:"menu_id"`
 	Code   *string `json:"code"`
 }

-func (q *Queries) UpdateSysMenuPermissionCode(ctx context.Context, arg UpdateSysMenuPermissionCodeParams) error {
-	_, err := q.db.Exec(ctx, updateSysMenuPermissionCode, arg.MenuID, arg.Code)
+func (q *Queries) UpdateMenuPermissionCode(ctx context.Context, arg UpdateMenuPermissionCodeParams) error {
+	_, err := q.db.Exec(ctx, updateMenuPermissionCode, arg.MenuID, arg.Code)
 	return err
 }
--- a/internal/db/sqlc/sys_permissions.sql.go
+++ b/internal/db/sqlc/sys_permissions.sql.go
@@ -9,72 +9,72 @@ import (
 	"context"
 )

-const createSysPermission = `-- name: CreateSysPermission :one
+const createPermission = `-- name: CreatePermission :one
 INSERT INTO sys_permissions(type,code)
 VALUES ($1,$2) RETURNING id
 `

-type CreateSysPermissionParams struct {
+type CreatePermissionParams struct {
 	Type int16   `json:"type"`
 	Code *string `json:"code"`
 }

-func (q *Queries) CreateSysPermission(ctx context.Context, arg CreateSysPermissionParams) (int32, error) {
-	row := q.db.QueryRow(ctx, createSysPermission, arg.Type, arg.Code)
+func (q *Queries) CreatePermission(ctx context.Context, arg CreatePermissionParams) (int32, error) {
+	row := q.db.QueryRow(ctx, createPermission, arg.Type, arg.Code)
 	var id int32
 	err := row.Scan(&id)
 	return id, err
 }

-const deleteSysPermission = `-- name: DeleteSysPermission :exec
+const deletePermission = `-- name: DeletePermission :exec
 DELETE
 FROM sys_permissions
 WHERE id = $1
 `

-func (q *Queries) DeleteSysPermission(ctx context.Context, id int32) error {
-	_, err := q.db.Exec(ctx, deleteSysPermission, id)
+func (q *Queries) DeletePermission(ctx context.Context, id int32) error {
+	_, err := q.db.Exec(ctx, deletePermission, id)
 	return err
 }

-const getSysPermissionIDBySysApiID = `-- name: GetSysPermissionIDBySysApiID :one
+const getPermissionIDBySysApiID = `-- name: GetPermissionIDBySysApiID :one
 SELECT permission_id
 FROM sys_api_permission
 WHERE api_id = $1
 `

-func (q *Queries) GetSysPermissionIDBySysApiID(ctx context.Context, apiID int32) (int32, error) {
-	row := q.db.QueryRow(ctx, getSysPermissionIDBySysApiID, apiID)
+func (q *Queries) GetPermissionIDBySysApiID(ctx context.Context, apiID int32) (int32, error) {
+	row := q.db.QueryRow(ctx, getPermissionIDBySysApiID, apiID)
 	var permission_id int32
 	err := row.Scan(&permission_id)
 	return permission_id, err
 }

-const getSysPermissionIDBySysMenuID = `-- name: GetSysPermissionIDBySysMenuID :one
+const getPermissionIDBySysMenuID = `-- name: GetPermissionIDBySysMenuID :one
 SELECT permission_id
 FROM sys_menu_permission
 WHERE menu_id = $1
 `

-func (q *Queries) GetSysPermissionIDBySysMenuID(ctx context.Context, menuID int32) (int32, error) {
-	row := q.db.QueryRow(ctx, getSysPermissionIDBySysMenuID, menuID)
+func (q *Queries) GetPermissionIDBySysMenuID(ctx context.Context, menuID int32) (int32, error) {
+	row := q.db.QueryRow(ctx, getPermissionIDBySysMenuID, menuID)
 	var permission_id int32
 	err := row.Scan(&permission_id)
 	return permission_id, err
 }

-const updateSysPermission = `-- name: UpdateSysPermission :exec
+const updatePermission = `-- name: UpdatePermission :exec
 UPDATE sys_permissions
 SET code = $2
 WHERE id = $1
 `

-type UpdateSysPermissionParams struct {
+type UpdatePermissionParams struct {
 	ID   int32   `json:"id"`
 	Code *string `json:"code"`
 }

-func (q *Queries) UpdateSysPermission(ctx context.Context, arg UpdateSysPermissionParams) error {
-	_, err := q.db.Exec(ctx, updateSysPermission, arg.ID, arg.Code)
+func (q *Queries) UpdatePermission(ctx context.Context, arg UpdatePermissionParams) error {
+	_, err := q.db.Exec(ctx, updatePermission, arg.ID, arg.Code)
 	return err
 }
--- a/internal/db/sqlc/sys_roles.sql.go
+++ b/internal/db/sqlc/sys_roles.sql.go
@@ -9,76 +9,76 @@ import (
 	"context"
 )

-const countSysRoles = `-- name: CountSysRoles :one
+const countRoles = `-- name: CountRoles :one
 SELECT COUNT(*)
 FROM sys_roles
 `

-func (q *Queries) CountSysRoles(ctx context.Context) (int64, error) {
-	row := q.db.QueryRow(ctx, countSysRoles)
+func (q *Queries) CountRoles(ctx context.Context) (int64, error) {
+	row := q.db.QueryRow(ctx, countRoles)
 	var count int64
 	err := row.Scan(&count)
 	return count, err
 }

-const createSysRole = `-- name: CreateSysRole :exec
+const createRole = `-- name: CreateRole :exec
 INSERT INTO sys_roles (name, code, status)
 VALUES ($1, $2, $3)
 `

-type CreateSysRoleParams struct {
+type CreateRoleParams struct {
 	Name   string `json:"name"`
 	Code   string `json:"code"`
 	Status int16  `json:"status"`
 }

-func (q *Queries) CreateSysRole(ctx context.Context, arg CreateSysRoleParams) error {
-	_, err := q.db.Exec(ctx, createSysRole, arg.Name, arg.Code, arg.Status)
+func (q *Queries) CreateRole(ctx context.Context, arg CreateRoleParams) error {
+	_, err := q.db.Exec(ctx, createRole, arg.Name, arg.Code, arg.Status)
 	return err
 }

-type CreateSysRolePermissionParams struct {
+type CreateRolePermissionParams struct {
 	RoleID       int32 `json:"role_id"`
 	PermissionID int32 `json:"permission_id"`
 }

-const deleteSysRole = `-- name: DeleteSysRole :execrows
+const deleteRole = `-- name: DeleteRole :execrows
 DELETE
 FROM sys_roles
 WHERE id = $1
 `

-func (q *Queries) DeleteSysRole(ctx context.Context, id int32) (int64, error) {
-	result, err := q.db.Exec(ctx, deleteSysRole, id)
+func (q *Queries) DeleteRole(ctx context.Context, id int32) (int64, error) {
+	result, err := q.db.Exec(ctx, deleteRole, id)
 	if err != nil {
 		return 0, err
 	}
 	return result.RowsAffected(), nil
 }

-const deleteSysRolePermissionByPermissionID = `-- name: DeleteSysRolePermissionByPermissionID :exec
+const deleteRolePermissionByPermissionID = `-- name: DeleteRolePermissionByPermissionID :exec
 DELETE
 FROM sys_role_permission
 WHERE permission_id = $1
 `

-func (q *Queries) DeleteSysRolePermissionByPermissionID(ctx context.Context, permissionID int32) error {
-	_, err := q.db.Exec(ctx, deleteSysRolePermissionByPermissionID, permissionID)
+func (q *Queries) DeleteRolePermissionByPermissionID(ctx context.Context, permissionID int32) error {
+	_, err := q.db.Exec(ctx, deleteRolePermissionByPermissionID, permissionID)
 	return err
 }

-const deleteSysRolePermissionByRoleID = `-- name: DeleteSysRolePermissionByRoleID :exec
+const deleteRolePermissionsByRoleID = `-- name: DeleteRolePermissionsByRoleID :exec
 DELETE
 FROM sys_role_permission
 WHERE role_id = $1
 `

-func (q *Queries) DeleteSysRolePermissionByRoleID(ctx context.Context, roleID int32) error {
-	_, err := q.db.Exec(ctx, deleteSysRolePermissionByRoleID, roleID)
+func (q *Queries) DeleteRolePermissionsByRoleID(ctx context.Context, roleID int32) error {
+	_, err := q.db.Exec(ctx, deleteRolePermissionsByRoleID, roleID)
 	return err
 }

-const deleteSysRolePermissionByType = `-- name: DeleteSysRolePermissionByType :exec
+const deleteRolePermissionsByType = `-- name: DeleteRolePermissionsByType :exec
 DELETE
 FROM sys_role_permission rp USING sys_permissions p
 WHERE rp.permission_id = p.id
@@ -86,28 +86,28 @@ WHERE rp.permission_id = p.id
  AND p."type" = $2
 `

-type DeleteSysRolePermissionByTypeParams struct {
+type DeleteRolePermissionsByTypeParams struct {
 	RoleID int32 `json:"role_id"`
 	Type   int16 `json:"type"`
 }

-func (q *Queries) DeleteSysRolePermissionByType(ctx context.Context, arg DeleteSysRolePermissionByTypeParams) error {
-	_, err := q.db.Exec(ctx, deleteSysRolePermissionByType, arg.RoleID, arg.Type)
+func (q *Queries) DeleteRolePermissionsByType(ctx context.Context, arg DeleteRolePermissionsByTypeParams) error {
+	_, err := q.db.Exec(ctx, deleteRolePermissionsByType, arg.RoleID, arg.Type)
 	return err
 }

-const deleteSysUserRoleByRoleID = `-- name: DeleteSysUserRoleByRoleID :exec
+const deleteUserRoleByRoleID = `-- name: DeleteUserRoleByRoleID :exec
 DELETE
 FROM sys_user_role
 WHERE role_id = $1
 `

-func (q *Queries) DeleteSysUserRoleByRoleID(ctx context.Context, roleID int32) error {
-	_, err := q.db.Exec(ctx, deleteSysUserRoleByRoleID, roleID)
+func (q *Queries) DeleteUserRoleByRoleID(ctx context.Context, roleID int32) error {
+	_, err := q.db.Exec(ctx, deleteUserRoleByRoleID, roleID)
 	return err
 }

-const existsSysRoleCode = `-- name: ExistsSysRoleCode :one
+const existsRoleCode = `-- name: ExistsRoleCode :one
 SELECT EXISTS(SELECT 1
              FROM sys_roles
              WHERE code = $1
@@ -117,143 +117,26 @@ SELECT EXISTS(SELECT 1
                  ))
 `

-type ExistsSysRoleCodeParams struct {
+type ExistsRoleCodeParams struct {
 	Code string `json:"code"`
 	ID   *int32 `json:"id"`
 }

-func (q *Queries) ExistsSysRoleCode(ctx context.Context, arg ExistsSysRoleCodeParams) (bool, error) {
-	row := q.db.QueryRow(ctx, existsSysRoleCode, arg.Code, arg.ID)
+func (q *Queries) ExistsRoleCode(ctx context.Context, arg ExistsRoleCodeParams) (bool, error) {
+	row := q.db.QueryRow(ctx, existsRoleCode, arg.Code, arg.ID)
 	var exists bool
 	err := row.Scan(&exists)
 	return exists, err
 }

-const getAllSysRoles = `-- name: GetAllSysRoles :many
-SELECT id, name, code, status, created_at, updated_at
-from sys_roles
-`
-
-func (q *Queries) GetAllSysRoles(ctx context.Context) ([]SysRole, error) {
-	rows, err := q.db.Query(ctx, getAllSysRoles)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []SysRole{}
-	for rows.Next() {
-		var i SysRole
-		if err := rows.Scan(
-			&i.ID,
-			&i.Name,
-			&i.Code,
-			&i.Status,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getSysPermissionIdsByApiIDs = `-- name: GetSysPermissionIdsByApiIDs :many
-SELECT permission_id
-FROM sys_api_permission
-WHERE api_id = ANY ($1::int[])
-`
-
-func (q *Queries) GetSysPermissionIdsByApiIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
-	rows, err := q.db.Query(ctx, getSysPermissionIdsByApiIDs, dollar_1)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []int32{}
-	for rows.Next() {
-		var permission_id int32
-		if err := rows.Scan(&permission_id); err != nil {
-			return nil, err
-		}
-		items = append(items, permission_id)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getSysPermissionIdsByMenuIDs = `-- name: GetSysPermissionIdsByMenuIDs :many
-SELECT permission_id
-FROM sys_menu_permission
-WHERE menu_id = ANY ($1::int[])
-`
-
-func (q *Queries) GetSysPermissionIdsByMenuIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
-	rows, err := q.db.Query(ctx, getSysPermissionIdsByMenuIDs, dollar_1)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []int32{}
-	for rows.Next() {
-		var permission_id int32
-		if err := rows.Scan(&permission_id); err != nil {
-			return nil, err
-		}
-		items = append(items, permission_id)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getSysRoleApis = `-- name: GetSysRoleApis :many
-SELECT a.id, a."name"
-FROM sys_role_permission rp
-         JOIN sys_api_permission ap ON ap.permission_id = rp.permission_id
-         JOIN sys_apis a ON a.id = ap.api_id
-WHERE rp.role_id = $1
-`
-
-type GetSysRoleApisRow struct {
-	ID   int32  `json:"id"`
-	Name string `json:"name"`
-}
-
-func (q *Queries) GetSysRoleApis(ctx context.Context, roleID int32) ([]GetSysRoleApisRow, error) {
-	rows, err := q.db.Query(ctx, getSysRoleApis, roleID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []GetSysRoleApisRow{}
-	for rows.Next() {
-		var i GetSysRoleApisRow
-		if err := rows.Scan(&i.ID, &i.Name); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const getSysRoleByID = `-- name: GetSysRoleByID :one
+const getRoleByID = `-- name: GetRoleByID :one
 SELECT id, name, code, status, created_at, updated_at
 FROM sys_roles
 WHERE id = $1
 `

-func (q *Queries) GetSysRoleByID(ctx context.Context, id int32) (SysRole, error) {
-	row := q.db.QueryRow(ctx, getSysRoleByID, id)
+func (q *Queries) GetRoleByID(ctx context.Context, id int32) (SysRole, error) {
+	row := q.db.QueryRow(ctx, getRoleByID, id)
 	var i SysRole
 	err := row.Scan(
 		&i.ID,
@@ -266,53 +149,13 @@ func (q *Queries) GetSysRoleByID(ctx context.Context, id int32) (SysRole, error)
 	return i, err
 }

-const getSysRoleMenus = `-- name: GetSysRoleMenus :many
-SELECT m.id, m.name
-FROM sys_role_permission rp
-         JOIN sys_menu_permission mp ON mp.permission_id = rp.permission_id
-         JOIN sys_menus m ON m.id = mp.menu_id
-WHERE rp.role_id = $1
-`
-
-type GetSysRoleMenusRow struct {
-	ID   int32  `json:"id"`
-	Name string `json:"name"`
-}
-
-func (q *Queries) GetSysRoleMenus(ctx context.Context, roleID int32) ([]GetSysRoleMenusRow, error) {
-	rows, err := q.db.Query(ctx, getSysRoleMenus, roleID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []GetSysRoleMenusRow{}
-	for rows.Next() {
-		var i GetSysRoleMenusRow
-		if err := rows.Scan(&i.ID, &i.Name); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const listSysRoles = `-- name: ListSysRoles :many
+const listAllRoles = `-- name: ListAllRoles :many
 SELECT id, name, code, status, created_at, updated_at
-FROM sys_roles
-ORDER BY id
-LIMIT $1 OFFSET $2
+from sys_roles
 `

-type ListSysRolesParams struct {
-	Limit  int32 `json:"limit"`
-	Offset int32 `json:"offset"`
-}
-
-func (q *Queries) ListSysRoles(ctx context.Context, arg ListSysRolesParams) ([]SysRole, error) {
-	rows, err := q.db.Query(ctx, listSysRoles, arg.Limit, arg.Offset)
+func (q *Queries) ListAllRoles(ctx context.Context) ([]SysRole, error) {
+	rows, err := q.db.Query(ctx, listAllRoles)
 	if err != nil {
 		return nil, err
 	}
@@ -338,21 +181,178 @@ func (q *Queries) ListSysRoles(ctx context.Context, arg ListSysRolesParams) ([]S
 	return items, nil
 }

-const updateSysRole = `-- name: UpdateSysRole :execrows
+const listPermissionIDsByApiIDs = `-- name: ListPermissionIDsByApiIDs :many
+SELECT permission_id
+FROM sys_api_permission
+WHERE api_id = ANY ($1::int[])
+`
+
+func (q *Queries) ListPermissionIDsByApiIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
+	rows, err := q.db.Query(ctx, listPermissionIDsByApiIDs, dollar_1)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []int32{}
+	for rows.Next() {
+		var permission_id int32
+		if err := rows.Scan(&permission_id); err != nil {
+			return nil, err
+		}
+		items = append(items, permission_id)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listPermissionIDsByMenuIDs = `-- name: ListPermissionIDsByMenuIDs :many
+SELECT permission_id
+FROM sys_menu_permission
+WHERE menu_id = ANY ($1::int[])
+`
+
+func (q *Queries) ListPermissionIDsByMenuIDs(ctx context.Context, dollar_1 []int32) ([]int32, error) {
+	rows, err := q.db.Query(ctx, listPermissionIDsByMenuIDs, dollar_1)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []int32{}
+	for rows.Next() {
+		var permission_id int32
+		if err := rows.Scan(&permission_id); err != nil {
+			return nil, err
+		}
+		items = append(items, permission_id)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listRoleApis = `-- name: ListRoleApis :many
+SELECT a.id, a."name"
+FROM sys_role_permission rp
+         JOIN sys_api_permission ap ON ap.permission_id = rp.permission_id
+         JOIN sys_apis a ON a.id = ap.api_id
+WHERE rp.role_id = $1
+`
+
+type ListRoleApisRow struct {
+	ID   int32  `json:"id"`
+	Name string `json:"name"`
+}
+
+func (q *Queries) ListRoleApis(ctx context.Context, roleID int32) ([]ListRoleApisRow, error) {
+	rows, err := q.db.Query(ctx, listRoleApis, roleID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListRoleApisRow{}
+	for rows.Next() {
+		var i ListRoleApisRow
+		if err := rows.Scan(&i.ID, &i.Name); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listRoleMenus = `-- name: ListRoleMenus :many
+SELECT m.id, m.name
+FROM sys_role_permission rp
+         JOIN sys_menu_permission mp ON mp.permission_id = rp.permission_id
+         JOIN sys_menus m ON m.id = mp.menu_id
+WHERE rp.role_id = $1
+`
+
+type ListRoleMenusRow struct {
+	ID   int32  `json:"id"`
+	Name string `json:"name"`
+}
+
+func (q *Queries) ListRoleMenus(ctx context.Context, roleID int32) ([]ListRoleMenusRow, error) {
+	rows, err := q.db.Query(ctx, listRoleMenus, roleID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListRoleMenusRow{}
+	for rows.Next() {
+		var i ListRoleMenusRow
+		if err := rows.Scan(&i.ID, &i.Name); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listRoles = `-- name: ListRoles :many
+SELECT id, name, code, status, created_at, updated_at
+FROM sys_roles
+ORDER BY id
+LIMIT $1 OFFSET $2
+`
+
+type ListRolesParams struct {
+	Limit  int32 `json:"limit"`
+	Offset int32 `json:"offset"`
+}
+
+func (q *Queries) ListRoles(ctx context.Context, arg ListRolesParams) ([]SysRole, error) {
+	rows, err := q.db.Query(ctx, listRoles, arg.Limit, arg.Offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []SysRole{}
+	for rows.Next() {
+		var i SysRole
+		if err := rows.Scan(
+			&i.ID,
+			&i.Name,
+			&i.Code,
+			&i.Status,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const updateRole = `-- name: UpdateRole :execrows
 UPDATE sys_roles
 SET name   = coalesce($1, name),
    status = coalesce($2, status)
 WHERE id = $3
 `

-type UpdateSysRoleParams struct {
+type UpdateRoleParams struct {
 	Name   *string `json:"name"`
 	Status *int16  `json:"status"`
 	ID     int32   `json:"id"`
 }

-func (q *Queries) UpdateSysRole(ctx context.Context, arg UpdateSysRoleParams) (int64, error) {
-	result, err := q.db.Exec(ctx, updateSysRole, arg.Name, arg.Status, arg.ID)
+func (q *Queries) UpdateRole(ctx context.Context, arg UpdateRoleParams) (int64, error) {
+	result, err := q.db.Exec(ctx, updateRole, arg.Name, arg.Status, arg.ID)
 	if err != nil {
 		return 0, err
 	}
--- a/internal/db/sqlc/sys_users.sql.go
+++ b/internal/db/sqlc/sys_users.sql.go
@@ -10,36 +10,36 @@ import (
 	"time"
 )

-const clearSysUserRoles = `-- name: ClearSysUserRoles :exec
+const clearUserRoles = `-- name: ClearUserRoles :exec
 DELETE
 FROM sys_user_role
 WHERE user_id = $1
 `

-func (q *Queries) ClearSysUserRoles(ctx context.Context, userID int32) error {
-	_, err := q.db.Exec(ctx, clearSysUserRoles, userID)
+func (q *Queries) ClearUserRoles(ctx context.Context, userID int32) error {
+	_, err := q.db.Exec(ctx, clearUserRoles, userID)
 	return err
 }

-const countSysUsers = `-- name: CountSysUsers :one
+const countUsers = `-- name: CountUsers :one
 SELECT COUNT(*)
 FROM sys_users
 WHERE ($1::text = '' OR username ILIKE '%' || $1 || '%')
 `

-func (q *Queries) CountSysUsers(ctx context.Context, username string) (int64, error) {
-	row := q.db.QueryRow(ctx, countSysUsers, username)
+func (q *Queries) CountUsers(ctx context.Context, username string) (int64, error) {
+	row := q.db.QueryRow(ctx, countUsers, username)
 	var count int64
 	err := row.Scan(&count)
 	return count, err
 }

-const createSysUser = `-- name: CreateSysUser :exec
+const createUser = `-- name: CreateUser :exec
 INSERT INTO sys_users (account, username, password_hash, status, avatar_id)
 VALUES ($1, $2, $3, $4, $5)
 `

-type CreateSysUserParams struct {
+type CreateUserParams struct {
 	Account      string `json:"account"`
 	Username     string `json:"username"`
 	PasswordHash string `json:"password_hash"`
@@ -47,8 +47,8 @@ type CreateSysUserParams struct {
 	AvatarID     *int32 `json:"avatar_id"`
 }

-func (q *Queries) CreateSysUser(ctx context.Context, arg CreateSysUserParams) error {
-	_, err := q.db.Exec(ctx, createSysUser,
+func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) error {
+	_, err := q.db.Exec(ctx, createUser,
 		arg.Account,
 		arg.Username,
 		arg.PasswordHash,
@@ -58,34 +58,34 @@ func (q *Queries) CreateSysUser(ctx context.Context, arg CreateSysUserParams) er
 	return err
 }

-type CreateSysUserRoleParams struct {
+type CreateUserRoleParams struct {
 	UserID int32 `json:"user_id"`
 	RoleID int32 `json:"role_id"`
 }

-const deleteSysUser = `-- name: DeleteSysUser :execrows
+const deleteUser = `-- name: DeleteUser :execrows
 DELETE
 FROM sys_users
 WHERE id = $1
  AND id <> 1
 `

-func (q *Queries) DeleteSysUser(ctx context.Context, id int32) (int64, error) {
-	result, err := q.db.Exec(ctx, deleteSysUser, id)
+func (q *Queries) DeleteUser(ctx context.Context, id int32) (int64, error) {
+	result, err := q.db.Exec(ctx, deleteUser, id)
 	if err != nil {
 		return 0, err
 	}
 	return result.RowsAffected(), nil
 }

-const getActiveSysUserByID = `-- name: GetActiveSysUserByID :one
+const getActiveUserByID = `-- name: GetActiveUserByID :one
 SELECT id, account, username, status
 FROM sys_users
 WHERE id = $1
  AND status = 1
 `

-type GetActiveSysUserByIDRow struct {
+type GetActiveUserByIDRow struct {
 	ID       int32  `json:"id"`
 	Account  string `json:"account"`
 	Username string `json:"username"`
@@ -93,9 +93,9 @@ type GetActiveSysUserByIDRow struct {
 }

 // 场景：用户登录、获取个人信息、刷新 Token（严格校验 status = 1）
-func (q *Queries) GetActiveSysUserByID(ctx context.Context, id int32) (GetActiveSysUserByIDRow, error) {
-	row := q.db.QueryRow(ctx, getActiveSysUserByID, id)
-	var i GetActiveSysUserByIDRow
+func (q *Queries) GetActiveUserByID(ctx context.Context, id int32) (GetActiveUserByIDRow, error) {
+	row := q.db.QueryRow(ctx, getActiveUserByID, id)
+	var i GetActiveUserByIDRow
 	err := row.Scan(
 		&i.ID,
 		&i.Account,
@@ -105,7 +105,92 @@ func (q *Queries) GetActiveSysUserByID(ctx context.Context, id int32) (GetActive
 	return i, err
 }

-const getSysAdminMenus = `-- name: GetSysAdminMenus :many
+const getUserByAccount = `-- name: GetUserByAccount :one
+SELECT u.id,
+       u.account,
+       u.username,
+       u.password_hash,
+       u.status,
+       u.avatar_id,
+       f.file_url AS avatar_url,
+       u.created_at,
+       u.updated_at
+FROM sys_users u
+         LEFT JOIN files f ON u.avatar_id = f.id
+WHERE u.account = $1
+`
+
+type GetUserByAccountRow struct {
+	ID           int32      `json:"id"`
+	Account      string     `json:"account"`
+	Username     string     `json:"username"`
+	PasswordHash string     `json:"password_hash"`
+	Status       int16      `json:"status"`
+	AvatarID     *int32     `json:"avatar_id"`
+	AvatarUrl    *string    `json:"avatar_url"`
+	CreatedAt    time.Time  `json:"created_at"`
+	UpdatedAt    *time.Time `json:"updated_at"`
+}
+
+func (q *Queries) GetUserByAccount(ctx context.Context, account string) (GetUserByAccountRow, error) {
+	row := q.db.QueryRow(ctx, getUserByAccount, account)
+	var i GetUserByAccountRow
+	err := row.Scan(
+		&i.ID,
+		&i.Account,
+		&i.Username,
+		&i.PasswordHash,
+		&i.Status,
+		&i.AvatarID,
+		&i.AvatarUrl,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const getUserByID = `-- name: GetUserByID :one
+SELECT u.id,
+       u.account,
+       u.username,
+       u.avatar_id,
+       u.status,
+       f.file_url AS avatar_url,
+       u.created_at,
+       u.updated_at
+FROM sys_users u
+         LEFT JOIN files f ON u.avatar_id = f.id
+WHERE u.id = $1
+`
+
+type GetUserByIDRow struct {
+	ID        int32      `json:"id"`
+	Account   string     `json:"account"`
+	Username  string     `json:"username"`
+	AvatarID  *int32     `json:"avatar_id"`
+	Status    int16      `json:"status"`
+	AvatarUrl *string    `json:"avatar_url"`
+	CreatedAt time.Time  `json:"created_at"`
+	UpdatedAt *time.Time `json:"updated_at"`
+}
+
+func (q *Queries) GetUserByID(ctx context.Context, id int32) (GetUserByIDRow, error) {
+	row := q.db.QueryRow(ctx, getUserByID, id)
+	var i GetUserByIDRow
+	err := row.Scan(
+		&i.ID,
+		&i.Account,
+		&i.Username,
+		&i.AvatarID,
+		&i.Status,
+		&i.AvatarUrl,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const listAdminMenus = `-- name: ListAdminMenus :many
 SELECT id, name, path, component, type, hidden, sort, status, parent_id, icon, created_at, updated_at
 FROM sys_menus
 WHERE status = 1
@@ -113,8 +198,8 @@ WHERE status = 1
 ORDER BY sort, id
 `

-func (q *Queries) GetSysAdminMenus(ctx context.Context) ([]SysMenu, error) {
-	rows, err := q.db.Query(ctx, getSysAdminMenus)
+func (q *Queries) ListAdminMenus(ctx context.Context) ([]SysMenu, error) {
+	rows, err := q.db.Query(ctx, listAdminMenus)
 	if err != nil {
 		return nil, err
 	}
@@ -146,14 +231,14 @@ func (q *Queries) GetSysAdminMenus(ctx context.Context) ([]SysMenu, error) {
 	return items, nil
 }

-const getSysAdminPermissions = `-- name: GetSysAdminPermissions :many
+const listAdminPermissionCodes = `-- name: ListAdminPermissionCodes :many
 SELECT code
 FROM sys_permissions
 WHERE type = 0
 `

-func (q *Queries) GetSysAdminPermissions(ctx context.Context) ([]*string, error) {
-	rows, err := q.db.Query(ctx, getSysAdminPermissions)
+func (q *Queries) ListAdminPermissionCodes(ctx context.Context) ([]*string, error) {
+	rows, err := q.db.Query(ctx, listAdminPermissionCodes)
 	if err != nil {
 		return nil, err
 	}
@@ -172,7 +257,7 @@ func (q *Queries) GetSysAdminPermissions(ctx context.Context) ([]*string, error)
 	return items, nil
 }

-const getSysUserApis = `-- name: GetSysUserApis :many
+const listUserApis = `-- name: ListUserApis :many
 SELECT DISTINCT a.id,
                a.PATH,
                a.METHOD
@@ -187,21 +272,21 @@ WHERE u.id = $1
  AND r.status = 1
 `

-type GetSysUserApisRow struct {
+type ListUserApisRow struct {
 	ID     int32  `json:"id"`
 	Path   string `json:"path"`
 	Method string `json:"method"`
 }

-func (q *Queries) GetSysUserApis(ctx context.Context, id int32) ([]GetSysUserApisRow, error) {
-	rows, err := q.db.Query(ctx, getSysUserApis, id)
+func (q *Queries) ListUserApis(ctx context.Context, id int32) ([]ListUserApisRow, error) {
+	rows, err := q.db.Query(ctx, listUserApis, id)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	items := []GetSysUserApisRow{}
+	items := []ListUserApisRow{}
 	for rows.Next() {
-		var i GetSysUserApisRow
+		var i ListUserApisRow
 		if err := rows.Scan(&i.ID, &i.Path, &i.Method); err != nil {
 			return nil, err
 		}
@@ -213,92 +298,7 @@ func (q *Queries) GetSysUserApis(ctx context.Context, id int32) ([]GetSysUserApi
 	return items, nil
 }

-const getSysUserByAccount = `-- name: GetSysUserByAccount :one
-SELECT u.id,
-       u.account,
-       u.username,
-       u.password_hash,
-       u.status,
-       u.avatar_id,
-       f.file_path AS avatar_url,
-       u.created_at,
-       u.updated_at
-FROM sys_users u
-         LEFT JOIN files f ON u.avatar_id = f.id
-WHERE u.account = $1
-`
-
-type GetSysUserByAccountRow struct {
-	ID           int32      `json:"id"`
-	Account      string     `json:"account"`
-	Username     string     `json:"username"`
-	PasswordHash string     `json:"password_hash"`
-	Status       int16      `json:"status"`
-	AvatarID     *int32     `json:"avatar_id"`
-	AvatarUrl    *string    `json:"avatar_url"`
-	CreatedAt    time.Time  `json:"created_at"`
-	UpdatedAt    *time.Time `json:"updated_at"`
-}
-
-func (q *Queries) GetSysUserByAccount(ctx context.Context, account string) (GetSysUserByAccountRow, error) {
-	row := q.db.QueryRow(ctx, getSysUserByAccount, account)
-	var i GetSysUserByAccountRow
-	err := row.Scan(
-		&i.ID,
-		&i.Account,
-		&i.Username,
-		&i.PasswordHash,
-		&i.Status,
-		&i.AvatarID,
-		&i.AvatarUrl,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getSysUserByID = `-- name: GetSysUserByID :one
-SELECT u.id,
-       u.account,
-       u.username,
-       u.avatar_id,
-       u.status,
-       f.file_path AS avatar_url,
-       u.created_at,
-       u.updated_at
-FROM sys_users u
-         LEFT JOIN files f ON u.avatar_id = f.id
-WHERE u.id = $1
-`
-
-type GetSysUserByIDRow struct {
-	ID        int32      `json:"id"`
-	Account   string     `json:"account"`
-	Username  string     `json:"username"`
-	AvatarID  *int32     `json:"avatar_id"`
-	Status    int16      `json:"status"`
-	AvatarUrl *string    `json:"avatar_url"`
-	CreatedAt time.Time  `json:"created_at"`
-	UpdatedAt *time.Time `json:"updated_at"`
-}
-
-func (q *Queries) GetSysUserByID(ctx context.Context, id int32) (GetSysUserByIDRow, error) {
-	row := q.db.QueryRow(ctx, getSysUserByID, id)
-	var i GetSysUserByIDRow
-	err := row.Scan(
-		&i.ID,
-		&i.Account,
-		&i.Username,
-		&i.AvatarID,
-		&i.Status,
-		&i.AvatarUrl,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getSysUserMenus = `-- name: GetSysUserMenus :many
+const listUserMenus = `-- name: ListUserMenus :many
 SELECT DISTINCT m.id, m.name, m.path, m.component, m.type, m.hidden, m.sort, m.status, m.parent_id, m.icon, m.created_at, m.updated_at
 FROM sys_users u
         JOIN sys_user_role ur ON ur.user_id = u.id
@@ -314,8 +314,8 @@ WHERE u.id = $1
 ORDER BY m.sort, m.id
 `

-func (q *Queries) GetSysUserMenus(ctx context.Context, id int32) ([]SysMenu, error) {
-	rows, err := q.db.Query(ctx, getSysUserMenus, id)
+func (q *Queries) ListUserMenus(ctx context.Context, id int32) ([]SysMenu, error) {
+	rows, err := q.db.Query(ctx, listUserMenus, id)
 	if err != nil {
 		return nil, err
 	}
@@ -347,7 +347,7 @@ func (q *Queries) GetSysUserMenus(ctx context.Context, id int32) ([]SysMenu, err
 	return items, nil
 }

-const getSysUserPermissions = `-- name: GetSysUserPermissions :many
+const listUserPermissionCodes = `-- name: ListUserPermissionCodes :many
 SELECT DISTINCT p.code
 FROM sys_users u
         JOIN sys_user_role ur ON u.id = ur.user_id
@@ -363,8 +363,8 @@ WHERE u.id = $1
  AND p."type" = 0
 `

-func (q *Queries) GetSysUserPermissions(ctx context.Context, id int32) ([]*string, error) {
-	rows, err := q.db.Query(ctx, getSysUserPermissions, id)
+func (q *Queries) ListUserPermissionCodes(ctx context.Context, id int32) ([]*string, error) {
+	rows, err := q.db.Query(ctx, listUserPermissionCodes, id)
 	if err != nil {
 		return nil, err
 	}
@@ -383,15 +383,15 @@ func (q *Queries) GetSysUserPermissions(ctx context.Context, id int32) ([]*strin
 	return items, nil
 }

-const getSysUserRoles = `-- name: GetSysUserRoles :many
+const listUserRoles = `-- name: ListUserRoles :many
 SELECT r.id, r.name, r.code, r.status, r.created_at, r.updated_at
 FROM sys_roles r
         JOIN sys_user_role ur ON r.id = ur.role_id
 WHERE ur.user_id = $1
 `

-func (q *Queries) GetSysUserRoles(ctx context.Context, userID int32) ([]SysRole, error) {
-	rows, err := q.db.Query(ctx, getSysUserRoles, userID)
+func (q *Queries) ListUserRoles(ctx context.Context, userID int32) ([]SysRole, error) {
+	rows, err := q.db.Query(ctx, listUserRoles, userID)
 	if err != nil {
 		return nil, err
 	}
@@ -417,13 +417,13 @@ func (q *Queries) GetSysUserRoles(ctx context.Context, userID int32) ([]SysRole,
 	return items, nil
 }

-const listSysUsers = `-- name: ListSysUsers :many
+const listUsers = `-- name: ListUsers :many
 SELECT u.id,
       u.account,
       u.username,
       u.status,
       u.avatar_id,
-       f.file_path AS avatar_url,
+       f.file_url AS avatar_url,
       u.created_at,
       u.updated_at
 FROM sys_users u
@@ -433,13 +433,13 @@ ORDER BY u.id
 LIMIT $1 OFFSET $2
 `

-type ListSysUsersParams struct {
+type ListUsersParams struct {
 	Limit    int32  `json:"limit"`
 	Offset   int32  `json:"offset"`
 	Username string `json:"username"`
 }

-type ListSysUsersRow struct {
+type ListUsersRow struct {
 	ID        int32      `json:"id"`
 	Account   string     `json:"account"`
 	Username  string     `json:"username"`
@@ -450,15 +450,15 @@ type ListSysUsersRow struct {
 	UpdatedAt *time.Time `json:"updated_at"`
 }

-func (q *Queries) ListSysUsers(ctx context.Context, arg ListSysUsersParams) ([]ListSysUsersRow, error) {
-	rows, err := q.db.Query(ctx, listSysUsers, arg.Limit, arg.Offset, arg.Username)
+func (q *Queries) ListUsers(ctx context.Context, arg ListUsersParams) ([]ListUsersRow, error) {
+	rows, err := q.db.Query(ctx, listUsers, arg.Limit, arg.Offset, arg.Username)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	items := []ListSysUsersRow{}
+	items := []ListUsersRow{}
 	for rows.Next() {
-		var i ListSysUsersRow
+		var i ListUsersRow
 		if err := rows.Scan(
 			&i.ID,
 			&i.Account,
@@ -479,7 +479,7 @@ func (q *Queries) ListSysUsers(ctx context.Context, arg ListSysUsersParams) ([]L
 	return items, nil
 }

-const updateSysUser = `-- name: UpdateSysUser :execrows
+const updateUser = `-- name: UpdateUser :execrows
 UPDATE sys_users
 SET username  = coalesce($1, username),
    status    = coalesce($2, status),
@@ -487,7 +487,7 @@ SET username  = coalesce($1, username),
 WHERE id = $5
 `

-type UpdateSysUserParams struct {
+type UpdateUserParams struct {
 	Username       *string `json:"username"`
 	Status         *int16  `json:"status"`
 	UpdateAvatarID bool    `json:"update_avatar_id"`
@@ -495,8 +495,8 @@ type UpdateSysUserParams struct {
 	ID             int32   `json:"id"`
 }

-func (q *Queries) UpdateSysUser(ctx context.Context, arg UpdateSysUserParams) (int64, error) {
-	result, err := q.db.Exec(ctx, updateSysUser,
+func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) (int64, error) {
+	result, err := q.db.Exec(ctx, updateUser,
 		arg.Username,
 		arg.Status,
 		arg.UpdateAvatarID,
@@ -509,19 +509,19 @@ func (q *Queries) UpdateSysUser(ctx context.Context, arg UpdateSysUserParams) (i
 	return result.RowsAffected(), nil
 }

-const updateSysUserPassword = `-- name: UpdateSysUserPassword :execrows
+const updateUserPassword = `-- name: UpdateUserPassword :execrows
 UPDATE sys_users
 SET password_hash = $2
 WHERE id = $1
 `

-type UpdateSysUserPasswordParams struct {
+type UpdateUserPasswordParams struct {
 	ID           int32  `json:"id"`
 	PasswordHash string `json:"password_hash"`
 }

-func (q *Queries) UpdateSysUserPassword(ctx context.Context, arg UpdateSysUserPasswordParams) (int64, error) {
-	result, err := q.db.Exec(ctx, updateSysUserPassword, arg.ID, arg.PasswordHash)
+func (q *Queries) UpdateUserPassword(ctx context.Context, arg UpdateUserPasswordParams) (int64, error) {
+	result, err := q.db.Exec(ctx, updateUserPassword, arg.ID, arg.PasswordHash)
 	if err != nil {
 		return 0, err
 	}
				`@@ -0,0 +1 @@`
				`ALTER TABLE files DROP COLUMN IF EXISTS file_url;`