Revert "feat(gateway): 实现负载感知的账号调度优化 (#114)"

This reverts commit 8d252303fc.

.gitattributes

@@ -1,15 +0,0 @@
-# 确保所有 SQL 迁移文件使用 LF 换行符
-backend/migrations/*.sql text eol=lf
-
-# Go 源代码文件
-*.go text eol=lf
-
-# Shell 脚本
-*.sh text eol=lf
-
-# YAML/YML 配置文件
-*.yaml text eol=lf
-*.yml text eol=lf
-
-# Dockerfile
-Dockerfile text eol=lf

.github/audit-exceptions.yml

@@ -1,16 +0,0 @@
-version: 1
-exceptions:
-  - package: xlsx
-    advisory: "GHSA-4r6h-8v6p-xvw6"
-    severity: high
-    reason: "Admin export only; switched to dynamic import to reduce exposure (CVE-2023-30533)"
-    mitigation: "Load only on export; restrict export permissions and data scope"
-    expires_on: "2026-04-05"
-    owner: "security@your-domain"
-  - package: xlsx
-    advisory: "GHSA-5pgg-2g8v-p4x9"
-    severity: high
-    reason: "Admin export only; switched to dynamic import to reduce exposure (CVE-2024-22363)"
-    mitigation: "Load only on export; restrict export permissions and data scope"
-    expires_on: "2026-04-05"
-    owner: "security@your-domain"

.github/workflows/backend-ci.yml

@@ -11,15 +11,12 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-go@v6
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
           go-version-file: backend/go.mod
-          check-latest: false
+          check-latest: true
           cache: true
-      - name: Verify Go version
-        run: |
-          go version | grep -q 'go1.26.1'
       - name: Unit tests
         working-directory: backend
         run: make test-unit
@@ -30,18 +27,15 @@ jobs:
   golangci-lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-go@v6
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
           go-version-file: backend/go.mod
-          check-latest: false
+          check-latest: true
           cache: true
-      - name: Verify Go version
-        run: |
-          go version | grep -q 'go1.26.1'
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v9
         with:
-          version: v2.9
-          args: --timeout=30m
-          working-directory: backend
+          version: v2.7
+          args: --timeout=5m
+          working-directory: backend

.github/workflows/release.yml

@@ -4,22 +4,6 @@ on:
   push:
     tags:
       - 'v*'
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Tag to release (e.g., v1.0.0)'
-        required: true
-        type: string
-      simple_release:
-        description: 'Simple release: only x86_64 GHCR image, skip other artifacts'
-        required: false
-        type: boolean
-        default: false
-
-# 环境变量：合并 workflow_dispatch 输入和 repository variable
-# tag push 触发时读取 vars.SIMPLE_RELEASE，workflow_dispatch 时使用输入参数
-env:
-  SIMPLE_RELEASE: ${{ github.event.inputs.simple_release == 'true' || vars.SIMPLE_RELEASE == 'true' }}
 
 permissions:
   contents: write
@@ -31,21 +15,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Update VERSION file
         run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            VERSION=${{ github.event.inputs.tag }}
-            VERSION=${VERSION#v}
-          else
-            VERSION=${GITHUB_REF#refs/tags/v}
-          fi
+          VERSION=${GITHUB_REF#refs/tags/v}
           echo "$VERSION" > backend/cmd/server/VERSION
           echo "Updated VERSION file to: $VERSION"
 
       - name: Upload VERSION artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: version-file
           path: backend/cmd/server/VERSION
@@ -55,30 +34,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
+        uses: actions/checkout@v4
 
       - name: Setup Node.js
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@v4
         with:
           node-version: '20'
-          cache: 'pnpm'
-          cache-dependency-path: frontend/pnpm-lock.yaml
+          cache: 'npm'
+          cache-dependency-path: frontend/package-lock.json
 
       - name: Install dependencies
-        run: pnpm install --frozen-lockfile
+        run: npm ci
         working-directory: frontend
 
       - name: Build frontend
-        run: pnpm run build
+        run: npm run build
         working-directory: frontend
 
       - name: Upload frontend artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: frontend-dist
           path: backend/internal/web/dist/
@@ -89,34 +63,28 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          ref: ${{ github.event.inputs.tag || github.ref }}
 
       - name: Download VERSION artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: version-file
           path: backend/cmd/server/
 
       - name: Download frontend artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: frontend-dist
           path: backend/internal/web/dist/
 
       - name: Setup Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version-file: backend/go.mod
-          check-latest: false
+          go-version: '1.24'
           cache-dependency-path: backend/go.sum
 
-      - name: Verify Go version
-        run: |
-          go version | grep -q 'go1.26.1'
-
       # Docker setup for GoReleaser
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
@@ -125,10 +93,7 @@ jobs:
         uses: docker/setup-buildx-action@v3
 
       - name: Login to DockerHub
-        if: ${{ env.DOCKERHUB_USERNAME != '' }}
         uses: docker/login-action@v3
-        env:
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
@@ -148,11 +113,7 @@ jobs:
       - name: Get tag message
         id: tag_message
         run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            TAG_NAME=${{ github.event.inputs.tag }}
-          else
-            TAG_NAME=${GITHUB_REF#refs/tags/}
-          fi
+          TAG_NAME=${GITHUB_REF#refs/tags/}
           echo "Processing tag: $TAG_NAME"
 
           # 获取完整的 tag message（跳过第一行标题）
@@ -173,24 +134,21 @@ jobs:
         run: echo "owner=$(echo '${{ github.repository_owner }}' | tr '[:upper:]' '[:lower:]')" >> $GITHUB_OUTPUT
 
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v7
+        uses: goreleaser/goreleaser-action@v6
         with:
           version: '~> v2'
-          args: release --clean --skip=validate ${{ env.SIMPLE_RELEASE == 'true' && '--config=.goreleaser.simple.yaml' || '' }}
+          args: release --clean --skip=validate
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TAG_MESSAGE: ${{ steps.tag_message.outputs.message }}
           GITHUB_REPO_OWNER: ${{ github.repository_owner }}
           GITHUB_REPO_OWNER_LOWER: ${{ steps.lowercase.outputs.owner }}
           GITHUB_REPO_NAME: ${{ github.event.repository.name }}
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME || 'skip' }}
+          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
 
       # Update DockerHub description
       - name: Update DockerHub description
-        if: ${{ env.SIMPLE_RELEASE != 'true' && env.DOCKERHUB_USERNAME != '' }}
-        uses: peter-evans/dockerhub-description@v5
-        env:
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+        uses: peter-evans/dockerhub-description@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
@@ -200,11 +158,9 @@ jobs:
 
       # Send Telegram notification
       - name: Send Telegram Notification
-        if: ${{ env.SIMPLE_RELEASE != 'true' }}
         env:
           TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
           TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
         continue-on-error: true
         run: |
           # 检查必要的环境变量
@@ -213,18 +169,14 @@ jobs:
             exit 0
           fi
 
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            TAG_NAME=${{ github.event.inputs.tag }}
-          else
-            TAG_NAME=${GITHUB_REF#refs/tags/}
-          fi
+          TAG_NAME=${GITHUB_REF#refs/tags/}
           VERSION=${TAG_NAME#v}
           REPO="${{ github.repository }}"
+          DOCKER_IMAGE="${{ secrets.DOCKERHUB_USERNAME }}/sub2api"
           GHCR_IMAGE="ghcr.io/${REPO,,}"  # ${,,} converts to lowercase
 
-          # 获取 tag message 内容并转义 Markdown 特殊字符
+          # 获取 tag message 内容
           TAG_MESSAGE='${{ steps.tag_message.outputs.message }}'
-          TAG_MESSAGE=$(echo "$TAG_MESSAGE" | sed 's/\([_*`\[]\)/\\\1/g')
 
           # 限制消息长度（Telegram 消息限制 4096 字符，预留空间给头尾固定内容）
           if [ ${#TAG_MESSAGE} -gt 3500 ]; then
@@ -242,20 +194,14 @@ jobs:
 
           MESSAGE+="🐳 *Docker 部署:*"$'\n'
           MESSAGE+="\`\`\`bash"$'\n'
-          # 根据是否配置 DockerHub 动态生成
-          if [ -n "$DOCKERHUB_USERNAME" ]; then
-            DOCKER_IMAGE="${DOCKERHUB_USERNAME}/sub2api"
-            MESSAGE+="# Docker Hub"$'\n'
-            MESSAGE+="docker pull ${DOCKER_IMAGE}:${TAG_NAME}"$'\n'
-            MESSAGE+="# GitHub Container Registry"$'\n'
-          fi
+          MESSAGE+="# Docker Hub"$'\n'
+          MESSAGE+="docker pull ${DOCKER_IMAGE}:${TAG_NAME}"$'\n'
+          MESSAGE+="# GitHub Container Registry"$'\n'
           MESSAGE+="docker pull ${GHCR_IMAGE}:${TAG_NAME}"$'\n'
           MESSAGE+="\`\`\`"$'\n'$'\n'
           MESSAGE+="🔗 *相关链接:*"$'\n'
           MESSAGE+="• [GitHub Release](https://github.com/${REPO}/releases/tag/${TAG_NAME})"$'\n'
-          if [ -n "$DOCKERHUB_USERNAME" ]; then
-            MESSAGE+="• [Docker Hub](https://hub.docker.com/r/${DOCKER_IMAGE})"$'\n'
-          fi
+          MESSAGE+="• [Docker Hub](https://hub.docker.com/r/${DOCKER_IMAGE})"$'\n'
           MESSAGE+="• [GitHub Packages](https://github.com/${REPO}/pkgs/container/sub2api)"$'\n'$'\n'
           MESSAGE+="#Sub2API #Release #${TAG_NAME//./_}"
 

.github/workflows/security-scan.yml

@@ -1,58 +0,0 @@
-name: Security Scan
-
-on:
-  push:
-  pull_request:
-  schedule:
-    - cron: '0 3 * * 1'
-
-permissions:
-  contents: read
-
-jobs:
-  backend-security:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v6
-      - name: Set up Go
-        uses: actions/setup-go@v6
-        with:
-          go-version-file: backend/go.mod
-          check-latest: false
-          cache-dependency-path: backend/go.sum
-      - name: Verify Go version
-        run: |
-          go version | grep -q 'go1.26.1'
-      - name: Run govulncheck
-        working-directory: backend
-        run: |
-          go install golang.org/x/vuln/cmd/govulncheck@latest
-          govulncheck ./...
-
-  frontend-security:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Set up pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-      - name: Set up Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: '20'
-          cache: 'pnpm'
-          cache-dependency-path: frontend/pnpm-lock.yaml
-      - name: Install dependencies
-        working-directory: frontend
-        run: pnpm install --frozen-lockfile
-      - name: Run pnpm audit
-        working-directory: frontend
-        run: |
-          pnpm audit --prod --audit-level=high --json > audit.json || true
-      - name: Check audit exceptions
-        run: |
-          python tools/check_pnpm_audit_exceptions.py \
-            --audit frontend/audit.json \
-            --exceptions .github/audit-exceptions.yml

.gitignore

@@ -14,9 +14,6 @@ backend/server
 backend/sub2api
 backend/main
 
-# Go 测试二进制
-*.test
-
 # 测试覆盖率
 *.out
 coverage.html
@@ -36,7 +33,6 @@ frontend/dist/
 *.local
 *.tsbuildinfo
 vite.config.d.ts
-vite.config.js.timestamp-*
 
 # 日志
 npm-debug.log*
@@ -52,7 +48,6 @@ pnpm-debug.log*
 .env.*.local
 *.env
 !.env.example
-docker-compose.override.yml
 
 # ===================
 # IDE / 编辑器
@@ -82,9 +77,6 @@ temp/
 *.temp
 *.log
 *.bak
-.cache/
-.dev/
-.serena/
 
 # ===================
 # 构建产物
@@ -116,20 +108,12 @@ backend/.installed
 # ===================
 tests
 CLAUDE.md
+AGENTS.md
 .claude
 scripts
 .code-review-state
-#openspec/
+openspec/
+docs/
 code-reviews/
-#AGENTS.md
+AGENTS.md
 backend/cmd/server/server
-deploy/docker-compose.override.yml
-.gocache/
-vite.config.js
-docs/*
-.serena/
-.codex/
-frontend/coverage/
-aicodex
-output/
-

.goreleaser.simple.yaml

@@ -1,86 +0,0 @@
-# 简化版 GoReleaser 配置 - 仅发布 x86_64 GHCR 镜像
-version: 2
-
-project_name: sub2api
-
-before:
-  hooks:
-    - go mod tidy -C backend
-
-builds:
-  - id: sub2api
-    dir: backend
-    main: ./cmd/server
-    binary: sub2api
-    flags:
-      - -tags=embed
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-    goarch:
-      - amd64
-    ldflags:
-      - -s -w
-      - -X main.Commit={{.Commit}}
-      - -X main.Date={{.Date}}
-      - -X main.BuildType=release
-
-# 跳过 archives
-archives: []
-
-# 跳过 checksum
-checksum:
-  disable: true
-
-changelog:
-  disable: true
-
-# 仅 GHCR x86_64 镜像
-dockers:
-  - id: ghcr-amd64
-    goos: linux
-    goarch: amd64
-    image_templates:
-      - "ghcr.io/{{ .Env.GITHUB_REPO_OWNER_LOWER }}/sub2api:{{ .Version }}-amd64"
-      - "ghcr.io/{{ .Env.GITHUB_REPO_OWNER_LOWER }}/sub2api:{{ .Version }}"
-      - "ghcr.io/{{ .Env.GITHUB_REPO_OWNER_LOWER }}/sub2api:latest"
-    dockerfile: Dockerfile.goreleaser
-    use: buildx
-    build_flag_templates:
-      - "--platform=linux/amd64"
-      - "--label=org.opencontainers.image.version={{ .Version }}"
-      - "--label=org.opencontainers.image.revision={{ .Commit }}"
-      - "--label=org.opencontainers.image.source=https://github.com/{{ .Env.GITHUB_REPO_OWNER }}/{{ .Env.GITHUB_REPO_NAME }}"
-
-# 跳过 manifests（单架构不需要）
-docker_manifests: []
-
-release:
-  github:
-    owner: "{{ .Env.GITHUB_REPO_OWNER }}"
-    name: "{{ .Env.GITHUB_REPO_NAME }}"
-  draft: false
-  prerelease: auto
-  name_template: "Sub2API {{.Version}} (Simple)"
-  # 跳过上传二进制包
-  skip_upload: true
-  header: |
-    > AI API Gateway Platform - 将 AI 订阅配额分发和管理
-    > ⚡ Simple Release: 仅包含 x86_64 GHCR 镜像
-
-    {{ .Env.TAG_MESSAGE }}
-
-  footer: |
-    ---
-
-    ## 📥 Installation
-
-    **Docker (x86_64 only):**
-    ```bash
-    docker pull ghcr.io/{{ .Env.GITHUB_REPO_OWNER_LOWER }}/sub2api:{{ .Version }}
-    ```
-
-    ## 📚 Documentation
-
-    - [GitHub Repository](https://github.com/{{ .Env.GITHUB_REPO_OWNER }}/{{ .Env.GITHUB_REPO_NAME }})

.goreleaser.yaml

@@ -54,11 +54,9 @@ changelog:
 
 # Docker images
 dockers:
-  # DockerHub images (skipped if DOCKERHUB_USERNAME is 'skip')
   - id: amd64
     goos: linux
     goarch: amd64
-    skip_push: '{{ if eq .Env.DOCKERHUB_USERNAME "skip" }}true{{ else }}false{{ end }}'
     image_templates:
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-amd64"
     dockerfile: Dockerfile.goreleaser
@@ -71,7 +69,6 @@ dockers:
   - id: arm64
     goos: linux
     goarch: arm64
-    skip_push: '{{ if eq .Env.DOCKERHUB_USERNAME "skip" }}true{{ else }}false{{ end }}'
     image_templates:
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-arm64"
     dockerfile: Dockerfile.goreleaser
@@ -110,27 +107,22 @@ dockers:
 
 # Docker manifests for multi-arch support
 docker_manifests:
-  # DockerHub manifests (skipped if DOCKERHUB_USERNAME is 'skip')
   - name_template: "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}"
-    skip_push: '{{ if eq .Env.DOCKERHUB_USERNAME "skip" }}true{{ else }}false{{ end }}'
     image_templates:
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-amd64"
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-arm64"
 
   - name_template: "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:latest"
-    skip_push: '{{ if eq .Env.DOCKERHUB_USERNAME "skip" }}true{{ else }}false{{ end }}'
     image_templates:
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-amd64"
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-arm64"
 
   - name_template: "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Major }}.{{ .Minor }}"
-    skip_push: '{{ if eq .Env.DOCKERHUB_USERNAME "skip" }}true{{ else }}false{{ end }}'
     image_templates:
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-amd64"
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-arm64"
 
   - name_template: "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Major }}"
-    skip_push: '{{ if eq .Env.DOCKERHUB_USERNAME "skip" }}true{{ else }}false{{ end }}'
     image_templates:
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-amd64"
       - "{{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}-arm64"
@@ -177,11 +169,9 @@ release:
 
     **Docker:**
     ```bash
-    {{ if ne .Env.DOCKERHUB_USERNAME "skip" -}}
     # Docker Hub
     docker pull {{ .Env.DOCKERHUB_USERNAME }}/sub2api:{{ .Version }}
 
-    {{ end -}}
     # GitHub Container Registry
     docker pull ghcr.io/{{ .Env.GITHUB_REPO_OWNER_LOWER }}/sub2api:{{ .Version }}
     ```

DEV_GUIDE.md

@@ -1,346 +0,0 @@
-# sub2api 项目开发指南
-
-> 本文档记录项目环境配置、常见坑点和注意事项，供 Claude Code 和团队成员参考。
-
-## 一、项目基本信息
-
-| 项目 | 说明 |
-|------|------|
-| **上游仓库** | Wei-Shaw/sub2api |
-| **Fork 仓库** | bayma888/sub2api-bmai |
-| **技术栈** | Go 后端 (Ent ORM + Gin) + Vue3 前端 (pnpm) |
-| **数据库** | PostgreSQL 16 + Redis |
-| **包管理** | 后端: go modules, 前端: **pnpm**（不是 npm） |
-
-## 二、本地环境配置
-
-### PostgreSQL 16 (Windows 服务)
-
-| 配置项 | 值 |
-|--------|-----|
-| 端口 | 5432 |
-| psql 路径 | `C:\Program Files\PostgreSQL\16\bin\psql.exe` |
-| pg_hba.conf | `C:\Program Files\PostgreSQL\16\data\pg_hba.conf` |
-| 数据库凭据 | user=`sub2api`, password=`sub2api`, dbname=`sub2api` |
-| 超级用户 | user=`postgres`, password=`postgres` |
-
-### Redis
-
-| 配置项 | 值 |
-|--------|-----|
-| 端口 | 6379 |
-| 密码 | 无 |
-
-### 开发工具
-
-```bash
-# golangci-lint v2.7
-go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.7
-
-# pnpm (前端包管理)
-npm install -g pnpm
-```
-
-## 三、CI/CD 流水线
-
-### GitHub Actions Workflows
-
-| Workflow | 触发条件 | 检查内容 |
-|----------|----------|----------|
-| **backend-ci.yml** | push, pull_request | 单元测试 + 集成测试 + golangci-lint v2.7 |
-| **security-scan.yml** | push, pull_request, 每周一 | govulncheck + gosec + pnpm audit |
-| **release.yml** | tag `v*` | 构建发布（PR 不触发） |
-
-### CI 要求
-
-- Go 版本必须是 **1.25.7**
-- 前端使用 `pnpm install --frozen-lockfile`，必须提交 `pnpm-lock.yaml`
-
-### 本地测试命令
-
-```bash
-# 后端单元测试
-cd backend && go test -tags=unit ./...
-
-# 后端集成测试
-cd backend && go test -tags=integration ./...
-
-# 代码质量检查
-cd backend && golangci-lint run ./...
-
-# 前端依赖安装（必须用 pnpm）
-cd frontend && pnpm install
-```
-
-## 四、常见坑点 & 解决方案
-
-### 坑 1：pnpm-lock.yaml 必须同步提交
-
-**问题**：`package.json` 新增依赖后，CI 的 `pnpm install --frozen-lockfile` 失败。
-
-**原因**：上游 CI 使用 pnpm，lock 文件不同步会报错。
-
-**解决**：
-```bash
-cd frontend
-pnpm install  # 更新 pnpm-lock.yaml
-git add pnpm-lock.yaml
-git commit -m "chore: update pnpm-lock.yaml"
-```
-
----
-
-### 坑 2：npm 和 pnpm 的 node_modules 冲突
-
-**问题**：之前用 npm 装过 `node_modules`，pnpm install 报 `EPERM` 错误。
-
-**解决**：
-```bash
-cd frontend
-rm -rf node_modules  # 或 PowerShell: Remove-Item -Recurse -Force node_modules
-pnpm install
-```
-
----
-
-### 坑 3：PowerShell 中 bcrypt hash 的 `$` 被转义
-
-**问题**：bcrypt hash 格式如 `$2a$10$xxx...`，PowerShell 把 `$2a` 当变量解析，导致数据丢失。
-
-**解决**：将 SQL 写入文件，用 `psql -f` 执行：
-```bash
-# 错误示范（PowerShell 会吃掉 $）
-psql -c "INSERT INTO users ... VALUES ('$2a$10$...')"
-
-# 正确做法
-echo "INSERT INTO users ... VALUES ('\$2a\$10\$...')" > temp.sql
-psql -U sub2api -h 127.0.0.1 -d sub2api -f temp.sql
-```
-
----
-
-### 坑 4：psql 不支持中文路径
-
-**问题**：`psql -f "D:\中文路径\file.sql"` 报错找不到文件。
-
-**解决**：复制到纯英文路径再执行：
-```bash
-cp "D:\中文路径\file.sql" "C:\temp.sql"
-psql -f "C:\temp.sql"
-```
-
----
-
-### 坑 5：PostgreSQL 密码重置流程
-
-**场景**：忘记 PostgreSQL 密码。
-
-**步骤**：
-1. 修改 `C:\Program Files\PostgreSQL\16\data\pg_hba.conf`
-   ```
-   # 将 scram-sha-256 改为 trust
-   host    all    all    127.0.0.1/32    trust
-   ```
-2. 重启 PostgreSQL 服务
-   ```powershell
-   Restart-Service postgresql-x64-16
-   ```
-3. 无密码登录并重置
-   ```bash
-   psql -U postgres -h 127.0.0.1
-   ALTER USER sub2api WITH PASSWORD 'sub2api';
-   ALTER USER postgres WITH PASSWORD 'postgres';
-   ```
-4. 改回 `scram-sha-256` 并重启
-
----
-
-### 坑 6：Go interface 新增方法后 test stub 必须补全
-
-**问题**：给 interface 新增方法后，编译报错 `does not implement interface (missing method XXX)`。
-
-**原因**：所有测试文件中实现该 interface 的 stub/mock 都必须补上新方法。
-
-**解决**：
-```bash
-# 搜索所有实现该 interface 的 struct
-cd backend
-grep -r "type.*Stub.*struct" internal/
-grep -r "type.*Mock.*struct" internal/
-
-# 逐一补全新方法
-```
-
----
-
-### 坑 7：Windows 上 psql 连 localhost 的 IPv6 问题
-
-**问题**：psql 连 `localhost` 先尝试 IPv6 (::1)，可能报错后再回退 IPv4。
-
-**建议**：直接用 `127.0.0.1` 代替 `localhost`。
-
----
-
-### 坑 8：Windows 没有 make 命令
-
-**问题**：CI 里用 `make test-unit`，本地 Windows 没有 make。
-
-**解决**：直接用 Makefile 里的原始命令：
-```bash
-# 代替 make test-unit
-go test -tags=unit ./...
-
-# 代替 make test-integration
-go test -tags=integration ./...
-```
-
----
-
-### 坑 9：Ent Schema 修改后必须重新生成
-
-**问题**：修改 `ent/schema/*.go` 后，代码不生效。
-
-**解决**：
-```bash
-cd backend
-go generate ./ent  # 重新生成 ent 代码
-git add ent/       # 生成的文件也要提交
-```
-
----
-
-### 坑 10：前端测试看似正常，但后端调用失败（模型映射被批量误改）
-
-**典型现象**：
-- 前端按钮点测看起来正常；
-- 实际通过 API/客户端调用时返回 `Service temporarily unavailable` 或提示无可用账号；
-- 常见于 OpenAI 账号（例如 Codex 模型）在批量修改后突然不可用。
-
-**根因**：
-- OpenAI 账号编辑页默认不显式展示映射规则，容易让人误以为“没映射也没关系”；
-- 但在**批量修改同时选中不同平台账号**（OpenAI + Antigravity/Gemini）时，模型白名单/映射可能被跨平台策略覆盖；
-- 结果是 OpenAI 账号的关键模型映射丢失或被改坏，后端选不到可用账号。
-
-**修复方案（按优先级）**：
-1. **快速修复（推荐）**：在批量修改中补回正确的透传映射（例如 `gpt-5.3-codex -> gpt-5.3-codex-spark`）。
-2. **彻底重建**：删除并重新添加全部相关账号（最稳但成本高）。
-
-**关键经验**：
-- 如果某模型已被软件内置默认映射覆盖，通常不需要额外再加透传；
-- 但当上游模型更新快于本仓库默认映射时，**手动批量添加透传映射**是最简单、最低风险的临时兜底方案；
-- 批量操作前尽量按平台分组，不要混选不同平台账号。
-
----
-
-### 坑 11：PR 提交前检查清单
-
-提交 PR 前务必本地验证：
-
-- [ ] `go test -tags=unit ./...` 通过
-- [ ] `go test -tags=integration ./...` 通过
-- [ ] `golangci-lint run ./...` 无新增问题
-- [ ] `pnpm-lock.yaml` 已同步（如果改了 package.json）
-- [ ] 所有 test stub 补全新接口方法（如果改了 interface）
-- [ ] Ent 生成的代码已提交（如果改了 schema）
-
-## 五、常用命令速查
-
-### 数据库操作
-
-```bash
-# 连接数据库
-psql -U sub2api -h 127.0.0.1 -d sub2api
-
-# 查看所有用户
-psql -U postgres -h 127.0.0.1 -c "\du"
-
-# 查看所有数据库
-psql -U postgres -h 127.0.0.1 -c "\l"
-
-# 执行 SQL 文件
-psql -U sub2api -h 127.0.0.1 -d sub2api -f migration.sql
-```
-
-### Git 操作
-
-```bash
-# 同步上游
-git fetch upstream
-git checkout main
-git merge upstream/main
-git push origin main
-
-# 创建功能分支
-git checkout -b feature/xxx
-
-# Rebase 到最新 main
-git fetch upstream
-git rebase upstream/main
-```
-
-### 前端操作
-
-```bash
-# 安装依赖（必须用 pnpm）
-cd frontend
-pnpm install
-
-# 开发服务器
-pnpm dev
-
-# 构建
-pnpm build
-```
-
-### 后端操作
-
-```bash
-# 运行服务器
-cd backend
-go run ./cmd/server/
-
-# 生成 Ent 代码
-go generate ./ent
-
-# 运行测试
-go test -tags=unit ./...
-go test -tags=integration ./...
-
-# Lint 检查
-golangci-lint run ./...
-```
-
-## 六、项目结构速览
-
-```
-sub2api-bmai/
-├── backend/
-│   ├── cmd/server/          # 主程序入口
-│   ├── ent/                 # Ent ORM 生成代码
-│   │   └── schema/          # 数据库 Schema 定义
-│   ├── internal/
-│   │   ├── handler/         # HTTP 处理器
-│   │   ├── service/         # 业务逻辑
-│   │   ├── repository/      # 数据访问层
-│   │   └── server/          # 服务器配置
-│   ├── migrations/          # 数据库迁移脚本
-│   └── config.yaml          # 配置文件
-├── frontend/
-│   ├── src/
-│   │   ├── api/             # API 调用
-│   │   ├── components/      # Vue 组件
-│   │   ├── views/           # 页面视图
-│   │   ├── types/           # TypeScript 类型
-│   │   └── i18n/            # 国际化
-│   ├── package.json         # 依赖配置
-│   └── pnpm-lock.yaml       # pnpm 锁文件（必须提交）
-└── .claude/
-    └── CLAUDE.md            # 本文档
-```
-
-## 七、参考资源
-
-- [上游仓库](https://github.com/Wei-Shaw/sub2api)
-- [Ent 文档](https://entgo.io/docs/getting-started)
-- [Vue3 文档](https://vuejs.org/)
-- [pnpm 文档](https://pnpm.io/)

Dockerfile

@@ -7,8 +7,8 @@
 # =============================================================================
 
 ARG NODE_IMAGE=node:24-alpine
-ARG GOLANG_IMAGE=golang:1.26.1-alpine
-ARG ALPINE_IMAGE=alpine:3.21
+ARG GOLANG_IMAGE=golang:1.25-alpine
+ARG ALPINE_IMAGE=alpine:3.19
 ARG GOPROXY=https://goproxy.cn,direct
 ARG GOSUMDB=sum.golang.google.cn
 
@@ -19,16 +19,13 @@ FROM ${NODE_IMAGE} AS frontend-builder
 
 WORKDIR /app/frontend
 
-# Install pnpm
-RUN corepack enable && corepack prepare pnpm@latest --activate
-
 # Install dependencies first (better caching)
-COPY frontend/package.json frontend/pnpm-lock.yaml ./
-RUN pnpm install --frozen-lockfile
+COPY frontend/package*.json ./
+RUN npm ci
 
 # Copy frontend source and build
 COPY frontend/ ./
-RUN pnpm run build
+RUN npm run build
 
 # -----------------------------------------------------------------------------
 # Stage 2: Backend Builder
@@ -36,7 +33,7 @@ RUN pnpm run build
 FROM ${GOLANG_IMAGE} AS backend-builder
 
 # Build arguments for version info (set by CI)
-ARG VERSION=
+ARG VERSION=docker
 ARG COMMIT=docker
 ARG DATE
 ARG GOPROXY
@@ -61,14 +58,9 @@ COPY backend/ ./
 COPY --from=frontend-builder /app/backend/internal/web/dist ./internal/web/dist
 
 # Build the binary (BuildType=release for CI builds, embed frontend)
-# Version precedence: build arg VERSION > cmd/server/VERSION
-RUN VERSION_VALUE="${VERSION}" && \
-    if [ -z "${VERSION_VALUE}" ]; then VERSION_VALUE="$(tr -d '\r\n' < ./cmd/server/VERSION)"; fi && \
-    DATE_VALUE="${DATE:-$(date -u +%Y-%m-%dT%H:%M:%SZ)}" && \
-    CGO_ENABLED=0 GOOS=linux go build \
+RUN CGO_ENABLED=0 GOOS=linux go build \
     -tags embed \
-    -ldflags="-s -w -X main.Version=${VERSION_VALUE} -X main.Commit=${COMMIT} -X main.Date=${DATE_VALUE} -X main.BuildType=release" \
-    -trimpath \
+    -ldflags="-s -w -X main.Commit=${COMMIT} -X main.Date=${DATE:-$(date -u +%Y-%m-%dT%H:%M:%SZ)} -X main.BuildType=release" \
     -o /app/sub2api \
     ./cmd/server
 
@@ -86,6 +78,7 @@ LABEL org.opencontainers.image.source="https://github.com/Wei-Shaw/sub2api"
 RUN apk add --no-cache \
     ca-certificates \
     tzdata \
+    curl \
     && rm -rf /var/cache/apk/*
 
 # Create non-root user
@@ -95,12 +88,11 @@ RUN addgroup -g 1000 sub2api && \
 # Set working directory
 WORKDIR /app
 
-# Copy binary/resources with ownership to avoid extra full-layer chown copy
-COPY --from=backend-builder --chown=sub2api:sub2api /app/sub2api /app/sub2api
-COPY --from=backend-builder --chown=sub2api:sub2api /app/backend/resources /app/resources
+# Copy binary from builder
+COPY --from=backend-builder /app/sub2api /app/sub2api
 
 # Create data directory
-RUN mkdir -p /app/data && chown sub2api:sub2api /app/data
+RUN mkdir -p /app/data && chown -R sub2api:sub2api /app
 
 # Switch to non-root user
 USER sub2api
@@ -110,7 +102,7 @@ EXPOSE 8080
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
-    CMD wget -q -T 5 -O /dev/null http://localhost:${SERVER_PORT:-8080}/health || exit 1
+    CMD curl -f http://localhost:${SERVER_PORT:-8080}/health || exit 1
 
 # Run the application
 ENTRYPOINT ["/app/sub2api"]

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build build-backend build-frontend build-datamanagementd test test-backend test-frontend test-datamanagementd secret-scan
+.PHONY: build build-backend build-frontend
 
 # 一键编译前后端
 build: build-backend build-frontend
@@ -9,24 +9,4 @@ build-backend:
 
 # 编译前端（需要已安装依赖）
 build-frontend:
-	@pnpm --dir frontend run build
-
-# 编译 datamanagementd（宿主机数据管理进程）
-build-datamanagementd:
-	@cd datamanagement && go build -o datamanagementd ./cmd/datamanagementd
-
-# 运行测试（后端 + 前端）
-test: test-backend test-frontend
-
-test-backend:
-	@$(MAKE) -C backend test
-
-test-frontend:
-	@pnpm --dir frontend run lint:check
-	@pnpm --dir frontend run typecheck
-
-test-datamanagementd:
-	@cd datamanagement && go test ./...
-
-secret-scan:
-	@python3 tools/secret_scan.py
+	@npm --prefix frontend run build

README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Go](https://img.shields.io/badge/Go-1.25.7-00ADD8.svg)](https://golang.org/)
+[![Go](https://img.shields.io/badge/Go-1.21+-00ADD8.svg)](https://golang.org/)
 [![Vue](https://img.shields.io/badge/Vue-3.4+-4FC08D.svg)](https://vuejs.org/)
 [![PostgreSQL](https://img.shields.io/badge/PostgreSQL-15+-336791.svg)](https://www.postgresql.org/)
 [![Redis](https://img.shields.io/badge/Redis-7+-DC382D.svg)](https://redis.io/)
@@ -18,7 +18,7 @@ English | [中文](README_CN.md)
 
 ## Demo
 
-Try Sub2API online: **https://demo.sub2api.org/**
+Try Sub2API online: **https://v2.pincc.ai/**
 
 Demo credentials (shared demo environment; **not** created automatically for self-hosted installs):
 
@@ -44,20 +44,13 @@ Sub2API is an AI API gateway platform designed to distribute and manage API quot
 
 | Component | Technology |
 |-----------|------------|
-| Backend | Go 1.25.7, Gin, Ent |
+| Backend | Go 1.21+, Gin, GORM |
 | Frontend | Vue 3.4+, Vite 5+, TailwindCSS |
 | Database | PostgreSQL 15+ |
 | Cache/Queue | Redis 7+ |
 
 ---
 
-## Documentation
-
-- Dependency Security: `docs/dependency-security.md`
-- Admin Payment Integration API: `docs/ADMIN_PAYMENT_INTEGRATION_API.md`
-
----
-
 ## Deployment
 
 ### Method 1: Script Installation (Recommended)
@@ -129,7 +122,7 @@ curl -sSL https://raw.githubusercontent.com/Wei-Shaw/sub2api/main/deploy/install
 
 ---
 
-### Method 2: Docker Compose (Recommended)
+### Method 2: Docker Compose
 
 Deploy with Docker Compose, including PostgreSQL and Redis containers.
 
@@ -138,59 +131,29 @@ Deploy with Docker Compose, including PostgreSQL and Redis containers.
 - Docker 20.10+
 - Docker Compose v2+
 
-#### Quick Start (One-Click Deployment)
-
-Use the automated deployment script for easy setup:
-
-```bash
-# Create deployment directory
-mkdir -p sub2api-deploy && cd sub2api-deploy
-
-# Download and run deployment preparation script
-curl -sSL https://raw.githubusercontent.com/Wei-Shaw/sub2api/main/deploy/docker-deploy.sh | bash
-
-# Start services
-docker-compose up -d
-
-# View logs
-docker-compose logs -f sub2api
-```
-
-**What the script does:**
-- Downloads `docker-compose.local.yml` (saved as `docker-compose.yml`) and `.env.example`
-- Generates secure credentials (JWT_SECRET, TOTP_ENCRYPTION_KEY, POSTGRES_PASSWORD)
-- Creates `.env` file with auto-generated secrets
-- Creates data directories (uses local directories for easy backup/migration)
-- Displays generated credentials for your reference
-
-#### Manual Deployment
-
-If you prefer manual setup:
+#### Installation Steps
 
 ```bash
 # 1. Clone the repository
 git clone https://github.com/Wei-Shaw/sub2api.git
-cd sub2api/deploy
+cd sub2api
 
-# 2. Copy environment configuration
+# 2. Enter the deploy directory
+cd deploy
+
+# 3. Copy environment configuration
 cp .env.example .env
 
-# 3. Edit configuration (generate secure passwords)
+# 4. Edit configuration (set your passwords)
 nano .env
 ```
 
 **Required configuration in `.env`:**
 
 ```bash
-# PostgreSQL password (REQUIRED)
+# PostgreSQL password (REQUIRED - change this!)
 POSTGRES_PASSWORD=your_secure_password_here
 
-# JWT Secret (RECOMMENDED - keeps users logged in after restart)
-JWT_SECRET=your_jwt_secret_here
-
-# TOTP Encryption Key (RECOMMENDED - preserves 2FA after restart)
-TOTP_ENCRYPTION_KEY=your_totp_key_here
-
 # Optional: Admin account
 ADMIN_EMAIL=admin@example.com
 ADMIN_PASSWORD=your_admin_password
@@ -199,96 +162,40 @@ ADMIN_PASSWORD=your_admin_password
 SERVER_PORT=8080
 ```
 
-**Generate secure secrets:**
 ```bash
-# Generate JWT_SECRET
-openssl rand -hex 32
-
-# Generate TOTP_ENCRYPTION_KEY
-openssl rand -hex 32
-
-# Generate POSTGRES_PASSWORD
-openssl rand -hex 32
-```
-
-```bash
-# 4. Create data directories (for local version)
-mkdir -p data postgres_data redis_data
-
 # 5. Start all services
-# Option A: Local directory version (recommended - easy migration)
-docker-compose -f docker-compose.local.yml up -d
-
-# Option B: Named volumes version (simple setup)
 docker-compose up -d
 
 # 6. Check status
-docker-compose -f docker-compose.local.yml ps
+docker-compose ps
 
 # 7. View logs
-docker-compose -f docker-compose.local.yml logs -f sub2api
+docker-compose logs -f sub2api
 ```
 
-#### Deployment Versions
-
-| Version | Data Storage | Migration | Best For |
-|---------|-------------|-----------|----------|
-| **docker-compose.local.yml** | Local directories | ✅ Easy (tar entire directory) | Production, frequent backups |
-| **docker-compose.yml** | Named volumes | ⚠️ Requires docker commands | Simple setup |
-
-**Recommendation:** Use `docker-compose.local.yml` (deployed by script) for easier data management.
-
 #### Access
 
 Open `http://YOUR_SERVER_IP:8080` in your browser.
 
-If admin password was auto-generated, find it in logs:
-```bash
-docker-compose -f docker-compose.local.yml logs sub2api | grep "admin password"
-```
-
 #### Upgrade
 
 ```bash
 # Pull latest image and recreate container
-docker-compose -f docker-compose.local.yml pull
-docker-compose -f docker-compose.local.yml up -d
-```
-
-#### Easy Migration (Local Directory Version)
-
-When using `docker-compose.local.yml`, migrate to a new server easily:
-
-```bash
-# On source server
-docker-compose -f docker-compose.local.yml down
-cd ..
-tar czf sub2api-complete.tar.gz sub2api-deploy/
-
-# Transfer to new server
-scp sub2api-complete.tar.gz user@new-server:/path/
-
-# On new server
-tar xzf sub2api-complete.tar.gz
-cd sub2api-deploy/
-docker-compose -f docker-compose.local.yml up -d
+docker-compose pull
+docker-compose up -d
 ```
 
 #### Useful Commands
 
 ```bash
 # Stop all services
-docker-compose -f docker-compose.local.yml down
+docker-compose down
 
 # Restart
-docker-compose -f docker-compose.local.yml restart
+docker-compose restart
 
 # View all logs
-docker-compose -f docker-compose.local.yml logs -f
-
-# Remove all data (caution!)
-docker-compose -f docker-compose.local.yml down
-rm -rf data/ postgres_data/ redis_data/
+docker-compose logs -f
 ```
 
 ---
@@ -311,23 +218,20 @@ Build and run from source code for development or customization.
 git clone https://github.com/Wei-Shaw/sub2api.git
 cd sub2api
 
-# 2. Install pnpm (if not already installed)
-npm install -g pnpm
-
-# 3. Build frontend
+# 2. Build frontend
 cd frontend
-pnpm install
-pnpm run build
+npm install
+npm run build
 # Output will be in ../backend/internal/web/dist/
 
-# 4. Build backend with embedded frontend
+# 3. Build backend with embedded frontend
 cd ../backend
 go build -tags embed -o sub2api ./cmd/server
 
-# 5. Create configuration file
+# 4. Create configuration file
 cp ../deploy/config.example.yaml ./config.yaml
 
-# 6. Edit configuration
+# 5. Edit configuration
 nano config.yaml
 ```
 
@@ -364,65 +268,6 @@ default:
   rate_multiplier: 1.0
 ```
 
-### Sora Status (Temporarily Unavailable)
-
-> ⚠️ Sora-related features are temporarily unavailable due to technical issues in upstream integration and media delivery.
-> Please do not rely on Sora in production at this time.
-> Existing `gateway.sora_*` configuration keys are reserved and may not take effect until these issues are resolved.
-
-Additional security-related options are available in `config.yaml`:
-
-- `cors.allowed_origins` for CORS allowlist
-- `security.url_allowlist` for upstream/pricing/CRS host allowlists
-- `security.url_allowlist.enabled` to disable URL validation (use with caution)
-- `security.url_allowlist.allow_insecure_http` to allow HTTP URLs when validation is disabled
-- `security.url_allowlist.allow_private_hosts` to allow private/local IP addresses
-- `security.response_headers.enabled` to enable configurable response header filtering (disabled uses default allowlist)
-- `security.csp` to control Content-Security-Policy headers
-- `billing.circuit_breaker` to fail closed on billing errors
-- `server.trusted_proxies` to enable X-Forwarded-For parsing
-- `turnstile.required` to require Turnstile in release mode
-
-**⚠️ Security Warning: HTTP URL Configuration**
-
-When `security.url_allowlist.enabled=false`, the system performs minimal URL validation by default, **rejecting HTTP URLs** and only allowing HTTPS. To allow HTTP URLs (e.g., for development or internal testing), you must explicitly set:
-
-```yaml
-security:
-  url_allowlist:
-    enabled: false                # Disable allowlist checks
-    allow_insecure_http: true     # Allow HTTP URLs (⚠️ INSECURE)
-```
-
-**Or via environment variable:**
-
-```bash
-SECURITY_URL_ALLOWLIST_ENABLED=false
-SECURITY_URL_ALLOWLIST_ALLOW_INSECURE_HTTP=true
-```
-
-**Risks of allowing HTTP:**
-- API keys and data transmitted in **plaintext** (vulnerable to interception)
-- Susceptible to **man-in-the-middle (MITM) attacks**
-- **NOT suitable for production** environments
-
-**When to use HTTP:**
-- ✅ Development/testing with local servers (http://localhost)
-- ✅ Internal networks with trusted endpoints
-- ✅ Testing account connectivity before obtaining HTTPS
-- ❌ Production environments (use HTTPS only)
-
-**Example error without this setting:**
-```
-Invalid base URL: invalid url scheme: http
-```
-
-If you disable URL validation or response header filtering, harden your network layer:
-- Enforce an egress allowlist for upstream domains/IPs
-- Block private/loopback/link-local ranges
-- Enforce TLS-only outbound traffic
-- Strip sensitive upstream response headers at the proxy
-
 ```bash
 # 6. Run the application
 ./sub2api
@@ -437,7 +282,7 @@ go run ./cmd/server
 
 # Frontend (with hot reload)
 cd frontend
-pnpm run dev
+npm run dev
 ```
 
 #### Code Generation
@@ -452,16 +297,6 @@ go generate ./cmd/server
 
 ---
 
-## Simple Mode
-
-Simple Mode is designed for individual developers or internal teams who want quick access without full SaaS features.
-
-- Enable: Set environment variable `RUN_MODE=simple`
-- Difference: Hides SaaS-related features and skips billing process
-- Security note: In production, you must also set `SIMPLE_MODE_CONFIRM=true` to allow startup
-
----
-
 ## Antigravity Support
 
 Sub2API supports [Antigravity](https://antigravity.so/) accounts. After authorization, dedicated endpoints are available for Claude and Gemini models.
@@ -486,12 +321,6 @@ Antigravity accounts support optional **hybrid scheduling**. When enabled, the g
 
 > **⚠️ Warning**: Anthropic Claude and Antigravity Claude **cannot be mixed within the same conversation context**. Use groups to isolate them properly.
 
-### Known Issues
-
-In Claude Code, Plan Mode cannot exit automatically. (Normally when using the native Claude API, after planning is complete, Claude Code will pop up options for users to approve or reject the plan.)
-
-**Workaround**: Press `Shift + Tab` to manually exit Plan Mode, then type your response to approve or reject the plan.
-
 ---
 
 ## Project Structure
@@ -522,28 +351,6 @@ sub2api/
     └── install.sh            # One-click installation script
 ```
 
-## Disclaimer
-
-> **Please read carefully before using this project:**
->
-> :rotating_light: **Terms of Service Risk**: Using this project may violate Anthropic's Terms of Service. Please read Anthropic's user agreement carefully before use. All risks arising from the use of this project are borne solely by the user.
->
-> :book: **Disclaimer**: This project is for technical learning and research purposes only. The author assumes no responsibility for account suspension, service interruption, or any other losses caused by the use of this project.
-
----
-
-## Star History
-
-<a href="https://star-history.com/#Wei-Shaw/sub2api&Date">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=Wei-Shaw/sub2api&type=Date&theme=dark" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=Wei-Shaw/sub2api&type=Date" />
-   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=Wei-Shaw/sub2api&type=Date" />
- </picture>
-</a>
-
----
-
 ## License
 
 MIT License

README_CN.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Go](https://img.shields.io/badge/Go-1.25.7-00ADD8.svg)](https://golang.org/)
+[![Go](https://img.shields.io/badge/Go-1.21+-00ADD8.svg)](https://golang.org/)
 [![Vue](https://img.shields.io/badge/Vue-3.4+-4FC08D.svg)](https://vuejs.org/)
 [![PostgreSQL](https://img.shields.io/badge/PostgreSQL-15+-336791.svg)](https://www.postgresql.org/)
 [![Redis](https://img.shields.io/badge/Redis-7+-DC382D.svg)](https://redis.io/)
@@ -44,24 +44,13 @@ Sub2API 是一个 AI API 网关平台，用于分发和管理 AI 产品订阅（
 
 | 组件 | 技术 |
 |------|------|
-| 后端 | Go 1.25.7, Gin, Ent |
+| 后端 | Go 1.21+, Gin, GORM |
 | 前端 | Vue 3.4+, Vite 5+, TailwindCSS |
 | 数据库 | PostgreSQL 15+ |
 | 缓存/队列 | Redis 7+ |
 
 ---
 
-## 文档
-
-- 依赖安全：`docs/dependency-security.md`
-
----
-
-## OpenAI Responses 兼容注意事项
-
-- 当请求包含 `function_call_output` 时，需要携带 `previous_response_id`，或在 `input` 中包含带 `call_id` 的 `tool_call`/`function_call`，或带非空 `id` 且与 `function_call_output.call_id` 匹配的 `item_reference`。
-- 若依赖上游历史记录，网关会强制 `store=true` 并需要复用 `previous_response_id`，以避免出现 “No tool call found for function call output” 错误。
-
 ## 部署方式
 
 ### 方式一：脚本安装（推荐）
@@ -133,7 +122,7 @@ curl -sSL https://raw.githubusercontent.com/Wei-Shaw/sub2api/main/deploy/install
 
 ---
 
-### 方式二：Docker Compose（推荐）
+### 方式二：Docker Compose
 
 使用 Docker Compose 部署，包含 PostgreSQL 和 Redis 容器。
 
@@ -142,59 +131,29 @@ curl -sSL https://raw.githubusercontent.com/Wei-Shaw/sub2api/main/deploy/install
 - Docker 20.10+
 - Docker Compose v2+
 
-#### 快速开始（一键部署）
-
-使用自动化部署脚本快速搭建：
-
-```bash
-# 创建部署目录
-mkdir -p sub2api-deploy && cd sub2api-deploy
-
-# 下载并运行部署准备脚本
-curl -sSL https://raw.githubusercontent.com/Wei-Shaw/sub2api/main/deploy/docker-deploy.sh | bash
-
-# 启动服务
-docker-compose up -d
-
-# 查看日志
-docker-compose logs -f sub2api
-```
-
-**脚本功能：**
-- 下载 `docker-compose.local.yml`（本地保存为 `docker-compose.yml`）和 `.env.example`
-- 自动生成安全凭证（JWT_SECRET、TOTP_ENCRYPTION_KEY、POSTGRES_PASSWORD）
-- 创建 `.env` 文件并填充自动生成的密钥
-- 创建数据目录（使用本地目录，便于备份和迁移）
-- 显示生成的凭证供你记录
-
-#### 手动部署
-
-如果你希望手动配置：
+#### 安装步骤
 
 ```bash
 # 1. 克隆仓库
 git clone https://github.com/Wei-Shaw/sub2api.git
-cd sub2api/deploy
+cd sub2api
 
-# 2. 复制环境配置文件
+# 2. 进入 deploy 目录
+cd deploy
+
+# 3. 复制环境配置文件
 cp .env.example .env
 
-# 3. 编辑配置（生成安全密码）
+# 4. 编辑配置（设置密码等）
 nano .env
 ```
 
 **`.env` 必须配置项：**
 
 ```bash
-# PostgreSQL 密码（必需）
+# PostgreSQL 密码（必须修改！）
 POSTGRES_PASSWORD=your_secure_password_here
 
-# JWT 密钥（推荐 - 重启后保持用户登录状态）
-JWT_SECRET=your_jwt_secret_here
-
-# TOTP 加密密钥（推荐 - 重启后保留双因素认证）
-TOTP_ENCRYPTION_KEY=your_totp_key_here
-
 # 可选：管理员账号
 ADMIN_EMAIL=admin@example.com
 ADMIN_PASSWORD=your_admin_password
@@ -203,108 +162,40 @@ ADMIN_PASSWORD=your_admin_password
 SERVER_PORT=8080
 ```
 
-**生成安全密钥：**
 ```bash
-# 生成 JWT_SECRET
-openssl rand -hex 32
-
-# 生成 TOTP_ENCRYPTION_KEY
-openssl rand -hex 32
-
-# 生成 POSTGRES_PASSWORD
-openssl rand -hex 32
-```
-
-```bash
-# 4. 创建数据目录（本地版）
-mkdir -p data postgres_data redis_data
-
 # 5. 启动所有服务
-# 选项 A：本地目录版（推荐 - 易于迁移）
-docker-compose -f docker-compose.local.yml up -d
-
-# 选项 B：命名卷版（简单设置）
 docker-compose up -d
 
 # 6. 查看状态
-docker-compose -f docker-compose.local.yml ps
+docker-compose ps
 
 # 7. 查看日志
-docker-compose -f docker-compose.local.yml logs -f sub2api
+docker-compose logs -f sub2api
 ```
 
-#### 部署版本对比
-
-| 版本 | 数据存储 | 迁移便利性 | 适用场景 |
-|------|---------|-----------|---------|
-| **docker-compose.local.yml** | 本地目录 | ✅ 简单（打包整个目录） | 生产环境、频繁备份 |
-| **docker-compose.yml** | 命名卷 | ⚠️ 需要 docker 命令 | 简单设置 |
-
-**推荐：** 使用 `docker-compose.local.yml`（脚本部署）以便更轻松地管理数据。
-
-#### 启用“数据管理”功能（datamanagementd）
-
-如需启用管理后台“数据管理”，需要额外部署宿主机数据管理进程 `datamanagementd`。
-
-关键点：
-
-- 主进程固定探测：`/tmp/sub2api-datamanagement.sock`
-- 只有该 Socket 可连通时，数据管理功能才会开启
-- Docker 场景需将宿主机 Socket 挂载到容器同路径
-
-详细部署步骤见：`deploy/DATAMANAGEMENTD_CN.md`
-
 #### 访问
 
 在浏览器中打开 `http://你的服务器IP:8080`
 
-如果管理员密码是自动生成的，在日志中查找：
-```bash
-docker-compose -f docker-compose.local.yml logs sub2api | grep "admin password"
-```
-
 #### 升级
 
 ```bash
 # 拉取最新镜像并重建容器
-docker-compose -f docker-compose.local.yml pull
-docker-compose -f docker-compose.local.yml up -d
-```
-
-#### 轻松迁移（本地目录版）
-
-使用 `docker-compose.local.yml` 时，可以轻松迁移到新服务器：
-
-```bash
-# 源服务器
-docker-compose -f docker-compose.local.yml down
-cd ..
-tar czf sub2api-complete.tar.gz sub2api-deploy/
-
-# 传输到新服务器
-scp sub2api-complete.tar.gz user@new-server:/path/
-
-# 新服务器
-tar xzf sub2api-complete.tar.gz
-cd sub2api-deploy/
-docker-compose -f docker-compose.local.yml up -d
+docker-compose pull
+docker-compose up -d
 ```
 
 #### 常用命令
 
 ```bash
 # 停止所有服务
-docker-compose -f docker-compose.local.yml down
+docker-compose down
 
 # 重启
-docker-compose -f docker-compose.local.yml restart
+docker-compose restart
 
 # 查看所有日志
-docker-compose -f docker-compose.local.yml logs -f
-
-# 删除所有数据（谨慎！）
-docker-compose -f docker-compose.local.yml down
-rm -rf data/ postgres_data/ redis_data/
+docker-compose logs -f
 ```
 
 ---
@@ -327,23 +218,20 @@ rm -rf data/ postgres_data/ redis_data/
 git clone https://github.com/Wei-Shaw/sub2api.git
 cd sub2api
 
-# 2. 安装 pnpm（如果还没有安装）
-npm install -g pnpm
-
-# 3. 编译前端
+# 2. 编译前端
 cd frontend
-pnpm install
-pnpm run build
+npm install
+npm run build
 # 构建产物输出到 ../backend/internal/web/dist/
 
-# 4. 编译后端（嵌入前端）
+# 3. 编译后端（嵌入前端）
 cd ../backend
 go build -tags embed -o sub2api ./cmd/server
 
-# 5. 创建配置文件
+# 4. 创建配置文件
 cp ../deploy/config.example.yaml ./config.yaml
 
-# 6. 编辑配置
+# 5. 编辑配置
 nano config.yaml
 ```
 
@@ -380,122 +268,11 @@ default:
   rate_multiplier: 1.0
 ```
 
-### Sora 功能状态（暂不可用）
-
-> ⚠️ 当前 Sora 相关功能因上游接入与媒体链路存在技术问题，暂时不可用。
-> 现阶段请勿在生产环境依赖 Sora 能力。
-> 文档中的 `gateway.sora_*` 配置仅作预留，待技术问题修复后再恢复可用。
-
-### Sora 媒体签名 URL（功能恢复后可选）
-
-当配置 `gateway.sora_media_signing_key` 且 `gateway.sora_media_signed_url_ttl_seconds > 0` 时，网关会将 Sora 输出的媒体地址改写为临时签名 URL（`/sora/media-signed/...`）。这样无需 API Key 即可在浏览器中直接访问，且具备过期控制与防篡改能力（签名包含 path + query）。
-
-```yaml
-gateway:
-  # /sora/media 是否强制要求 API Key（默认 false）
-  sora_media_require_api_key: false
-  # 媒体临时签名密钥（为空则禁用签名）
-  sora_media_signing_key: "your-signing-key"
-  # 临时签名 URL 有效期（秒）
-  sora_media_signed_url_ttl_seconds: 900
-```
-
-> 若未配置签名密钥，`/sora/media-signed` 将返回 503。  
-> 如需更严格的访问控制，可将 `sora_media_require_api_key` 设为 true，仅允许携带 API Key 的 `/sora/media` 访问。
-
-访问策略说明：
-- `/sora/media`：内部调用或客户端携带 API Key 才能下载
-- `/sora/media-signed`：外部可访问，但有签名 + 过期控制
-
-`config.yaml` 还支持以下安全相关配置：
-
-- `cors.allowed_origins` 配置 CORS 白名单
-- `security.url_allowlist` 配置上游/价格数据/CRS 主机白名单
-- `security.url_allowlist.enabled` 可关闭 URL 校验（慎用）
-- `security.url_allowlist.allow_insecure_http` 关闭校验时允许 HTTP URL
-- `security.url_allowlist.allow_private_hosts` 允许私有/本地 IP 地址
-- `security.response_headers.enabled` 可启用可配置响应头过滤（关闭时使用默认白名单）
-- `security.csp` 配置 Content-Security-Policy
-- `billing.circuit_breaker` 计费异常时 fail-closed
-- `server.trusted_proxies` 启用可信代理解析 X-Forwarded-For
-- `turnstile.required` 在 release 模式强制启用 Turnstile
-
-**网关防御纵深建议（重点）**
-
-- `gateway.upstream_response_read_max_bytes`：限制非流式上游响应读取大小（默认 `8MB`），用于防止异常响应导致内存放大。
-- `gateway.proxy_probe_response_read_max_bytes`：限制代理探测响应读取大小（默认 `1MB`）。
-- `gateway.gemini_debug_response_headers`：默认 `false`，仅在排障时短时开启，避免高频请求日志开销。
-- `/auth/register`、`/auth/login`、`/auth/login/2fa`、`/auth/send-verify-code` 已提供服务端兜底限流（Redis 故障时 fail-close）。
-- 推荐将 WAF/CDN 作为第一层防护，服务端限流与响应读取上限作为第二层兜底；两层同时保留，避免旁路流量与误配置风险。
-
-**⚠️ 安全警告：HTTP URL 配置**
-
-当 `security.url_allowlist.enabled=false` 时，系统默认执行最小 URL 校验，**拒绝 HTTP URL**，仅允许 HTTPS。要允许 HTTP URL（例如用于开发或内网测试），必须显式设置：
-
-```yaml
-security:
-  url_allowlist:
-    enabled: false                # 禁用白名单检查
-    allow_insecure_http: true     # 允许 HTTP URL（⚠️ 不安全）
-```
-
-**或通过环境变量：**
-
-```bash
-SECURITY_URL_ALLOWLIST_ENABLED=false
-SECURITY_URL_ALLOWLIST_ALLOW_INSECURE_HTTP=true
-```
-
-**允许 HTTP 的风险：**
-- API 密钥和数据以**明文传输**（可被截获）
-- 易受**中间人攻击 (MITM)**
-- **不适合生产环境**
-
-**适用场景：**
-- ✅ 开发/测试环境的本地服务器（http://localhost）
-- ✅ 内网可信端点
-- ✅ 获取 HTTPS 前测试账号连通性
-- ❌ 生产环境（仅使用 HTTPS）
-
-**未设置此项时的错误示例：**
-```
-Invalid base URL: invalid url scheme: http
-```
-
-如关闭 URL 校验或响应头过滤，请加强网络层防护：
-- 出站访问白名单限制上游域名/IP
-- 阻断私网/回环/链路本地地址
-- 强制仅允许 TLS 出站
-- 在反向代理层移除敏感响应头
-
 ```bash
 # 6. 运行应用
 ./sub2api
 ```
 
-#### HTTP/2 (h2c) 与 HTTP/1.1 回退
-
-后端明文端口默认支持 h2c，并保留 HTTP/1.1 回退用于 WebSocket 与旧客户端。浏览器通常不支持 h2c，性能收益主要在反向代理或内网链路。
-
-**反向代理示例（Caddy）：**
-
-```caddyfile
-transport http {
-	versions h2c h1
-}
-```
-
-**验证：**
-
-```bash
-# h2c prior knowledge
-curl --http2-prior-knowledge -I http://localhost:8080/health
-# HTTP/1.1 回退
-curl --http1.1 -I http://localhost:8080/health
-# WebSocket 回退验证（需管理员 token）
-websocat -H="Sec-WebSocket-Protocol: sub2api-admin, jwt.<ADMIN_TOKEN>" ws://localhost:8080/api/v1/admin/ops/ws/qps
-```
-
 #### 开发模式
 
 ```bash
@@ -505,7 +282,7 @@ go run ./cmd/server
 
 # 前端（支持热重载）
 cd frontend
-pnpm run dev
+npm run dev
 ```
 
 #### 代码生成
@@ -554,10 +331,6 @@ Antigravity 账户支持可选的**混合调度**功能。开启后，通用端
 
 > **⚠️ 注意**：Anthropic Claude 和 Antigravity Claude **不能在同一上下文中混合使用**，请通过分组功能做好隔离。
 
-
-### 已知问题
-在 Claude Code 中，无法自动退出Plan Mode。（正常使用原生Claude Api时，Plan 完成后，Claude Code会弹出弹出选项让用户同意或拒绝Plan。） 
-解决办法：shift + Tab，手动退出Plan mode，然后输入内容 告诉 Claude Code 同意或拒绝 Plan
 ---
 
 ## 项目结构
@@ -588,28 +361,6 @@ sub2api/
     └── install.sh            # 一键安装脚本
 ```
 
-## 免责声明
-
-> **使用本项目前请仔细阅读：**
->
-> :rotating_light: **服务条款风险**: 使用本项目可能违反 Anthropic 的服务条款。请在使用前仔细阅读 Anthropic 的用户协议，使用本项目的一切风险由用户自行承担。
->
-> :book: **免责声明**: 本项目仅供技术学习和研究使用，作者不对因使用本项目导致的账户封禁、服务中断或其他损失承担任何责任。
-
----
-
-## Star History
-
-<a href="https://star-history.com/#Wei-Shaw/sub2api&Date">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=Wei-Shaw/sub2api&type=Date&theme=dark" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=Wei-Shaw/sub2api&type=Date" />
-   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=Wei-Shaw/sub2api&type=Date" />
- </picture>
-</a>
-
----
-
 ## 许可证
 
 MIT License

backend/.dockerignore

@@ -1,2 +0,0 @@
-.cache/
-.DS_Store

backend/.golangci.yml

@@ -5,7 +5,6 @@ linters:
   enable:
     - depguard
     - errcheck
-    - gosec
     - govet
     - ineffassign
     - staticcheck
@@ -19,12 +18,6 @@ linters:
           list-mode: original
           files:
             - "**/internal/service/**"
-            - "!**/internal/service/ops_aggregation_service.go"
-            - "!**/internal/service/ops_alert_evaluator_service.go"
-            - "!**/internal/service/ops_cleanup_service.go"
-            - "!**/internal/service/ops_metrics_collector.go"
-            - "!**/internal/service/ops_scheduled_report_service.go"
-            - "!**/internal/service/wire.go"
           deny:
             - pkg: github.com/Wei-Shaw/sub2api/internal/repository
               desc: "service must not import repository"
@@ -43,22 +36,6 @@ linters:
               desc: "handler must not import gorm"
             - pkg: github.com/redis/go-redis/v9
               desc: "handler must not import redis"
-    gosec:
-      excludes:
-        - G101
-        - G103
-        - G104
-        - G109
-        - G115
-        - G201
-        - G202
-        - G301
-        - G302
-        - G304
-        - G306
-        - G404
-      severity: high
-      confidence: high
     errcheck:
       # Report about not checking of errors in type assertions: `a := b.(MyStruct)`.
       # Such cases aren't reported by default.
@@ -93,33 +70,519 @@ linters:
       check-escaping-errors: true
     staticcheck:
       # https://staticcheck.dev/docs/configuration/options/#dot_import_whitelist
+      # Default: ["github.com/mmcloughlin/avo/build", "github.com/mmcloughlin/avo/operand", "github.com/mmcloughlin/avo/reg"]
       dot-import-whitelist:
         - fmt
       # https://staticcheck.dev/docs/configuration/options/#initialisms
+      # Default: ["ACL", "API", "ASCII", "CPU", "CSS", "DNS", "EOF", "GUID", "HTML", "HTTP", "HTTPS", "ID", "IP", "JSON", "QPS", "RAM", "RPC", "SLA", "SMTP", "SQL", "SSH", "TCP", "TLS", "TTL", "UDP", "UI", "GID", "UID", "UUID", "URI", "URL", "UTF8", "VM", "XML", "XMPP", "XSRF", "XSS", "SIP", "RTP", "AMQP", "DB", "TS"]
       initialisms: [ "ACL", "API", "ASCII", "CPU", "CSS", "DNS", "EOF", "GUID", "HTML", "HTTP", "HTTPS", "ID", "IP", "JSON", "QPS", "RAM", "RPC", "SLA", "SMTP", "SQL", "SSH", "TCP", "TLS", "TTL", "UDP", "UI", "GID", "UID", "UUID", "URI", "URL", "UTF8", "VM", "XML", "XMPP", "XSRF", "XSS", "SIP", "RTP", "AMQP", "DB", "TS" ]
       # https://staticcheck.dev/docs/configuration/options/#http_status_code_whitelist
+      # Default: ["200", "400", "404", "500"]
       http-status-code-whitelist: [ "200", "400", "404", "500" ]
-      # "all" enables every SA/ST/S/QF check; only list the ones to disable.
+      # SAxxxx checks in https://staticcheck.dev/docs/configuration/options/#checks
+      # Example (to disable some checks): [ "all", "-SA1000", "-SA1001"]
+      # Run `GL_DEBUG=staticcheck golangci-lint run --enable=staticcheck` to see all available checks and enabled by config checks.
+      # Default: ["all", "-ST1000", "-ST1003", "-ST1016", "-ST1020", "-ST1021", "-ST1022"]
       checks:
-        - all
-        - -ST1000  # Package comment format
-        - -ST1003  # Poorly chosen identifier (ApiKey vs APIKey)
-        - -ST1020  # Comment on exported method format
-        - -ST1021  # Comment on exported type format
-        - -ST1022  # Comment on exported variable format
+        # Invalid regular expression.
+        # https://staticcheck.dev/docs/checks/#SA1000
+        - SA1000
+        # Invalid template.
+        # https://staticcheck.dev/docs/checks/#SA1001
+        - SA1001
+        # Invalid format in 'time.Parse'.
+        # https://staticcheck.dev/docs/checks/#SA1002
+        - SA1002
+        # Unsupported argument to functions in 'encoding/binary'.
+        # https://staticcheck.dev/docs/checks/#SA1003
+        - SA1003
+        # Suspiciously small untyped constant in 'time.Sleep'.
+        # https://staticcheck.dev/docs/checks/#SA1004
+        - SA1004
+        # Invalid first argument to 'exec.Command'.
+        # https://staticcheck.dev/docs/checks/#SA1005
+        - SA1005
+        # 'Printf' with dynamic first argument and no further arguments.
+        # https://staticcheck.dev/docs/checks/#SA1006
+        - SA1006
+        # Invalid URL in 'net/url.Parse'.
+        # https://staticcheck.dev/docs/checks/#SA1007
+        - SA1007
+        # Non-canonical key in 'http.Header' map.
+        # https://staticcheck.dev/docs/checks/#SA1008
+        - SA1008
+        # '(*regexp.Regexp).FindAll' called with 'n == 0', which will always return zero results.
+        # https://staticcheck.dev/docs/checks/#SA1010
+        - SA1010
+        # Various methods in the "strings" package expect valid UTF-8, but invalid input is provided.
+        # https://staticcheck.dev/docs/checks/#SA1011
+        - SA1011
+        # A nil 'context.Context' is being passed to a function, consider using 'context.TODO' instead.
+        # https://staticcheck.dev/docs/checks/#SA1012
+        - SA1012
+        # 'io.Seeker.Seek' is being called with the whence constant as the first argument, but it should be the second.
+        # https://staticcheck.dev/docs/checks/#SA1013
+        - SA1013
+        # Non-pointer value passed to 'Unmarshal' or 'Decode'.
+        # https://staticcheck.dev/docs/checks/#SA1014
+        - SA1014
+        # Using 'time.Tick' in a way that will leak. Consider using 'time.NewTicker', and only use 'time.Tick' in tests, commands and endless functions.
+        # https://staticcheck.dev/docs/checks/#SA1015
+        - SA1015
+        # Trapping a signal that cannot be trapped.
+        # https://staticcheck.dev/docs/checks/#SA1016
+        - SA1016
+        # Channels used with 'os/signal.Notify' should be buffered.
+        # https://staticcheck.dev/docs/checks/#SA1017
+        - SA1017
+        # 'strings.Replace' called with 'n == 0', which does nothing.
+        # https://staticcheck.dev/docs/checks/#SA1018
+        - SA1018
+        # Using a deprecated function, variable, constant or field.
+        # https://staticcheck.dev/docs/checks/#SA1019
+        - SA1019
+        # Using an invalid host:port pair with a 'net.Listen'-related function.
+        # https://staticcheck.dev/docs/checks/#SA1020
+        - SA1020
+        # Using 'bytes.Equal' to compare two 'net.IP'.
+        # https://staticcheck.dev/docs/checks/#SA1021
+        - SA1021
+        # Modifying the buffer in an 'io.Writer' implementation.
+        # https://staticcheck.dev/docs/checks/#SA1023
+        - SA1023
+        # A string cutset contains duplicate characters.
+        # https://staticcheck.dev/docs/checks/#SA1024
+        - SA1024
+        # It is not possible to use '(*time.Timer).Reset''s return value correctly.
+        # https://staticcheck.dev/docs/checks/#SA1025
+        - SA1025
+        # Cannot marshal channels or functions.
+        # https://staticcheck.dev/docs/checks/#SA1026
+        - SA1026
+        # Atomic access to 64-bit variable must be 64-bit aligned.
+        # https://staticcheck.dev/docs/checks/#SA1027
+        - SA1027
+        # 'sort.Slice' can only be used on slices.
+        # https://staticcheck.dev/docs/checks/#SA1028
+        - SA1028
+        # Inappropriate key in call to 'context.WithValue'.
+        # https://staticcheck.dev/docs/checks/#SA1029
+        - SA1029
+        # Invalid argument in call to a 'strconv' function.
+        # https://staticcheck.dev/docs/checks/#SA1030
+        - SA1030
+        # Overlapping byte slices passed to an encoder.
+        # https://staticcheck.dev/docs/checks/#SA1031
+        - SA1031
+        # Wrong order of arguments to 'errors.Is'.
+        # https://staticcheck.dev/docs/checks/#SA1032
+        - SA1032
+        # 'sync.WaitGroup.Add' called inside the goroutine, leading to a race condition.
+        # https://staticcheck.dev/docs/checks/#SA2000
+        - SA2000
+        # Empty critical section, did you mean to defer the unlock?.
+        # https://staticcheck.dev/docs/checks/#SA2001
+        - SA2001
+        # Called 'testing.T.FailNow' or 'SkipNow' in a goroutine, which isn't allowed.
+        # https://staticcheck.dev/docs/checks/#SA2002
+        - SA2002
+        # Deferred 'Lock' right after locking, likely meant to defer 'Unlock' instead.
+        # https://staticcheck.dev/docs/checks/#SA2003
+        - SA2003
+        # 'TestMain' doesn't call 'os.Exit', hiding test failures.
+        # https://staticcheck.dev/docs/checks/#SA3000
+        - SA3000
+        # Assigning to 'b.N' in benchmarks distorts the results.
+        # https://staticcheck.dev/docs/checks/#SA3001
+        - SA3001
+        # Binary operator has identical expressions on both sides.
+        # https://staticcheck.dev/docs/checks/#SA4000
+        - SA4000
+        # '&*x' gets simplified to 'x', it does not copy 'x'.
+        # https://staticcheck.dev/docs/checks/#SA4001
+        - SA4001
+        # Comparing unsigned values against negative values is pointless.
+        # https://staticcheck.dev/docs/checks/#SA4003
+        - SA4003
+        # The loop exits unconditionally after one iteration.
+        # https://staticcheck.dev/docs/checks/#SA4004
+        - SA4004
+        # Field assignment that will never be observed. Did you mean to use a pointer receiver?.
+        # https://staticcheck.dev/docs/checks/#SA4005
+        - SA4005
+        # A value assigned to a variable is never read before being overwritten. Forgotten error check or dead code?.
+        # https://staticcheck.dev/docs/checks/#SA4006
+        - SA4006
+        # The variable in the loop condition never changes, are you incrementing the wrong variable?.
+        # https://staticcheck.dev/docs/checks/#SA4008
+        - SA4008
+        # A function argument is overwritten before its first use.
+        # https://staticcheck.dev/docs/checks/#SA4009
+        - SA4009
+        # The result of 'append' will never be observed anywhere.
+        # https://staticcheck.dev/docs/checks/#SA4010
+        - SA4010
+        # Break statement with no effect. Did you mean to break out of an outer loop?.
+        # https://staticcheck.dev/docs/checks/#SA4011
+        - SA4011
+        # Comparing a value against NaN even though no value is equal to NaN.
+        # https://staticcheck.dev/docs/checks/#SA4012
+        - SA4012
+        # Negating a boolean twice ('!!b') is the same as writing 'b'. This is either redundant, or a typo.
+        # https://staticcheck.dev/docs/checks/#SA4013
+        - SA4013
+        # An if/else if chain has repeated conditions and no side-effects; if the condition didn't match the first time, it won't match the second time, either.
+        # https://staticcheck.dev/docs/checks/#SA4014
+        - SA4014
+        # Calling functions like 'math.Ceil' on floats converted from integers doesn't do anything useful.
+        # https://staticcheck.dev/docs/checks/#SA4015
+        - SA4015
+        # Certain bitwise operations, such as 'x ^ 0', do not do anything useful.
+        # https://staticcheck.dev/docs/checks/#SA4016
+        - SA4016
+        # Discarding the return values of a function without side effects, making the call pointless.
+        # https://staticcheck.dev/docs/checks/#SA4017
+        - SA4017
+        # Self-assignment of variables.
+        # https://staticcheck.dev/docs/checks/#SA4018
+        - SA4018
+        # Multiple, identical build constraints in the same file.
+        # https://staticcheck.dev/docs/checks/#SA4019
+        - SA4019
+        # Unreachable case clause in a type switch.
+        # https://staticcheck.dev/docs/checks/#SA4020
+        - SA4020
+        # "x = append(y)" is equivalent to "x = y".
+        # https://staticcheck.dev/docs/checks/#SA4021
+        - SA4021
+        # Comparing the address of a variable against nil.
+        # https://staticcheck.dev/docs/checks/#SA4022
+        - SA4022
+        # Impossible comparison of interface value with untyped nil.
+        # https://staticcheck.dev/docs/checks/#SA4023
+        - SA4023
+        # Checking for impossible return value from a builtin function.
+        # https://staticcheck.dev/docs/checks/#SA4024
+        - SA4024
+        # Integer division of literals that results in zero.
+        # https://staticcheck.dev/docs/checks/#SA4025
+        - SA4025
+        # Go constants cannot express negative zero.
+        # https://staticcheck.dev/docs/checks/#SA4026
+        - SA4026
+        # '(*net/url.URL).Query' returns a copy, modifying it doesn't change the URL.
+        # https://staticcheck.dev/docs/checks/#SA4027
+        - SA4027
+        # 'x % 1' is always zero.
+        # https://staticcheck.dev/docs/checks/#SA4028
+        - SA4028
+        # Ineffective attempt at sorting slice.
+        # https://staticcheck.dev/docs/checks/#SA4029
+        - SA4029
+        # Ineffective attempt at generating random number.
+        # https://staticcheck.dev/docs/checks/#SA4030
+        - SA4030
+        # Checking never-nil value against nil.
+        # https://staticcheck.dev/docs/checks/#SA4031
+        - SA4031
+        # Comparing 'runtime.GOOS' or 'runtime.GOARCH' against impossible value.
+        # https://staticcheck.dev/docs/checks/#SA4032
+        - SA4032
+        # Assignment to nil map.
+        # https://staticcheck.dev/docs/checks/#SA5000
+        - SA5000
+        # Deferring 'Close' before checking for a possible error.
+        # https://staticcheck.dev/docs/checks/#SA5001
+        - SA5001
+        # The empty for loop ("for {}") spins and can block the scheduler.
+        # https://staticcheck.dev/docs/checks/#SA5002
+        - SA5002
+        # Defers in infinite loops will never execute.
+        # https://staticcheck.dev/docs/checks/#SA5003
+        - SA5003
+        # "for { select { ..." with an empty default branch spins.
+        # https://staticcheck.dev/docs/checks/#SA5004
+        - SA5004
+        # The finalizer references the finalized object, preventing garbage collection.
+        # https://staticcheck.dev/docs/checks/#SA5005
+        - SA5005
+        # Infinite recursive call.
+        # https://staticcheck.dev/docs/checks/#SA5007
+        - SA5007
+        # Invalid struct tag.
+        # https://staticcheck.dev/docs/checks/#SA5008
+        - SA5008
+        # Invalid Printf call.
+        # https://staticcheck.dev/docs/checks/#SA5009
+        - SA5009
+        # Impossible type assertion.
+        # https://staticcheck.dev/docs/checks/#SA5010
+        - SA5010
+        # Possible nil pointer dereference.
+        # https://staticcheck.dev/docs/checks/#SA5011
+        - SA5011
+        # Passing odd-sized slice to function expecting even size.
+        # https://staticcheck.dev/docs/checks/#SA5012
+        - SA5012
+        # Using 'regexp.Match' or related in a loop, should use 'regexp.Compile'.
+        # https://staticcheck.dev/docs/checks/#SA6000
+        - SA6000
+        # Missing an optimization opportunity when indexing maps by byte slices.
+        # https://staticcheck.dev/docs/checks/#SA6001
+        - SA6001
+        # Storing non-pointer values in 'sync.Pool' allocates memory.
+        # https://staticcheck.dev/docs/checks/#SA6002
+        - SA6002
+        # Converting a string to a slice of runes before ranging over it.
+        # https://staticcheck.dev/docs/checks/#SA6003
+        - SA6003
+        # Inefficient string comparison with 'strings.ToLower' or 'strings.ToUpper'.
+        # https://staticcheck.dev/docs/checks/#SA6005
+        - SA6005
+        # Using io.WriteString to write '[]byte'.
+        # https://staticcheck.dev/docs/checks/#SA6006
+        - SA6006
+        # Defers in range loops may not run when you expect them to.
+        # https://staticcheck.dev/docs/checks/#SA9001
+        - SA9001
+        # Using a non-octal 'os.FileMode' that looks like it was meant to be in octal.
+        # https://staticcheck.dev/docs/checks/#SA9002
+        - SA9002
+        # Empty body in an if or else branch.
+        # https://staticcheck.dev/docs/checks/#SA9003
+        - SA9003
+        # Only the first constant has an explicit type.
+        # https://staticcheck.dev/docs/checks/#SA9004
+        - SA9004
+        # Trying to marshal a struct with no public fields nor custom marshaling.
+        # https://staticcheck.dev/docs/checks/#SA9005
+        - SA9005
+        # Dubious bit shifting of a fixed size integer value.
+        # https://staticcheck.dev/docs/checks/#SA9006
+        - SA9006
+        # Deleting a directory that shouldn't be deleted.
+        # https://staticcheck.dev/docs/checks/#SA9007
+        - SA9007
+        # 'else' branch of a type assertion is probably not reading the right value.
+        # https://staticcheck.dev/docs/checks/#SA9008
+        - SA9008
+        # Ineffectual Go compiler directive.
+        # https://staticcheck.dev/docs/checks/#SA9009
+        - SA9009
+        # Incorrect or missing package comment.
+        # https://staticcheck.dev/docs/checks/#ST1000
+        - ST1000
+        # Dot imports are discouraged.
+        # https://staticcheck.dev/docs/checks/#ST1001
+        - ST1001
+        # Poorly chosen identifier.
+        # https://staticcheck.dev/docs/checks/#ST1003
+        - ST1003
+        # Incorrectly formatted error string.
+        # https://staticcheck.dev/docs/checks/#ST1005
+        - ST1005
+        # Poorly chosen receiver name.
+        # https://staticcheck.dev/docs/checks/#ST1006
+        - ST1006
+        # A function's error value should be its last return value.
+        # https://staticcheck.dev/docs/checks/#ST1008
+        - ST1008
+        # Poorly chosen name for variable of type 'time.Duration'.
+        # https://staticcheck.dev/docs/checks/#ST1011
+        - ST1011
+        # Poorly chosen name for error variable.
+        # https://staticcheck.dev/docs/checks/#ST1012
+        - ST1012
+        # Should use constants for HTTP error codes, not magic numbers.
+        # https://staticcheck.dev/docs/checks/#ST1013
+        - ST1013
+        # A switch's default case should be the first or last case.
+        # https://staticcheck.dev/docs/checks/#ST1015
+        - ST1015
+        # Use consistent method receiver names.
+        # https://staticcheck.dev/docs/checks/#ST1016
+        - ST1016
+        # Don't use Yoda conditions.
+        # https://staticcheck.dev/docs/checks/#ST1017
+        - ST1017
+        # Avoid zero-width and control characters in string literals.
+        # https://staticcheck.dev/docs/checks/#ST1018
+        - ST1018
+        # Importing the same package multiple times.
+        # https://staticcheck.dev/docs/checks/#ST1019
+        - ST1019
+        # The documentation of an exported function should start with the function's name.
+        # https://staticcheck.dev/docs/checks/#ST1020
+        - ST1020
+        # The documentation of an exported type should start with type's name.
+        # https://staticcheck.dev/docs/checks/#ST1021
+        - ST1021
+        # The documentation of an exported variable or constant should start with variable's name.
+        # https://staticcheck.dev/docs/checks/#ST1022
+        - ST1022
+        # Redundant type in variable declaration.
+        # https://staticcheck.dev/docs/checks/#ST1023
+        - ST1023
+        # Use plain channel send or receive instead of single-case select.
+        # https://staticcheck.dev/docs/checks/#S1000
+        - S1000
+        # Replace for loop with call to copy.
+        # https://staticcheck.dev/docs/checks/#S1001
+        - S1001
+        # Omit comparison with boolean constant.
+        # https://staticcheck.dev/docs/checks/#S1002
+        - S1002
+        # Replace call to 'strings.Index' with 'strings.Contains'.
+        # https://staticcheck.dev/docs/checks/#S1003
+        - S1003
+        # Replace call to 'bytes.Compare' with 'bytes.Equal'.
+        # https://staticcheck.dev/docs/checks/#S1004
+        - S1004
+        # Drop unnecessary use of the blank identifier.
+        # https://staticcheck.dev/docs/checks/#S1005
+        - S1005
+        # Use "for { ... }" for infinite loops.
+        # https://staticcheck.dev/docs/checks/#S1006
+        - S1006
+        # Simplify regular expression by using raw string literal.
+        # https://staticcheck.dev/docs/checks/#S1007
+        - S1007
+        # Simplify returning boolean expression.
+        # https://staticcheck.dev/docs/checks/#S1008
+        - S1008
+        # Omit redundant nil check on slices, maps, and channels.
+        # https://staticcheck.dev/docs/checks/#S1009
+        - S1009
+        # Omit default slice index.
+        # https://staticcheck.dev/docs/checks/#S1010
+        - S1010
+        # Use a single 'append' to concatenate two slices.
+        # https://staticcheck.dev/docs/checks/#S1011
+        - S1011
+        # Replace 'time.Now().Sub(x)' with 'time.Since(x)'.
+        # https://staticcheck.dev/docs/checks/#S1012
+        - S1012
+        # Use a type conversion instead of manually copying struct fields.
+        # https://staticcheck.dev/docs/checks/#S1016
+        - S1016
+        # Replace manual trimming with 'strings.TrimPrefix'.
+        # https://staticcheck.dev/docs/checks/#S1017
+        - S1017
+        # Use "copy" for sliding elements.
+        # https://staticcheck.dev/docs/checks/#S1018
+        - S1018
+        # Simplify "make" call by omitting redundant arguments.
+        # https://staticcheck.dev/docs/checks/#S1019
+        - S1019
+        # Omit redundant nil check in type assertion.
+        # https://staticcheck.dev/docs/checks/#S1020
+        - S1020
+        # Merge variable declaration and assignment.
+        # https://staticcheck.dev/docs/checks/#S1021
+        - S1021
+        # Omit redundant control flow.
+        # https://staticcheck.dev/docs/checks/#S1023
+        - S1023
+        # Replace 'x.Sub(time.Now())' with 'time.Until(x)'.
+        # https://staticcheck.dev/docs/checks/#S1024
+        - S1024
+        # Don't use 'fmt.Sprintf("%s", x)' unnecessarily.
+        # https://staticcheck.dev/docs/checks/#S1025
+        - S1025
+        # Simplify error construction with 'fmt.Errorf'.
+        # https://staticcheck.dev/docs/checks/#S1028
+        - S1028
+        # Range over the string directly.
+        # https://staticcheck.dev/docs/checks/#S1029
+        - S1029
+        # Use 'bytes.Buffer.String' or 'bytes.Buffer.Bytes'.
+        # https://staticcheck.dev/docs/checks/#S1030
+        - S1030
+        # Omit redundant nil check around loop.
+        # https://staticcheck.dev/docs/checks/#S1031
+        - S1031
+        # Use 'sort.Ints(x)', 'sort.Float64s(x)', and 'sort.Strings(x)'.
+        # https://staticcheck.dev/docs/checks/#S1032
+        - S1032
+        # Unnecessary guard around call to "delete".
+        # https://staticcheck.dev/docs/checks/#S1033
+        - S1033
+        # Use result of type assertion to simplify cases.
+        # https://staticcheck.dev/docs/checks/#S1034
+        - S1034
+        # Redundant call to 'net/http.CanonicalHeaderKey' in method call on 'net/http.Header'.
+        # https://staticcheck.dev/docs/checks/#S1035
+        - S1035
+        # Unnecessary guard around map access.
+        # https://staticcheck.dev/docs/checks/#S1036
+        - S1036
+        # Elaborate way of sleeping.
+        # https://staticcheck.dev/docs/checks/#S1037
+        - S1037
+        # Unnecessarily complex way of printing formatted string.
+        # https://staticcheck.dev/docs/checks/#S1038
+        - S1038
+        # Unnecessary use of 'fmt.Sprint'.
+        # https://staticcheck.dev/docs/checks/#S1039
+        - S1039
+        # Type assertion to current type.
+        # https://staticcheck.dev/docs/checks/#S1040
+        - S1040
+        # Apply De Morgan's law.
+        # https://staticcheck.dev/docs/checks/#QF1001
+        - QF1001
+        # Convert untagged switch to tagged switch.
+        # https://staticcheck.dev/docs/checks/#QF1002
+        - QF1002
+        # Convert if/else-if chain to tagged switch.
+        # https://staticcheck.dev/docs/checks/#QF1003
+        - QF1003
+        # Use 'strings.ReplaceAll' instead of 'strings.Replace' with 'n == -1'.
+        # https://staticcheck.dev/docs/checks/#QF1004
+        - QF1004
+        # Expand call to 'math.Pow'.
+        # https://staticcheck.dev/docs/checks/#QF1005
+        - QF1005
+        # Lift 'if'+'break' into loop condition.
+        # https://staticcheck.dev/docs/checks/#QF1006
+        - QF1006
+        # Merge conditional assignment into variable declaration.
+        # https://staticcheck.dev/docs/checks/#QF1007
+        - QF1007
+        # Omit embedded fields from selector expression.
+        # https://staticcheck.dev/docs/checks/#QF1008
+        - QF1008
+        # Use 'time.Time.Equal' instead of '==' operator.
+        # https://staticcheck.dev/docs/checks/#QF1009
+        - QF1009
+        # Convert slice of bytes to string when printing it.
+        # https://staticcheck.dev/docs/checks/#QF1010
+        - QF1010
+        # Omit redundant type from variable declaration.
+        # https://staticcheck.dev/docs/checks/#QF1011
+        - QF1011
+        # Use 'fmt.Fprintf(x, ...)' instead of 'x.Write(fmt.Sprintf(...))'.
+        # https://staticcheck.dev/docs/checks/#QF1012
+        - QF1012
     unused:
+      # Mark all struct fields that have been written to as used.
       # Default: true
-      field-writes-are-uses: true
+      field-writes-are-uses: false
+      # Treat IncDec statement (e.g. `i++` or `i--`) as both read and write operation instead of just write.
       # Default: false
       post-statements-are-reads: true
-      # Default: true
-      exported-fields-are-used: true
-      # Default: true
+      # Mark all exported fields as used.
+      # default: true
+      exported-fields-are-used: false
+      # Mark all function parameters as used.
+      # default: true
       parameters-are-used: true
-      # Default: true
+      # Mark all local variables as used.
+      # default: true
       local-variables-are-used: false
-      # Default: true — must be true, ent generates 130K+ lines of code
-      generated-is-used: true
+      # Mark all identifiers inside generated files as used.
+      # Default: true
+      generated-is-used: false
 
 formatters:
   enable:

backend/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.25.7-alpine
+FROM golang:1.21-alpine
 
 WORKDIR /app
 
@@ -15,7 +15,7 @@ RUN go mod download
 COPY . .
 
 # 构建应用
-RUN go build -o main ./cmd/server/
+RUN go build -o main cmd/server/main.go
 
 # 暴露端口
 EXPOSE 8080

backend/Makefile

@@ -1,18 +1,7 @@
-.PHONY: build generate test test-unit test-integration test-e2e
-
-VERSION ?= $(shell tr -d '\r\n' < ./cmd/server/VERSION)
-LDFLAGS ?= -s -w -X main.Version=$(VERSION)
+.PHONY: build test-unit test-integration test-e2e
 
 build:
-	CGO_ENABLED=0 go build -ldflags="$(LDFLAGS)" -trimpath -o bin/server ./cmd/server
-
-generate:
-	go generate ./ent
-	go generate ./cmd/server
-
-test:
-	go test ./...
-	golangci-lint run ./...
+	go build -o bin/server ./cmd/server
 
 test-unit:
 	go test -tags=unit ./...
@@ -21,7 +10,4 @@ test-integration:
 	go test -tags=integration ./...
 
 test-e2e:
-	./scripts/e2e-test.sh
-
-test-e2e-local:
-	go test -tags=e2e -v -timeout=300s ./internal/integration/...
+	go test -tags=e2e ./...

backend/cmd/jwtgen/main.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"time"
-
-	_ "github.com/Wei-Shaw/sub2api/ent/runtime"
-	"github.com/Wei-Shaw/sub2api/internal/config"
-	"github.com/Wei-Shaw/sub2api/internal/repository"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func main() {
-	email := flag.String("email", "", "Admin email to issue a JWT for (defaults to first active admin)")
-	flag.Parse()
-
-	cfg, err := config.LoadForBootstrap()
-	if err != nil {
-		log.Fatalf("failed to load config: %v", err)
-	}
-
-	client, sqlDB, err := repository.InitEnt(cfg)
-	if err != nil {
-		log.Fatalf("failed to init db: %v", err)
-	}
-	defer func() {
-		if err := client.Close(); err != nil {
-			log.Printf("failed to close db: %v", err)
-		}
-	}()
-
-	userRepo := repository.NewUserRepository(client, sqlDB)
-	authService := service.NewAuthService(client, userRepo, nil, nil, cfg, nil, nil, nil, nil, nil, nil)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	var user *service.User
-	if *email != "" {
-		user, err = userRepo.GetByEmail(ctx, *email)
-	} else {
-		user, err = userRepo.GetFirstAdmin(ctx)
-	}
-	if err != nil {
-		log.Fatalf("failed to resolve admin user: %v", err)
-	}
-
-	token, err := authService.GenerateToken(user)
-	if err != nil {
-		log.Fatalf("failed to generate token: %v", err)
-	}
-
-	fmt.Printf("ADMIN_EMAIL=%s\nADMIN_USER_ID=%d\nJWT=%s\n", user.Email, user.ID, token)
-}

backend/cmd/server/VERSION

@@ -1 +1 @@
-0.1.88
+0.1.1

backend/cmd/server/main.go

@@ -18,14 +18,11 @@ import (
 	_ "github.com/Wei-Shaw/sub2api/ent/runtime"
 	"github.com/Wei-Shaw/sub2api/internal/config"
 	"github.com/Wei-Shaw/sub2api/internal/handler"
-	"github.com/Wei-Shaw/sub2api/internal/pkg/logger"
 	"github.com/Wei-Shaw/sub2api/internal/server/middleware"
 	"github.com/Wei-Shaw/sub2api/internal/setup"
 	"github.com/Wei-Shaw/sub2api/internal/web"
 
 	"github.com/gin-gonic/gin"
-	"golang.org/x/net/http2"
-	"golang.org/x/net/http2/h2c"
 )
 
 //go:embed VERSION
@@ -40,24 +37,14 @@ var (
 )
 
 func init() {
-	// 如果 Version 已通过 ldflags 注入（例如 -X main.Version=...），则不要覆盖。
-	if strings.TrimSpace(Version) != "" {
-		return
-	}
-
-	// 默认从 embedded VERSION 文件读取版本号（编译期打包进二进制）。
+	// Read version from embedded VERSION file
 	Version = strings.TrimSpace(embeddedVersion)
 	if Version == "" {
 		Version = "0.0.0-dev"
 	}
 }
 
-// initLogger configures the default slog handler based on gin.Mode().
-// In non-release mode, Debug level logs are enabled.
 func main() {
-	logger.InitBootstrap()
-	defer logger.Sync()
-
 	// Parse command line flags
 	setupMode := flag.Bool("setup", false, "Run setup wizard in CLI mode")
 	showVersion := flag.Bool("version", false, "Show version information")
@@ -99,8 +86,7 @@ func main() {
 func runSetupServer() {
 	r := gin.New()
 	r.Use(middleware.Recovery())
-	r.Use(middleware.CORS(config.CORSConfig{}))
-	r.Use(middleware.SecurityHeaders(config.CSPConfig{Enabled: true, Policy: config.DefaultCSPPolicy}, nil))
+	r.Use(middleware.CORS())
 
 	// Register setup routes
 	setup.RegisterRoutes(r)
@@ -116,26 +102,16 @@ func runSetupServer() {
 	log.Printf("Setup wizard available at http://%s", addr)
 	log.Println("Complete the setup wizard to configure Sub2API")
 
-	server := &http.Server{
-		Addr:              addr,
-		Handler:           h2c.NewHandler(r, &http2.Server{}),
-		ReadHeaderTimeout: 30 * time.Second,
-		IdleTimeout:       120 * time.Second,
-	}
-
-	if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+	if err := r.Run(addr); err != nil {
 		log.Fatalf("Failed to start setup server: %v", err)
 	}
 }
 
 func runMainServer() {
-	cfg, err := config.LoadForBootstrap()
+	cfg, err := config.Load()
 	if err != nil {
 		log.Fatalf("Failed to load config: %v", err)
 	}
-	if err := logger.Init(logger.OptionsFromConfig(cfg.Log)); err != nil {
-		log.Fatalf("Failed to initialize logger: %v", err)
-	}
 	if cfg.RunMode == config.RunModeSimple {
 		log.Println("⚠️  WARNING: Running in SIMPLE mode - billing and quota checks are DISABLED")
 	}

backend/cmd/server/wire.go

@@ -7,7 +7,6 @@ import (
 	"context"
 	"log"
 	"net/http"
-	"sync"
 	"time"
 
 	"github.com/Wei-Shaw/sub2api/ent"
@@ -63,120 +62,29 @@ func provideServiceBuildInfo(buildInfo handler.BuildInfo) service.BuildInfo {
 func provideCleanup(
 	entClient *ent.Client,
 	rdb *redis.Client,
-	opsMetricsCollector *service.OpsMetricsCollector,
-	opsAggregation *service.OpsAggregationService,
-	opsAlertEvaluator *service.OpsAlertEvaluatorService,
-	opsCleanup *service.OpsCleanupService,
-	opsScheduledReport *service.OpsScheduledReportService,
-	opsSystemLogSink *service.OpsSystemLogSink,
-	soraMediaCleanup *service.SoraMediaCleanupService,
-	schedulerSnapshot *service.SchedulerSnapshotService,
 	tokenRefresh *service.TokenRefreshService,
-	accountExpiry *service.AccountExpiryService,
-	subscriptionExpiry *service.SubscriptionExpiryService,
-	usageCleanup *service.UsageCleanupService,
-	idempotencyCleanup *service.IdempotencyCleanupService,
 	pricing *service.PricingService,
 	emailQueue *service.EmailQueueService,
 	billingCache *service.BillingCacheService,
-	usageRecordWorkerPool *service.UsageRecordWorkerPool,
-	subscriptionService *service.SubscriptionService,
 	oauth *service.OAuthService,
 	openaiOAuth *service.OpenAIOAuthService,
 	geminiOAuth *service.GeminiOAuthService,
 	antigravityOAuth *service.AntigravityOAuthService,
-	openAIGateway *service.OpenAIGatewayService,
-	scheduledTestRunner *service.ScheduledTestRunnerService,
+	antigravityQuota *service.AntigravityQuotaRefresher,
 ) func() {
 	return func() {
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 
-		type cleanupStep struct {
+		// Cleanup steps in reverse dependency order
+		cleanupSteps := []struct {
 			name string
 			fn   func() error
-		}
-
-		// 应用层清理步骤可并行执行，基础设施资源（Redis/Ent）最后按顺序关闭。
-		parallelSteps := []cleanupStep{
-			{"OpsScheduledReportService", func() error {
-				if opsScheduledReport != nil {
-					opsScheduledReport.Stop()
-				}
-				return nil
-			}},
-			{"OpsCleanupService", func() error {
-				if opsCleanup != nil {
-					opsCleanup.Stop()
-				}
-				return nil
-			}},
-			{"OpsSystemLogSink", func() error {
-				if opsSystemLogSink != nil {
-					opsSystemLogSink.Stop()
-				}
-				return nil
-			}},
-			{"SoraMediaCleanupService", func() error {
-				if soraMediaCleanup != nil {
-					soraMediaCleanup.Stop()
-				}
-				return nil
-			}},
-			{"OpsAlertEvaluatorService", func() error {
-				if opsAlertEvaluator != nil {
-					opsAlertEvaluator.Stop()
-				}
-				return nil
-			}},
-			{"OpsAggregationService", func() error {
-				if opsAggregation != nil {
-					opsAggregation.Stop()
-				}
-				return nil
-			}},
-			{"OpsMetricsCollector", func() error {
-				if opsMetricsCollector != nil {
-					opsMetricsCollector.Stop()
-				}
-				return nil
-			}},
-			{"SchedulerSnapshotService", func() error {
-				if schedulerSnapshot != nil {
-					schedulerSnapshot.Stop()
-				}
-				return nil
-			}},
-			{"UsageCleanupService", func() error {
-				if usageCleanup != nil {
-					usageCleanup.Stop()
-				}
-				return nil
-			}},
-			{"IdempotencyCleanupService", func() error {
-				if idempotencyCleanup != nil {
-					idempotencyCleanup.Stop()
-				}
-				return nil
-			}},
+		}{
 			{"TokenRefreshService", func() error {
 				tokenRefresh.Stop()
 				return nil
 			}},
-			{"AccountExpiryService", func() error {
-				accountExpiry.Stop()
-				return nil
-			}},
-			{"SubscriptionExpiryService", func() error {
-				subscriptionExpiry.Stop()
-				return nil
-			}},
-			{"SubscriptionService", func() error {
-				if subscriptionService != nil {
-					subscriptionService.Stop()
-				}
-				return nil
-			}},
 			{"PricingService", func() error {
 				pricing.Stop()
 				return nil
@@ -189,12 +97,6 @@ func provideCleanup(
 				billingCache.Stop()
 				return nil
 			}},
-			{"UsageRecordWorkerPool", func() error {
-				if usageRecordWorkerPool != nil {
-					usageRecordWorkerPool.Stop()
-				}
-				return nil
-			}},
 			{"OAuthService", func() error {
 				oauth.Stop()
 				return nil
@@ -211,66 +113,27 @@ func provideCleanup(
 				antigravityOAuth.Stop()
 				return nil
 			}},
-			{"OpenAIWSPool", func() error {
-				if openAIGateway != nil {
-					openAIGateway.CloseOpenAIWSPool()
-				}
+			{"AntigravityQuotaRefresher", func() error {
+				antigravityQuota.Stop()
 				return nil
 			}},
-			{"ScheduledTestRunnerService", func() error {
-				if scheduledTestRunner != nil {
-					scheduledTestRunner.Stop()
-				}
-				return nil
-			}},
-		}
-
-		infraSteps := []cleanupStep{
 			{"Redis", func() error {
-				if rdb == nil {
-					return nil
-				}
 				return rdb.Close()
 			}},
 			{"Ent", func() error {
-				if entClient == nil {
-					return nil
-				}
 				return entClient.Close()
 			}},
 		}
 
-		runParallel := func(steps []cleanupStep) {
-			var wg sync.WaitGroup
-			for i := range steps {
-				step := steps[i]
-				wg.Add(1)
-				go func() {
-					defer wg.Done()
-					if err := step.fn(); err != nil {
-						log.Printf("[Cleanup] %s failed: %v", step.name, err)
-						return
-					}
-					log.Printf("[Cleanup] %s succeeded", step.name)
-				}()
-			}
-			wg.Wait()
-		}
-
-		runSequential := func(steps []cleanupStep) {
-			for i := range steps {
-				step := steps[i]
-				if err := step.fn(); err != nil {
-					log.Printf("[Cleanup] %s failed: %v", step.name, err)
-					continue
-				}
+		for _, step := range cleanupSteps {
+			if err := step.fn(); err != nil {
+				log.Printf("[Cleanup] %s failed: %v", step.name, err)
+				// Continue with remaining cleanup steps even if one fails
+			} else {
 				log.Printf("[Cleanup] %s succeeded", step.name)
 			}
 		}
 
-		runParallel(parallelSteps)
-		runSequential(infraSteps)
-
 		// Check if context timed out
 		select {
 		case <-ctx.Done():

backend/cmd/server/wire_gen.go

@@ -19,7 +19,6 @@ import (
 	"github.com/redis/go-redis/v9"
 	"log"
 	"net/http"
-	"sync"
 	"time"
 )
 
@@ -44,70 +43,42 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 		return nil, err
 	}
 	userRepository := repository.NewUserRepository(client, db)
-	redeemCodeRepository := repository.NewRedeemCodeRepository(client)
-	redisClient := repository.ProvideRedis(configConfig)
-	refreshTokenCache := repository.NewRefreshTokenCache(redisClient)
 	settingRepository := repository.NewSettingRepository(client)
-	groupRepository := repository.NewGroupRepository(client, db)
-	settingService := service.ProvideSettingService(settingRepository, groupRepository, configConfig)
+	settingService := service.NewSettingService(settingRepository, configConfig)
+	redisClient := repository.ProvideRedis(configConfig)
 	emailCache := repository.NewEmailCache(redisClient)
 	emailService := service.NewEmailService(settingRepository, emailCache)
 	turnstileVerifier := repository.NewTurnstileVerifier()
 	turnstileService := service.NewTurnstileService(settingService, turnstileVerifier)
 	emailQueueService := service.ProvideEmailQueueService(emailService)
-	promoCodeRepository := repository.NewPromoCodeRepository(client)
-	billingCache := repository.NewBillingCache(redisClient)
-	userSubscriptionRepository := repository.NewUserSubscriptionRepository(client)
-	apiKeyRepository := repository.NewAPIKeyRepository(client, db)
-	billingCacheService := service.NewBillingCacheService(billingCache, userRepository, userSubscriptionRepository, apiKeyRepository, configConfig)
-	userGroupRateRepository := repository.NewUserGroupRateRepository(db)
-	apiKeyCache := repository.NewAPIKeyCache(redisClient)
-	apiKeyService := service.NewAPIKeyService(apiKeyRepository, userRepository, groupRepository, userSubscriptionRepository, userGroupRateRepository, apiKeyCache, configConfig)
-	apiKeyService.SetRateLimitCacheInvalidator(billingCache)
-	apiKeyAuthCacheInvalidator := service.ProvideAPIKeyAuthCacheInvalidator(apiKeyService)
-	promoService := service.NewPromoService(promoCodeRepository, userRepository, billingCacheService, client, apiKeyAuthCacheInvalidator)
-	subscriptionService := service.NewSubscriptionService(groupRepository, userSubscriptionRepository, billingCacheService, client, configConfig)
-	authService := service.NewAuthService(client, userRepository, redeemCodeRepository, refreshTokenCache, configConfig, settingService, emailService, turnstileService, emailQueueService, promoService, subscriptionService)
-	userService := service.NewUserService(userRepository, apiKeyAuthCacheInvalidator, billingCache)
-	redeemCache := repository.NewRedeemCache(redisClient)
-	redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client, apiKeyAuthCacheInvalidator)
-	secretEncryptor, err := repository.NewAESEncryptor(configConfig)
-	if err != nil {
-		return nil, err
-	}
-	totpCache := repository.NewTotpCache(redisClient)
-	totpService := service.NewTotpService(userRepository, secretEncryptor, totpCache, settingService, emailService, emailQueueService)
-	authHandler := handler.NewAuthHandler(configConfig, authService, userService, settingService, promoService, redeemService, totpService)
+	authService := service.NewAuthService(userRepository, configConfig, settingService, emailService, turnstileService, emailQueueService)
+	userService := service.NewUserService(userRepository)
+	authHandler := handler.NewAuthHandler(configConfig, authService, userService)
 	userHandler := handler.NewUserHandler(userService)
+	apiKeyRepository := repository.NewApiKeyRepository(client)
+	groupRepository := repository.NewGroupRepository(client, db)
+	userSubscriptionRepository := repository.NewUserSubscriptionRepository(client)
+	apiKeyCache := repository.NewApiKeyCache(redisClient)
+	apiKeyService := service.NewApiKeyService(apiKeyRepository, userRepository, groupRepository, userSubscriptionRepository, apiKeyCache, configConfig)
 	apiKeyHandler := handler.NewAPIKeyHandler(apiKeyService)
 	usageLogRepository := repository.NewUsageLogRepository(client, db)
-	usageService := service.NewUsageService(usageLogRepository, userRepository, client, apiKeyAuthCacheInvalidator)
+	usageService := service.NewUsageService(usageLogRepository, userRepository)
 	usageHandler := handler.NewUsageHandler(usageService, apiKeyService)
+	redeemCodeRepository := repository.NewRedeemCodeRepository(client)
+	billingCache := repository.NewBillingCache(redisClient)
+	billingCacheService := service.NewBillingCacheService(billingCache, userRepository, userSubscriptionRepository, configConfig)
+	subscriptionService := service.NewSubscriptionService(groupRepository, userSubscriptionRepository, billingCacheService)
+	redeemCache := repository.NewRedeemCache(redisClient)
+	redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client)
 	redeemHandler := handler.NewRedeemHandler(redeemService)
 	subscriptionHandler := handler.NewSubscriptionHandler(subscriptionService)
-	announcementRepository := repository.NewAnnouncementRepository(client)
-	announcementReadRepository := repository.NewAnnouncementReadRepository(client)
-	announcementService := service.NewAnnouncementService(announcementRepository, announcementReadRepository, userRepository, userSubscriptionRepository)
-	announcementHandler := handler.NewAnnouncementHandler(announcementService)
-	dashboardAggregationRepository := repository.NewDashboardAggregationRepository(db)
-	dashboardStatsCache := repository.NewDashboardCache(redisClient, configConfig)
-	dashboardService := service.NewDashboardService(usageLogRepository, dashboardAggregationRepository, dashboardStatsCache, configConfig)
-	timingWheelService, err := service.ProvideTimingWheelService()
-	if err != nil {
-		return nil, err
-	}
-	dashboardAggregationService := service.ProvideDashboardAggregationService(dashboardAggregationRepository, timingWheelService, configConfig)
-	dashboardHandler := admin.NewDashboardHandler(dashboardService, dashboardAggregationService)
-	schedulerCache := repository.NewSchedulerCache(redisClient)
-	accountRepository := repository.NewAccountRepository(client, db, schedulerCache)
-	soraAccountRepository := repository.NewSoraAccountRepository(db)
+	dashboardService := service.NewDashboardService(usageLogRepository)
+	dashboardHandler := admin.NewDashboardHandler(dashboardService)
+	accountRepository := repository.NewAccountRepository(client, db)
 	proxyRepository := repository.NewProxyRepository(client, db)
-	proxyExitInfoProber := repository.NewProxyExitInfoProber(configConfig)
-	proxyLatencyCache := repository.NewProxyLatencyCache(redisClient)
-	adminService := service.NewAdminService(userRepository, groupRepository, accountRepository, soraAccountRepository, proxyRepository, apiKeyRepository, redeemCodeRepository, userGroupRateRepository, billingCacheService, proxyExitInfoProber, proxyLatencyCache, apiKeyAuthCacheInvalidator, client, settingService, subscriptionService, userSubscriptionRepository)
-	concurrencyCache := repository.ProvideConcurrencyCache(redisClient, configConfig)
-	concurrencyService := service.ProvideConcurrencyService(concurrencyCache, accountRepository, configConfig)
-	adminUserHandler := admin.NewUserHandler(adminService, concurrencyService)
+	proxyExitInfoProber := repository.NewProxyExitInfoProber()
+	adminService := service.NewAdminService(userRepository, groupRepository, accountRepository, proxyRepository, apiKeyRepository, redeemCodeRepository, billingCacheService, proxyExitInfoProber)
+	adminUserHandler := admin.NewUserHandler(adminService)
 	groupHandler := admin.NewGroupHandler(adminService)
 	claudeOAuthClient := repository.NewClaudeOAuthClient()
 	oAuthService := service.NewOAuthService(proxyRepository, claudeOAuthClient)
@@ -115,122 +86,62 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	openAIOAuthService := service.NewOpenAIOAuthService(proxyRepository, openAIOAuthClient)
 	geminiOAuthClient := repository.NewGeminiOAuthClient(configConfig)
 	geminiCliCodeAssistClient := repository.NewGeminiCliCodeAssistClient()
-	driveClient := repository.NewGeminiDriveClient()
-	geminiOAuthService := service.NewGeminiOAuthService(proxyRepository, geminiOAuthClient, geminiCliCodeAssistClient, driveClient, configConfig)
-	antigravityOAuthService := service.NewAntigravityOAuthService(proxyRepository)
-	geminiQuotaService := service.NewGeminiQuotaService(configConfig, settingRepository)
-	tempUnschedCache := repository.NewTempUnschedCache(redisClient)
-	timeoutCounterCache := repository.NewTimeoutCounterCache(redisClient)
+	geminiOAuthService := service.NewGeminiOAuthService(proxyRepository, geminiOAuthClient, geminiCliCodeAssistClient, configConfig)
+	rateLimitService := service.NewRateLimitService(accountRepository, configConfig)
+	claudeUsageFetcher := repository.NewClaudeUsageFetcher()
+	accountUsageService := service.NewAccountUsageService(accountRepository, usageLogRepository, claudeUsageFetcher)
 	geminiTokenCache := repository.NewGeminiTokenCache(redisClient)
-	compositeTokenCacheInvalidator := service.NewCompositeTokenCacheInvalidator(geminiTokenCache)
-	rateLimitService := service.ProvideRateLimitService(accountRepository, usageLogRepository, configConfig, geminiQuotaService, tempUnschedCache, timeoutCounterCache, settingService, compositeTokenCacheInvalidator)
-	httpUpstream := repository.NewHTTPUpstream(configConfig)
-	claudeUsageFetcher := repository.NewClaudeUsageFetcher(httpUpstream)
-	antigravityQuotaFetcher := service.NewAntigravityQuotaFetcher(proxyRepository)
-	usageCache := service.NewUsageCache()
-	identityCache := repository.NewIdentityCache(redisClient)
-	accountUsageService := service.NewAccountUsageService(accountRepository, usageLogRepository, claudeUsageFetcher, geminiQuotaService, antigravityQuotaFetcher, usageCache, identityCache)
 	geminiTokenProvider := service.NewGeminiTokenProvider(accountRepository, geminiTokenCache, geminiOAuthService)
 	gatewayCache := repository.NewGatewayCache(redisClient)
-	schedulerOutboxRepository := repository.NewSchedulerOutboxRepository(db)
-	schedulerSnapshotService := service.ProvideSchedulerSnapshotService(schedulerCache, schedulerOutboxRepository, accountRepository, groupRepository, configConfig)
+	antigravityOAuthService := service.NewAntigravityOAuthService(proxyRepository)
 	antigravityTokenProvider := service.NewAntigravityTokenProvider(accountRepository, geminiTokenCache, antigravityOAuthService)
-	antigravityGatewayService := service.NewAntigravityGatewayService(accountRepository, gatewayCache, schedulerSnapshotService, antigravityTokenProvider, rateLimitService, httpUpstream, settingService)
-	accountTestService := service.NewAccountTestService(accountRepository, geminiTokenProvider, antigravityGatewayService, httpUpstream, configConfig)
-	crsSyncService := service.NewCRSSyncService(accountRepository, proxyRepository, oAuthService, openAIOAuthService, geminiOAuthService, configConfig)
-	sessionLimitCache := repository.ProvideSessionLimitCache(redisClient, configConfig)
-	rpmCache := repository.NewRPMCache(redisClient)
-	accountHandler := admin.NewAccountHandler(adminService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, rateLimitService, accountUsageService, accountTestService, concurrencyService, crsSyncService, sessionLimitCache, rpmCache, compositeTokenCacheInvalidator)
-	adminAnnouncementHandler := admin.NewAnnouncementHandler(announcementService)
-	dataManagementService := service.NewDataManagementService()
-	dataManagementHandler := admin.NewDataManagementHandler(dataManagementService)
+	httpUpstream := repository.NewHTTPUpstream(configConfig)
+	antigravityGatewayService := service.NewAntigravityGatewayService(accountRepository, gatewayCache, antigravityTokenProvider, rateLimitService, httpUpstream)
+	accountTestService := service.NewAccountTestService(accountRepository, oAuthService, openAIOAuthService, geminiTokenProvider, antigravityGatewayService, httpUpstream)
+	concurrencyCache := repository.ProvideConcurrencyCache(redisClient, configConfig)
+	concurrencyService := service.NewConcurrencyService(concurrencyCache)
+	crsSyncService := service.NewCRSSyncService(accountRepository, proxyRepository, oAuthService, openAIOAuthService, geminiOAuthService)
+	accountHandler := admin.NewAccountHandler(adminService, oAuthService, openAIOAuthService, geminiOAuthService, rateLimitService, accountUsageService, accountTestService, concurrencyService, crsSyncService)
 	oAuthHandler := admin.NewOAuthHandler(oAuthService)
 	openAIOAuthHandler := admin.NewOpenAIOAuthHandler(openAIOAuthService, adminService)
 	geminiOAuthHandler := admin.NewGeminiOAuthHandler(geminiOAuthService)
 	antigravityOAuthHandler := admin.NewAntigravityOAuthHandler(antigravityOAuthService)
 	proxyHandler := admin.NewProxyHandler(adminService)
-	adminRedeemHandler := admin.NewRedeemHandler(adminService, redeemService)
-	promoHandler := admin.NewPromoHandler(promoService)
-	opsRepository := repository.NewOpsRepository(db)
-	pricingRemoteClient := repository.ProvidePricingRemoteClient(configConfig)
+	adminRedeemHandler := admin.NewRedeemHandler(adminService)
+	settingHandler := admin.NewSettingHandler(settingService, emailService, turnstileService)
+	updateCache := repository.NewUpdateCache(redisClient)
+	gitHubReleaseClient := repository.NewGitHubReleaseClient()
+	serviceBuildInfo := provideServiceBuildInfo(buildInfo)
+	updateService := service.ProvideUpdateService(updateCache, gitHubReleaseClient, serviceBuildInfo)
+	systemHandler := handler.ProvideSystemHandler(updateService)
+	adminSubscriptionHandler := admin.NewSubscriptionHandler(subscriptionService)
+	adminUsageHandler := admin.NewUsageHandler(usageService, apiKeyService, adminService)
+	adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, settingHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler)
+	pricingRemoteClient := repository.NewPricingRemoteClient()
 	pricingService, err := service.ProvidePricingService(configConfig, pricingRemoteClient)
 	if err != nil {
 		return nil, err
 	}
 	billingService := service.NewBillingService(configConfig, pricingService)
+	identityCache := repository.NewIdentityCache(redisClient)
 	identityService := service.NewIdentityService(identityCache)
+	timingWheelService := service.ProvideTimingWheelService()
 	deferredService := service.ProvideDeferredService(accountRepository, timingWheelService)
-	claudeTokenProvider := service.NewClaudeTokenProvider(accountRepository, geminiTokenCache, oAuthService)
-	digestSessionStore := service.NewDigestSessionStore()
-	gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, userRepository, userSubscriptionRepository, userGroupRateRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService, claudeTokenProvider, sessionLimitCache, rpmCache, digestSessionStore, settingService)
-	openAITokenProvider := service.NewOpenAITokenProvider(accountRepository, geminiTokenCache, openAIOAuthService)
-	openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, userRepository, userSubscriptionRepository, userGroupRateRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService, openAITokenProvider)
-	geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, schedulerSnapshotService, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService, configConfig)
-	opsSystemLogSink := service.ProvideOpsSystemLogSink(opsRepository)
-	opsService := service.NewOpsService(opsRepository, settingRepository, configConfig, accountRepository, userRepository, concurrencyService, gatewayService, openAIGatewayService, geminiMessagesCompatService, antigravityGatewayService, opsSystemLogSink)
-	soraS3Storage := service.NewSoraS3Storage(settingService)
-	settingService.SetOnS3UpdateCallback(soraS3Storage.RefreshClient)
-	soraGenerationRepository := repository.NewSoraGenerationRepository(db)
-	soraQuotaService := service.NewSoraQuotaService(userRepository, groupRepository, settingService)
-	soraGenerationService := service.NewSoraGenerationService(soraGenerationRepository, soraS3Storage, soraQuotaService)
-	settingHandler := admin.NewSettingHandler(settingService, emailService, turnstileService, opsService, soraS3Storage)
-	opsHandler := admin.NewOpsHandler(opsService)
-	updateCache := repository.NewUpdateCache(redisClient)
-	gitHubReleaseClient := repository.ProvideGitHubReleaseClient(configConfig)
-	serviceBuildInfo := provideServiceBuildInfo(buildInfo)
-	updateService := service.ProvideUpdateService(updateCache, gitHubReleaseClient, serviceBuildInfo)
-	idempotencyRepository := repository.NewIdempotencyRepository(client, db)
-	systemOperationLockService := service.ProvideSystemOperationLockService(idempotencyRepository, configConfig)
-	systemHandler := handler.ProvideSystemHandler(updateService, systemOperationLockService)
-	adminSubscriptionHandler := admin.NewSubscriptionHandler(subscriptionService)
-	usageCleanupRepository := repository.NewUsageCleanupRepository(client, db)
-	usageCleanupService := service.ProvideUsageCleanupService(usageCleanupRepository, timingWheelService, dashboardAggregationService, configConfig)
-	adminUsageHandler := admin.NewUsageHandler(usageService, apiKeyService, adminService, usageCleanupService)
-	userAttributeDefinitionRepository := repository.NewUserAttributeDefinitionRepository(client)
-	userAttributeValueRepository := repository.NewUserAttributeValueRepository(client)
-	userAttributeService := service.NewUserAttributeService(userAttributeDefinitionRepository, userAttributeValueRepository)
-	userAttributeHandler := admin.NewUserAttributeHandler(userAttributeService)
-	errorPassthroughRepository := repository.NewErrorPassthroughRepository(client)
-	errorPassthroughCache := repository.NewErrorPassthroughCache(redisClient)
-	errorPassthroughService := service.NewErrorPassthroughService(errorPassthroughRepository, errorPassthroughCache)
-	errorPassthroughHandler := admin.NewErrorPassthroughHandler(errorPassthroughService)
-	adminAPIKeyHandler := admin.NewAdminAPIKeyHandler(adminService)
-	scheduledTestPlanRepository := repository.NewScheduledTestPlanRepository(db)
-	scheduledTestResultRepository := repository.NewScheduledTestResultRepository(db)
-	scheduledTestService := service.ProvideScheduledTestService(scheduledTestPlanRepository, scheduledTestResultRepository)
-	scheduledTestHandler := admin.NewScheduledTestHandler(scheduledTestService)
-	adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, adminAnnouncementHandler, dataManagementHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, promoHandler, settingHandler, opsHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler, userAttributeHandler, errorPassthroughHandler, adminAPIKeyHandler, scheduledTestHandler)
-	usageRecordWorkerPool := service.NewUsageRecordWorkerPool(configConfig)
-	userMsgQueueCache := repository.NewUserMsgQueueCache(redisClient)
-	userMessageQueueService := service.ProvideUserMessageQueueService(userMsgQueueCache, rpmCache, configConfig)
-	gatewayHandler := handler.NewGatewayHandler(gatewayService, geminiMessagesCompatService, antigravityGatewayService, userService, concurrencyService, billingCacheService, usageService, apiKeyService, usageRecordWorkerPool, errorPassthroughService, userMessageQueueService, configConfig, settingService)
-	openAIGatewayHandler := handler.NewOpenAIGatewayHandler(openAIGatewayService, concurrencyService, billingCacheService, apiKeyService, usageRecordWorkerPool, errorPassthroughService, configConfig)
-	soraSDKClient := service.ProvideSoraSDKClient(configConfig, httpUpstream, openAITokenProvider, accountRepository, soraAccountRepository)
-	soraMediaStorage := service.ProvideSoraMediaStorage(configConfig)
-	soraGatewayService := service.NewSoraGatewayService(soraSDKClient, rateLimitService, httpUpstream, configConfig)
-	soraClientHandler := handler.NewSoraClientHandler(soraGenerationService, soraQuotaService, soraS3Storage, soraGatewayService, gatewayService, soraMediaStorage, apiKeyService)
-	soraGatewayHandler := handler.NewSoraGatewayHandler(gatewayService, soraGatewayService, concurrencyService, billingCacheService, usageRecordWorkerPool, configConfig)
+	gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService)
+	geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService)
+	gatewayHandler := handler.NewGatewayHandler(gatewayService, geminiMessagesCompatService, antigravityGatewayService, userService, concurrencyService, billingCacheService)
+	openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService)
+	openAIGatewayHandler := handler.NewOpenAIGatewayHandler(openAIGatewayService, concurrencyService, billingCacheService)
 	handlerSettingHandler := handler.ProvideSettingHandler(settingService, buildInfo)
-	totpHandler := handler.NewTotpHandler(totpService)
-	idempotencyCoordinator := service.ProvideIdempotencyCoordinator(idempotencyRepository, configConfig)
-	idempotencyCleanupService := service.ProvideIdempotencyCleanupService(idempotencyRepository, configConfig)
-	handlers := handler.ProvideHandlers(authHandler, userHandler, apiKeyHandler, usageHandler, redeemHandler, subscriptionHandler, announcementHandler, adminHandlers, gatewayHandler, openAIGatewayHandler, soraGatewayHandler, soraClientHandler, handlerSettingHandler, totpHandler, idempotencyCoordinator, idempotencyCleanupService)
+	handlers := handler.ProvideHandlers(authHandler, userHandler, apiKeyHandler, usageHandler, redeemHandler, subscriptionHandler, adminHandlers, gatewayHandler, openAIGatewayHandler, handlerSettingHandler)
 	jwtAuthMiddleware := middleware.NewJWTAuthMiddleware(authService, userService)
 	adminAuthMiddleware := middleware.NewAdminAuthMiddleware(authService, userService, settingService)
-	apiKeyAuthMiddleware := middleware.NewAPIKeyAuthMiddleware(apiKeyService, subscriptionService, configConfig)
-	engine := server.ProvideRouter(configConfig, handlers, jwtAuthMiddleware, adminAuthMiddleware, apiKeyAuthMiddleware, apiKeyService, subscriptionService, opsService, settingService, redisClient)
+	apiKeyAuthMiddleware := middleware.NewApiKeyAuthMiddleware(apiKeyService, subscriptionService, configConfig)
+	engine := server.ProvideRouter(configConfig, handlers, jwtAuthMiddleware, adminAuthMiddleware, apiKeyAuthMiddleware, apiKeyService, subscriptionService)
 	httpServer := server.ProvideHTTPServer(configConfig, engine)
-	opsMetricsCollector := service.ProvideOpsMetricsCollector(opsRepository, settingRepository, accountRepository, concurrencyService, db, redisClient, configConfig)
-	opsAggregationService := service.ProvideOpsAggregationService(opsRepository, settingRepository, db, redisClient, configConfig)
-	opsAlertEvaluatorService := service.ProvideOpsAlertEvaluatorService(opsService, opsRepository, emailService, redisClient, configConfig)
-	opsCleanupService := service.ProvideOpsCleanupService(opsRepository, db, redisClient, configConfig)
-	opsScheduledReportService := service.ProvideOpsScheduledReportService(opsService, userService, emailService, redisClient, configConfig)
-	soraMediaCleanupService := service.ProvideSoraMediaCleanupService(soraMediaStorage, configConfig)
-	tokenRefreshService := service.ProvideTokenRefreshService(accountRepository, soraAccountRepository, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, compositeTokenCacheInvalidator, schedulerCache, configConfig, tempUnschedCache)
-	accountExpiryService := service.ProvideAccountExpiryService(accountRepository)
-	subscriptionExpiryService := service.ProvideSubscriptionExpiryService(userSubscriptionRepository)
-	scheduledTestRunnerService := service.ProvideScheduledTestRunnerService(scheduledTestPlanRepository, scheduledTestService, accountTestService, rateLimitService, configConfig)
-	v := provideCleanup(client, redisClient, opsMetricsCollector, opsAggregationService, opsAlertEvaluatorService, opsCleanupService, opsScheduledReportService, opsSystemLogSink, soraMediaCleanupService, schedulerSnapshotService, tokenRefreshService, accountExpiryService, subscriptionExpiryService, usageCleanupService, idempotencyCleanupService, pricingService, emailQueueService, billingCacheService, usageRecordWorkerPool, subscriptionService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, openAIGatewayService, scheduledTestRunnerService)
+	tokenRefreshService := service.ProvideTokenRefreshService(accountRepository, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, configConfig)
+	antigravityQuotaRefresher := service.ProvideAntigravityQuotaRefresher(accountRepository, proxyRepository, antigravityOAuthService, configConfig)
+	v := provideCleanup(client, redisClient, tokenRefreshService, pricingService, emailQueueService, billingCacheService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, antigravityQuotaRefresher)
 	application := &Application{
 		Server:  httpServer,
 		Cleanup: v,
@@ -255,119 +166,28 @@ func provideServiceBuildInfo(buildInfo handler.BuildInfo) service.BuildInfo {
 func provideCleanup(
 	entClient *ent.Client,
 	rdb *redis.Client,
-	opsMetricsCollector *service.OpsMetricsCollector,
-	opsAggregation *service.OpsAggregationService,
-	opsAlertEvaluator *service.OpsAlertEvaluatorService,
-	opsCleanup *service.OpsCleanupService,
-	opsScheduledReport *service.OpsScheduledReportService,
-	opsSystemLogSink *service.OpsSystemLogSink,
-	soraMediaCleanup *service.SoraMediaCleanupService,
-	schedulerSnapshot *service.SchedulerSnapshotService,
 	tokenRefresh *service.TokenRefreshService,
-	accountExpiry *service.AccountExpiryService,
-	subscriptionExpiry *service.SubscriptionExpiryService,
-	usageCleanup *service.UsageCleanupService,
-	idempotencyCleanup *service.IdempotencyCleanupService,
 	pricing *service.PricingService,
 	emailQueue *service.EmailQueueService,
 	billingCache *service.BillingCacheService,
-	usageRecordWorkerPool *service.UsageRecordWorkerPool,
-	subscriptionService *service.SubscriptionService,
 	oauth *service.OAuthService,
 	openaiOAuth *service.OpenAIOAuthService,
 	geminiOAuth *service.GeminiOAuthService,
 	antigravityOAuth *service.AntigravityOAuthService,
-	openAIGateway *service.OpenAIGatewayService,
-	scheduledTestRunner *service.ScheduledTestRunnerService,
+	antigravityQuota *service.AntigravityQuotaRefresher,
 ) func() {
 	return func() {
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 
-		type cleanupStep struct {
+		cleanupSteps := []struct {
 			name string
 			fn   func() error
-		}
-
-		parallelSteps := []cleanupStep{
-			{"OpsScheduledReportService", func() error {
-				if opsScheduledReport != nil {
-					opsScheduledReport.Stop()
-				}
-				return nil
-			}},
-			{"OpsCleanupService", func() error {
-				if opsCleanup != nil {
-					opsCleanup.Stop()
-				}
-				return nil
-			}},
-			{"OpsSystemLogSink", func() error {
-				if opsSystemLogSink != nil {
-					opsSystemLogSink.Stop()
-				}
-				return nil
-			}},
-			{"SoraMediaCleanupService", func() error {
-				if soraMediaCleanup != nil {
-					soraMediaCleanup.Stop()
-				}
-				return nil
-			}},
-			{"OpsAlertEvaluatorService", func() error {
-				if opsAlertEvaluator != nil {
-					opsAlertEvaluator.Stop()
-				}
-				return nil
-			}},
-			{"OpsAggregationService", func() error {
-				if opsAggregation != nil {
-					opsAggregation.Stop()
-				}
-				return nil
-			}},
-			{"OpsMetricsCollector", func() error {
-				if opsMetricsCollector != nil {
-					opsMetricsCollector.Stop()
-				}
-				return nil
-			}},
-			{"SchedulerSnapshotService", func() error {
-				if schedulerSnapshot != nil {
-					schedulerSnapshot.Stop()
-				}
-				return nil
-			}},
-			{"UsageCleanupService", func() error {
-				if usageCleanup != nil {
-					usageCleanup.Stop()
-				}
-				return nil
-			}},
-			{"IdempotencyCleanupService", func() error {
-				if idempotencyCleanup != nil {
-					idempotencyCleanup.Stop()
-				}
-				return nil
-			}},
+		}{
 			{"TokenRefreshService", func() error {
 				tokenRefresh.Stop()
 				return nil
 			}},
-			{"AccountExpiryService", func() error {
-				accountExpiry.Stop()
-				return nil
-			}},
-			{"SubscriptionExpiryService", func() error {
-				subscriptionExpiry.Stop()
-				return nil
-			}},
-			{"SubscriptionService", func() error {
-				if subscriptionService != nil {
-					subscriptionService.Stop()
-				}
-				return nil
-			}},
 			{"PricingService", func() error {
 				pricing.Stop()
 				return nil
@@ -380,12 +200,6 @@ func provideCleanup(
 				billingCache.Stop()
 				return nil
 			}},
-			{"UsageRecordWorkerPool", func() error {
-				if usageRecordWorkerPool != nil {
-					usageRecordWorkerPool.Stop()
-				}
-				return nil
-			}},
 			{"OAuthService", func() error {
 				oauth.Stop()
 				return nil
@@ -402,66 +216,27 @@ func provideCleanup(
 				antigravityOAuth.Stop()
 				return nil
 			}},
-			{"OpenAIWSPool", func() error {
-				if openAIGateway != nil {
-					openAIGateway.CloseOpenAIWSPool()
-				}
+			{"AntigravityQuotaRefresher", func() error {
+				antigravityQuota.Stop()
 				return nil
 			}},
-			{"ScheduledTestRunnerService", func() error {
-				if scheduledTestRunner != nil {
-					scheduledTestRunner.Stop()
-				}
-				return nil
-			}},
-		}
-
-		infraSteps := []cleanupStep{
 			{"Redis", func() error {
-				if rdb == nil {
-					return nil
-				}
 				return rdb.Close()
 			}},
 			{"Ent", func() error {
-				if entClient == nil {
-					return nil
-				}
 				return entClient.Close()
 			}},
 		}
 
-		runParallel := func(steps []cleanupStep) {
-			var wg sync.WaitGroup
-			for i := range steps {
-				step := steps[i]
-				wg.Add(1)
-				go func() {
-					defer wg.Done()
-					if err := step.fn(); err != nil {
-						log.Printf("[Cleanup] %s failed: %v", step.name, err)
-						return
-					}
-					log.Printf("[Cleanup] %s succeeded", step.name)
-				}()
-			}
-			wg.Wait()
-		}
+		for _, step := range cleanupSteps {
+			if err := step.fn(); err != nil {
+				log.Printf("[Cleanup] %s failed: %v", step.name, err)
 
-		runSequential := func(steps []cleanupStep) {
-			for i := range steps {
-				step := steps[i]
-				if err := step.fn(); err != nil {
-					log.Printf("[Cleanup] %s failed: %v", step.name, err)
-					continue
-				}
+			} else {
 				log.Printf("[Cleanup] %s succeeded", step.name)
 			}
 		}
 
-		runParallel(parallelSteps)
-		runSequential(infraSteps)
-
 		select {
 		case <-ctx.Done():
 			log.Printf("[Cleanup] Warning: cleanup timed out after 10 seconds")

backend/cmd/server/wire_gen_test.go

@@ -1,83 +0,0 @@
-package main
-
-import (
-	"testing"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/config"
-	"github.com/Wei-Shaw/sub2api/internal/handler"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/stretchr/testify/require"
-)
-
-func TestProvideServiceBuildInfo(t *testing.T) {
-	in := handler.BuildInfo{
-		Version:   "v-test",
-		BuildType: "release",
-	}
-	out := provideServiceBuildInfo(in)
-	require.Equal(t, in.Version, out.Version)
-	require.Equal(t, in.BuildType, out.BuildType)
-}
-
-func TestProvideCleanup_WithMinimalDependencies_NoPanic(t *testing.T) {
-	cfg := &config.Config{}
-
-	oauthSvc := service.NewOAuthService(nil, nil)
-	openAIOAuthSvc := service.NewOpenAIOAuthService(nil, nil)
-	geminiOAuthSvc := service.NewGeminiOAuthService(nil, nil, nil, nil, cfg)
-	antigravityOAuthSvc := service.NewAntigravityOAuthService(nil)
-
-	tokenRefreshSvc := service.NewTokenRefreshService(
-		nil,
-		oauthSvc,
-		openAIOAuthSvc,
-		geminiOAuthSvc,
-		antigravityOAuthSvc,
-		nil,
-		nil,
-		cfg,
-		nil,
-	)
-	accountExpirySvc := service.NewAccountExpiryService(nil, time.Second)
-	subscriptionExpirySvc := service.NewSubscriptionExpiryService(nil, time.Second)
-	pricingSvc := service.NewPricingService(cfg, nil)
-	emailQueueSvc := service.NewEmailQueueService(nil, 1)
-	billingCacheSvc := service.NewBillingCacheService(nil, nil, nil, nil, cfg)
-	idempotencyCleanupSvc := service.NewIdempotencyCleanupService(nil, cfg)
-	schedulerSnapshotSvc := service.NewSchedulerSnapshotService(nil, nil, nil, nil, cfg)
-	opsSystemLogSinkSvc := service.NewOpsSystemLogSink(nil)
-
-	cleanup := provideCleanup(
-		nil, // entClient
-		nil, // redis
-		&service.OpsMetricsCollector{},
-		&service.OpsAggregationService{},
-		&service.OpsAlertEvaluatorService{},
-		&service.OpsCleanupService{},
-		&service.OpsScheduledReportService{},
-		opsSystemLogSinkSvc,
-		&service.SoraMediaCleanupService{},
-		schedulerSnapshotSvc,
-		tokenRefreshSvc,
-		accountExpirySvc,
-		subscriptionExpirySvc,
-		&service.UsageCleanupService{},
-		idempotencyCleanupSvc,
-		pricingSvc,
-		emailQueueSvc,
-		billingCacheSvc,
-		&service.UsageRecordWorkerPool{},
-		&service.SubscriptionService{},
-		oauthSvc,
-		openAIOAuthSvc,
-		geminiOAuthSvc,
-		antigravityOAuthSvc,
-		nil, // openAIGateway
-		nil, // scheduledTestRunner
-	)
-
-	require.NotPanics(t, func() {
-		cleanup()
-	})
-}

backend/ent/account.go

@@ -27,8 +27,6 @@ type Account struct {
 	DeletedAt *time.Time `json:"deleted_at,omitempty"`
 	// Name holds the value of the "name" field.
 	Name string `json:"name,omitempty"`
-	// Notes holds the value of the "notes" field.
-	Notes *string `json:"notes,omitempty"`
 	// Platform holds the value of the "platform" field.
 	Platform string `json:"platform,omitempty"`
 	// Type holds the value of the "type" field.
@@ -41,22 +39,14 @@ type Account struct {
 	ProxyID *int64 `json:"proxy_id,omitempty"`
 	// Concurrency holds the value of the "concurrency" field.
 	Concurrency int `json:"concurrency,omitempty"`
-	// LoadFactor holds the value of the "load_factor" field.
-	LoadFactor *int `json:"load_factor,omitempty"`
 	// Priority holds the value of the "priority" field.
 	Priority int `json:"priority,omitempty"`
-	// RateMultiplier holds the value of the "rate_multiplier" field.
-	RateMultiplier float64 `json:"rate_multiplier,omitempty"`
 	// Status holds the value of the "status" field.
 	Status string `json:"status,omitempty"`
 	// ErrorMessage holds the value of the "error_message" field.
 	ErrorMessage *string `json:"error_message,omitempty"`
 	// LastUsedAt holds the value of the "last_used_at" field.
 	LastUsedAt *time.Time `json:"last_used_at,omitempty"`
-	// Account expiration time (NULL means no expiration).
-	ExpiresAt *time.Time `json:"expires_at,omitempty"`
-	// Auto pause scheduling when account expires.
-	AutoPauseOnExpired bool `json:"auto_pause_on_expired,omitempty"`
 	// Schedulable holds the value of the "schedulable" field.
 	Schedulable bool `json:"schedulable,omitempty"`
 	// RateLimitedAt holds the value of the "rate_limited_at" field.
@@ -65,10 +55,6 @@ type Account struct {
 	RateLimitResetAt *time.Time `json:"rate_limit_reset_at,omitempty"`
 	// OverloadUntil holds the value of the "overload_until" field.
 	OverloadUntil *time.Time `json:"overload_until,omitempty"`
-	// TempUnschedulableUntil holds the value of the "temp_unschedulable_until" field.
-	TempUnschedulableUntil *time.Time `json:"temp_unschedulable_until,omitempty"`
-	// TempUnschedulableReason holds the value of the "temp_unschedulable_reason" field.
-	TempUnschedulableReason *string `json:"temp_unschedulable_reason,omitempty"`
 	// SessionWindowStart holds the value of the "session_window_start" field.
 	SessionWindowStart *time.Time `json:"session_window_start,omitempty"`
 	// SessionWindowEnd holds the value of the "session_window_end" field.
@@ -141,15 +127,13 @@ func (*Account) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case account.FieldCredentials, account.FieldExtra:
 			values[i] = new([]byte)
-		case account.FieldAutoPauseOnExpired, account.FieldSchedulable:
+		case account.FieldSchedulable:
 			values[i] = new(sql.NullBool)
-		case account.FieldRateMultiplier:
-			values[i] = new(sql.NullFloat64)
-		case account.FieldID, account.FieldProxyID, account.FieldConcurrency, account.FieldLoadFactor, account.FieldPriority:
+		case account.FieldID, account.FieldProxyID, account.FieldConcurrency, account.FieldPriority:
 			values[i] = new(sql.NullInt64)
-		case account.FieldName, account.FieldNotes, account.FieldPlatform, account.FieldType, account.FieldStatus, account.FieldErrorMessage, account.FieldTempUnschedulableReason, account.FieldSessionWindowStatus:
+		case account.FieldName, account.FieldPlatform, account.FieldType, account.FieldStatus, account.FieldErrorMessage, account.FieldSessionWindowStatus:
 			values[i] = new(sql.NullString)
-		case account.FieldCreatedAt, account.FieldUpdatedAt, account.FieldDeletedAt, account.FieldLastUsedAt, account.FieldExpiresAt, account.FieldRateLimitedAt, account.FieldRateLimitResetAt, account.FieldOverloadUntil, account.FieldTempUnschedulableUntil, account.FieldSessionWindowStart, account.FieldSessionWindowEnd:
+		case account.FieldCreatedAt, account.FieldUpdatedAt, account.FieldDeletedAt, account.FieldLastUsedAt, account.FieldRateLimitedAt, account.FieldRateLimitResetAt, account.FieldOverloadUntil, account.FieldSessionWindowStart, account.FieldSessionWindowEnd:
 			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
@@ -197,13 +181,6 @@ func (_m *Account) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.Name = value.String
 			}
-		case account.FieldNotes:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field notes", values[i])
-			} else if value.Valid {
-				_m.Notes = new(string)
-				*_m.Notes = value.String
-			}
 		case account.FieldPlatform:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field platform", values[i])
@@ -245,25 +222,12 @@ func (_m *Account) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.Concurrency = int(value.Int64)
 			}
-		case account.FieldLoadFactor:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field load_factor", values[i])
-			} else if value.Valid {
-				_m.LoadFactor = new(int)
-				*_m.LoadFactor = int(value.Int64)
-			}
 		case account.FieldPriority:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field priority", values[i])
 			} else if value.Valid {
 				_m.Priority = int(value.Int64)
 			}
-		case account.FieldRateMultiplier:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field rate_multiplier", values[i])
-			} else if value.Valid {
-				_m.RateMultiplier = value.Float64
-			}
 		case account.FieldStatus:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field status", values[i])
@@ -284,19 +248,6 @@ func (_m *Account) assignValues(columns []string, values []any) error {
 				_m.LastUsedAt = new(time.Time)
 				*_m.LastUsedAt = value.Time
 			}
-		case account.FieldExpiresAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
-			} else if value.Valid {
-				_m.ExpiresAt = new(time.Time)
-				*_m.ExpiresAt = value.Time
-			}
-		case account.FieldAutoPauseOnExpired:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field auto_pause_on_expired", values[i])
-			} else if value.Valid {
-				_m.AutoPauseOnExpired = value.Bool
-			}
 		case account.FieldSchedulable:
 			if value, ok := values[i].(*sql.NullBool); !ok {
 				return fmt.Errorf("unexpected type %T for field schedulable", values[i])
@@ -324,20 +275,6 @@ func (_m *Account) assignValues(columns []string, values []any) error {
 				_m.OverloadUntil = new(time.Time)
 				*_m.OverloadUntil = value.Time
 			}
-		case account.FieldTempUnschedulableUntil:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field temp_unschedulable_until", values[i])
-			} else if value.Valid {
-				_m.TempUnschedulableUntil = new(time.Time)
-				*_m.TempUnschedulableUntil = value.Time
-			}
-		case account.FieldTempUnschedulableReason:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field temp_unschedulable_reason", values[i])
-			} else if value.Valid {
-				_m.TempUnschedulableReason = new(string)
-				*_m.TempUnschedulableReason = value.String
-			}
 		case account.FieldSessionWindowStart:
 			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field session_window_start", values[i])
@@ -429,11 +366,6 @@ func (_m *Account) String() string {
 	builder.WriteString("name=")
 	builder.WriteString(_m.Name)
 	builder.WriteString(", ")
-	if v := _m.Notes; v != nil {
-		builder.WriteString("notes=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
 	builder.WriteString("platform=")
 	builder.WriteString(_m.Platform)
 	builder.WriteString(", ")
@@ -454,17 +386,9 @@ func (_m *Account) String() string {
 	builder.WriteString("concurrency=")
 	builder.WriteString(fmt.Sprintf("%v", _m.Concurrency))
 	builder.WriteString(", ")
-	if v := _m.LoadFactor; v != nil {
-		builder.WriteString("load_factor=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
 	builder.WriteString("priority=")
 	builder.WriteString(fmt.Sprintf("%v", _m.Priority))
 	builder.WriteString(", ")
-	builder.WriteString("rate_multiplier=")
-	builder.WriteString(fmt.Sprintf("%v", _m.RateMultiplier))
-	builder.WriteString(", ")
 	builder.WriteString("status=")
 	builder.WriteString(_m.Status)
 	builder.WriteString(", ")
@@ -478,14 +402,6 @@ func (_m *Account) String() string {
 		builder.WriteString(v.Format(time.ANSIC))
 	}
 	builder.WriteString(", ")
-	if v := _m.ExpiresAt; v != nil {
-		builder.WriteString("expires_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("auto_pause_on_expired=")
-	builder.WriteString(fmt.Sprintf("%v", _m.AutoPauseOnExpired))
-	builder.WriteString(", ")
 	builder.WriteString("schedulable=")
 	builder.WriteString(fmt.Sprintf("%v", _m.Schedulable))
 	builder.WriteString(", ")
@@ -504,16 +420,6 @@ func (_m *Account) String() string {
 		builder.WriteString(v.Format(time.ANSIC))
 	}
 	builder.WriteString(", ")
-	if v := _m.TempUnschedulableUntil; v != nil {
-		builder.WriteString("temp_unschedulable_until=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.TempUnschedulableReason; v != nil {
-		builder.WriteString("temp_unschedulable_reason=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
 	if v := _m.SessionWindowStart; v != nil {
 		builder.WriteString("session_window_start=")
 		builder.WriteString(v.Format(time.ANSIC))

backend/ent/account/account.go

@@ -23,8 +23,6 @@ const (
 	FieldDeletedAt = "deleted_at"
 	// FieldName holds the string denoting the name field in the database.
 	FieldName = "name"
-	// FieldNotes holds the string denoting the notes field in the database.
-	FieldNotes = "notes"
 	// FieldPlatform holds the string denoting the platform field in the database.
 	FieldPlatform = "platform"
 	// FieldType holds the string denoting the type field in the database.
@@ -37,22 +35,14 @@ const (
 	FieldProxyID = "proxy_id"
 	// FieldConcurrency holds the string denoting the concurrency field in the database.
 	FieldConcurrency = "concurrency"
-	// FieldLoadFactor holds the string denoting the load_factor field in the database.
-	FieldLoadFactor = "load_factor"
 	// FieldPriority holds the string denoting the priority field in the database.
 	FieldPriority = "priority"
-	// FieldRateMultiplier holds the string denoting the rate_multiplier field in the database.
-	FieldRateMultiplier = "rate_multiplier"
 	// FieldStatus holds the string denoting the status field in the database.
 	FieldStatus = "status"
 	// FieldErrorMessage holds the string denoting the error_message field in the database.
 	FieldErrorMessage = "error_message"
 	// FieldLastUsedAt holds the string denoting the last_used_at field in the database.
 	FieldLastUsedAt = "last_used_at"
-	// FieldExpiresAt holds the string denoting the expires_at field in the database.
-	FieldExpiresAt = "expires_at"
-	// FieldAutoPauseOnExpired holds the string denoting the auto_pause_on_expired field in the database.
-	FieldAutoPauseOnExpired = "auto_pause_on_expired"
 	// FieldSchedulable holds the string denoting the schedulable field in the database.
 	FieldSchedulable = "schedulable"
 	// FieldRateLimitedAt holds the string denoting the rate_limited_at field in the database.
@@ -61,10 +51,6 @@ const (
 	FieldRateLimitResetAt = "rate_limit_reset_at"
 	// FieldOverloadUntil holds the string denoting the overload_until field in the database.
 	FieldOverloadUntil = "overload_until"
-	// FieldTempUnschedulableUntil holds the string denoting the temp_unschedulable_until field in the database.
-	FieldTempUnschedulableUntil = "temp_unschedulable_until"
-	// FieldTempUnschedulableReason holds the string denoting the temp_unschedulable_reason field in the database.
-	FieldTempUnschedulableReason = "temp_unschedulable_reason"
 	// FieldSessionWindowStart holds the string denoting the session_window_start field in the database.
 	FieldSessionWindowStart = "session_window_start"
 	// FieldSessionWindowEnd holds the string denoting the session_window_end field in the database.
@@ -116,27 +102,20 @@ var Columns = []string{
 	FieldUpdatedAt,
 	FieldDeletedAt,
 	FieldName,
-	FieldNotes,
 	FieldPlatform,
 	FieldType,
 	FieldCredentials,
 	FieldExtra,
 	FieldProxyID,
 	FieldConcurrency,
-	FieldLoadFactor,
 	FieldPriority,
-	FieldRateMultiplier,
 	FieldStatus,
 	FieldErrorMessage,
 	FieldLastUsedAt,
-	FieldExpiresAt,
-	FieldAutoPauseOnExpired,
 	FieldSchedulable,
 	FieldRateLimitedAt,
 	FieldRateLimitResetAt,
 	FieldOverloadUntil,
-	FieldTempUnschedulableUntil,
-	FieldTempUnschedulableReason,
 	FieldSessionWindowStart,
 	FieldSessionWindowEnd,
 	FieldSessionWindowStatus,
@@ -186,14 +165,10 @@ var (
 	DefaultConcurrency int
 	// DefaultPriority holds the default value on creation for the "priority" field.
 	DefaultPriority int
-	// DefaultRateMultiplier holds the default value on creation for the "rate_multiplier" field.
-	DefaultRateMultiplier float64
 	// DefaultStatus holds the default value on creation for the "status" field.
 	DefaultStatus string
 	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
 	StatusValidator func(string) error
-	// DefaultAutoPauseOnExpired holds the default value on creation for the "auto_pause_on_expired" field.
-	DefaultAutoPauseOnExpired bool
 	// DefaultSchedulable holds the default value on creation for the "schedulable" field.
 	DefaultSchedulable bool
 	// SessionWindowStatusValidator is a validator for the "session_window_status" field. It is called by the builders before save.
@@ -228,11 +203,6 @@ func ByName(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldName, opts...).ToFunc()
 }
 
-// ByNotes orders the results by the notes field.
-func ByNotes(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldNotes, opts...).ToFunc()
-}
-
 // ByPlatform orders the results by the platform field.
 func ByPlatform(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldPlatform, opts...).ToFunc()
@@ -253,21 +223,11 @@ func ByConcurrency(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldConcurrency, opts...).ToFunc()
 }
 
-// ByLoadFactor orders the results by the load_factor field.
-func ByLoadFactor(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldLoadFactor, opts...).ToFunc()
-}
-
 // ByPriority orders the results by the priority field.
 func ByPriority(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldPriority, opts...).ToFunc()
 }
 
-// ByRateMultiplier orders the results by the rate_multiplier field.
-func ByRateMultiplier(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldRateMultiplier, opts...).ToFunc()
-}
-
 // ByStatus orders the results by the status field.
 func ByStatus(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldStatus, opts...).ToFunc()
@@ -283,16 +243,6 @@ func ByLastUsedAt(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldLastUsedAt, opts...).ToFunc()
 }
 
-// ByExpiresAt orders the results by the expires_at field.
-func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
-}
-
-// ByAutoPauseOnExpired orders the results by the auto_pause_on_expired field.
-func ByAutoPauseOnExpired(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldAutoPauseOnExpired, opts...).ToFunc()
-}
-
 // BySchedulable orders the results by the schedulable field.
 func BySchedulable(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldSchedulable, opts...).ToFunc()
@@ -313,16 +263,6 @@ func ByOverloadUntil(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldOverloadUntil, opts...).ToFunc()
 }
 
-// ByTempUnschedulableUntil orders the results by the temp_unschedulable_until field.
-func ByTempUnschedulableUntil(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldTempUnschedulableUntil, opts...).ToFunc()
-}
-
-// ByTempUnschedulableReason orders the results by the temp_unschedulable_reason field.
-func ByTempUnschedulableReason(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldTempUnschedulableReason, opts...).ToFunc()
-}
-
 // BySessionWindowStart orders the results by the session_window_start field.
 func BySessionWindowStart(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldSessionWindowStart, opts...).ToFunc()

backend/ent/account/where.go

@@ -75,11 +75,6 @@ func Name(v string) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldName, v))
 }
 
-// Notes applies equality check predicate on the "notes" field. It's identical to NotesEQ.
-func Notes(v string) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldNotes, v))
-}
-
 // Platform applies equality check predicate on the "platform" field. It's identical to PlatformEQ.
 func Platform(v string) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldPlatform, v))
@@ -100,21 +95,11 @@ func Concurrency(v int) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldConcurrency, v))
 }
 
-// LoadFactor applies equality check predicate on the "load_factor" field. It's identical to LoadFactorEQ.
-func LoadFactor(v int) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldLoadFactor, v))
-}
-
 // Priority applies equality check predicate on the "priority" field. It's identical to PriorityEQ.
 func Priority(v int) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldPriority, v))
 }
 
-// RateMultiplier applies equality check predicate on the "rate_multiplier" field. It's identical to RateMultiplierEQ.
-func RateMultiplier(v float64) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldRateMultiplier, v))
-}
-
 // Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
 func Status(v string) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldStatus, v))
@@ -130,16 +115,6 @@ func LastUsedAt(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldLastUsedAt, v))
 }
 
-// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
-func ExpiresAt(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldExpiresAt, v))
-}
-
-// AutoPauseOnExpired applies equality check predicate on the "auto_pause_on_expired" field. It's identical to AutoPauseOnExpiredEQ.
-func AutoPauseOnExpired(v bool) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldAutoPauseOnExpired, v))
-}
-
 // Schedulable applies equality check predicate on the "schedulable" field. It's identical to SchedulableEQ.
 func Schedulable(v bool) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldSchedulable, v))
@@ -160,16 +135,6 @@ func OverloadUntil(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldOverloadUntil, v))
 }
 
-// TempUnschedulableUntil applies equality check predicate on the "temp_unschedulable_until" field. It's identical to TempUnschedulableUntilEQ.
-func TempUnschedulableUntil(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldTempUnschedulableUntil, v))
-}
-
-// TempUnschedulableReason applies equality check predicate on the "temp_unschedulable_reason" field. It's identical to TempUnschedulableReasonEQ.
-func TempUnschedulableReason(v string) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldTempUnschedulableReason, v))
-}
-
 // SessionWindowStart applies equality check predicate on the "session_window_start" field. It's identical to SessionWindowStartEQ.
 func SessionWindowStart(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldSessionWindowStart, v))
@@ -380,81 +345,6 @@ func NameContainsFold(v string) predicate.Account {
 	return predicate.Account(sql.FieldContainsFold(FieldName, v))
 }
 
-// NotesEQ applies the EQ predicate on the "notes" field.
-func NotesEQ(v string) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldNotes, v))
-}
-
-// NotesNEQ applies the NEQ predicate on the "notes" field.
-func NotesNEQ(v string) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldNotes, v))
-}
-
-// NotesIn applies the In predicate on the "notes" field.
-func NotesIn(vs ...string) predicate.Account {
-	return predicate.Account(sql.FieldIn(FieldNotes, vs...))
-}
-
-// NotesNotIn applies the NotIn predicate on the "notes" field.
-func NotesNotIn(vs ...string) predicate.Account {
-	return predicate.Account(sql.FieldNotIn(FieldNotes, vs...))
-}
-
-// NotesGT applies the GT predicate on the "notes" field.
-func NotesGT(v string) predicate.Account {
-	return predicate.Account(sql.FieldGT(FieldNotes, v))
-}
-
-// NotesGTE applies the GTE predicate on the "notes" field.
-func NotesGTE(v string) predicate.Account {
-	return predicate.Account(sql.FieldGTE(FieldNotes, v))
-}
-
-// NotesLT applies the LT predicate on the "notes" field.
-func NotesLT(v string) predicate.Account {
-	return predicate.Account(sql.FieldLT(FieldNotes, v))
-}
-
-// NotesLTE applies the LTE predicate on the "notes" field.
-func NotesLTE(v string) predicate.Account {
-	return predicate.Account(sql.FieldLTE(FieldNotes, v))
-}
-
-// NotesContains applies the Contains predicate on the "notes" field.
-func NotesContains(v string) predicate.Account {
-	return predicate.Account(sql.FieldContains(FieldNotes, v))
-}
-
-// NotesHasPrefix applies the HasPrefix predicate on the "notes" field.
-func NotesHasPrefix(v string) predicate.Account {
-	return predicate.Account(sql.FieldHasPrefix(FieldNotes, v))
-}
-
-// NotesHasSuffix applies the HasSuffix predicate on the "notes" field.
-func NotesHasSuffix(v string) predicate.Account {
-	return predicate.Account(sql.FieldHasSuffix(FieldNotes, v))
-}
-
-// NotesIsNil applies the IsNil predicate on the "notes" field.
-func NotesIsNil() predicate.Account {
-	return predicate.Account(sql.FieldIsNull(FieldNotes))
-}
-
-// NotesNotNil applies the NotNil predicate on the "notes" field.
-func NotesNotNil() predicate.Account {
-	return predicate.Account(sql.FieldNotNull(FieldNotes))
-}
-
-// NotesEqualFold applies the EqualFold predicate on the "notes" field.
-func NotesEqualFold(v string) predicate.Account {
-	return predicate.Account(sql.FieldEqualFold(FieldNotes, v))
-}
-
-// NotesContainsFold applies the ContainsFold predicate on the "notes" field.
-func NotesContainsFold(v string) predicate.Account {
-	return predicate.Account(sql.FieldContainsFold(FieldNotes, v))
-}
-
 // PlatformEQ applies the EQ predicate on the "platform" field.
 func PlatformEQ(v string) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldPlatform, v))
@@ -655,56 +545,6 @@ func ConcurrencyLTE(v int) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldConcurrency, v))
 }
 
-// LoadFactorEQ applies the EQ predicate on the "load_factor" field.
-func LoadFactorEQ(v int) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldLoadFactor, v))
-}
-
-// LoadFactorNEQ applies the NEQ predicate on the "load_factor" field.
-func LoadFactorNEQ(v int) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldLoadFactor, v))
-}
-
-// LoadFactorIn applies the In predicate on the "load_factor" field.
-func LoadFactorIn(vs ...int) predicate.Account {
-	return predicate.Account(sql.FieldIn(FieldLoadFactor, vs...))
-}
-
-// LoadFactorNotIn applies the NotIn predicate on the "load_factor" field.
-func LoadFactorNotIn(vs ...int) predicate.Account {
-	return predicate.Account(sql.FieldNotIn(FieldLoadFactor, vs...))
-}
-
-// LoadFactorGT applies the GT predicate on the "load_factor" field.
-func LoadFactorGT(v int) predicate.Account {
-	return predicate.Account(sql.FieldGT(FieldLoadFactor, v))
-}
-
-// LoadFactorGTE applies the GTE predicate on the "load_factor" field.
-func LoadFactorGTE(v int) predicate.Account {
-	return predicate.Account(sql.FieldGTE(FieldLoadFactor, v))
-}
-
-// LoadFactorLT applies the LT predicate on the "load_factor" field.
-func LoadFactorLT(v int) predicate.Account {
-	return predicate.Account(sql.FieldLT(FieldLoadFactor, v))
-}
-
-// LoadFactorLTE applies the LTE predicate on the "load_factor" field.
-func LoadFactorLTE(v int) predicate.Account {
-	return predicate.Account(sql.FieldLTE(FieldLoadFactor, v))
-}
-
-// LoadFactorIsNil applies the IsNil predicate on the "load_factor" field.
-func LoadFactorIsNil() predicate.Account {
-	return predicate.Account(sql.FieldIsNull(FieldLoadFactor))
-}
-
-// LoadFactorNotNil applies the NotNil predicate on the "load_factor" field.
-func LoadFactorNotNil() predicate.Account {
-	return predicate.Account(sql.FieldNotNull(FieldLoadFactor))
-}
-
 // PriorityEQ applies the EQ predicate on the "priority" field.
 func PriorityEQ(v int) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldPriority, v))
@@ -745,46 +585,6 @@ func PriorityLTE(v int) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldPriority, v))
 }
 
-// RateMultiplierEQ applies the EQ predicate on the "rate_multiplier" field.
-func RateMultiplierEQ(v float64) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldRateMultiplier, v))
-}
-
-// RateMultiplierNEQ applies the NEQ predicate on the "rate_multiplier" field.
-func RateMultiplierNEQ(v float64) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldRateMultiplier, v))
-}
-
-// RateMultiplierIn applies the In predicate on the "rate_multiplier" field.
-func RateMultiplierIn(vs ...float64) predicate.Account {
-	return predicate.Account(sql.FieldIn(FieldRateMultiplier, vs...))
-}
-
-// RateMultiplierNotIn applies the NotIn predicate on the "rate_multiplier" field.
-func RateMultiplierNotIn(vs ...float64) predicate.Account {
-	return predicate.Account(sql.FieldNotIn(FieldRateMultiplier, vs...))
-}
-
-// RateMultiplierGT applies the GT predicate on the "rate_multiplier" field.
-func RateMultiplierGT(v float64) predicate.Account {
-	return predicate.Account(sql.FieldGT(FieldRateMultiplier, v))
-}
-
-// RateMultiplierGTE applies the GTE predicate on the "rate_multiplier" field.
-func RateMultiplierGTE(v float64) predicate.Account {
-	return predicate.Account(sql.FieldGTE(FieldRateMultiplier, v))
-}
-
-// RateMultiplierLT applies the LT predicate on the "rate_multiplier" field.
-func RateMultiplierLT(v float64) predicate.Account {
-	return predicate.Account(sql.FieldLT(FieldRateMultiplier, v))
-}
-
-// RateMultiplierLTE applies the LTE predicate on the "rate_multiplier" field.
-func RateMultiplierLTE(v float64) predicate.Account {
-	return predicate.Account(sql.FieldLTE(FieldRateMultiplier, v))
-}
-
 // StatusEQ applies the EQ predicate on the "status" field.
 func StatusEQ(v string) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldStatus, v))
@@ -975,66 +775,6 @@ func LastUsedAtNotNil() predicate.Account {
 	return predicate.Account(sql.FieldNotNull(FieldLastUsedAt))
 }
 
-// ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
-func ExpiresAtEQ(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldExpiresAt, v))
-}
-
-// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
-func ExpiresAtNEQ(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldExpiresAt, v))
-}
-
-// ExpiresAtIn applies the In predicate on the "expires_at" field.
-func ExpiresAtIn(vs ...time.Time) predicate.Account {
-	return predicate.Account(sql.FieldIn(FieldExpiresAt, vs...))
-}
-
-// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
-func ExpiresAtNotIn(vs ...time.Time) predicate.Account {
-	return predicate.Account(sql.FieldNotIn(FieldExpiresAt, vs...))
-}
-
-// ExpiresAtGT applies the GT predicate on the "expires_at" field.
-func ExpiresAtGT(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldGT(FieldExpiresAt, v))
-}
-
-// ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
-func ExpiresAtGTE(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldGTE(FieldExpiresAt, v))
-}
-
-// ExpiresAtLT applies the LT predicate on the "expires_at" field.
-func ExpiresAtLT(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldLT(FieldExpiresAt, v))
-}
-
-// ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
-func ExpiresAtLTE(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldLTE(FieldExpiresAt, v))
-}
-
-// ExpiresAtIsNil applies the IsNil predicate on the "expires_at" field.
-func ExpiresAtIsNil() predicate.Account {
-	return predicate.Account(sql.FieldIsNull(FieldExpiresAt))
-}
-
-// ExpiresAtNotNil applies the NotNil predicate on the "expires_at" field.
-func ExpiresAtNotNil() predicate.Account {
-	return predicate.Account(sql.FieldNotNull(FieldExpiresAt))
-}
-
-// AutoPauseOnExpiredEQ applies the EQ predicate on the "auto_pause_on_expired" field.
-func AutoPauseOnExpiredEQ(v bool) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldAutoPauseOnExpired, v))
-}
-
-// AutoPauseOnExpiredNEQ applies the NEQ predicate on the "auto_pause_on_expired" field.
-func AutoPauseOnExpiredNEQ(v bool) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldAutoPauseOnExpired, v))
-}
-
 // SchedulableEQ applies the EQ predicate on the "schedulable" field.
 func SchedulableEQ(v bool) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldSchedulable, v))
@@ -1195,131 +935,6 @@ func OverloadUntilNotNil() predicate.Account {
 	return predicate.Account(sql.FieldNotNull(FieldOverloadUntil))
 }
 
-// TempUnschedulableUntilEQ applies the EQ predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilEQ(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldTempUnschedulableUntil, v))
-}
-
-// TempUnschedulableUntilNEQ applies the NEQ predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilNEQ(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldTempUnschedulableUntil, v))
-}
-
-// TempUnschedulableUntilIn applies the In predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilIn(vs ...time.Time) predicate.Account {
-	return predicate.Account(sql.FieldIn(FieldTempUnschedulableUntil, vs...))
-}
-
-// TempUnschedulableUntilNotIn applies the NotIn predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilNotIn(vs ...time.Time) predicate.Account {
-	return predicate.Account(sql.FieldNotIn(FieldTempUnschedulableUntil, vs...))
-}
-
-// TempUnschedulableUntilGT applies the GT predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilGT(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldGT(FieldTempUnschedulableUntil, v))
-}
-
-// TempUnschedulableUntilGTE applies the GTE predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilGTE(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldGTE(FieldTempUnschedulableUntil, v))
-}
-
-// TempUnschedulableUntilLT applies the LT predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilLT(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldLT(FieldTempUnschedulableUntil, v))
-}
-
-// TempUnschedulableUntilLTE applies the LTE predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilLTE(v time.Time) predicate.Account {
-	return predicate.Account(sql.FieldLTE(FieldTempUnschedulableUntil, v))
-}
-
-// TempUnschedulableUntilIsNil applies the IsNil predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilIsNil() predicate.Account {
-	return predicate.Account(sql.FieldIsNull(FieldTempUnschedulableUntil))
-}
-
-// TempUnschedulableUntilNotNil applies the NotNil predicate on the "temp_unschedulable_until" field.
-func TempUnschedulableUntilNotNil() predicate.Account {
-	return predicate.Account(sql.FieldNotNull(FieldTempUnschedulableUntil))
-}
-
-// TempUnschedulableReasonEQ applies the EQ predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonEQ(v string) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonNEQ applies the NEQ predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonNEQ(v string) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonIn applies the In predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonIn(vs ...string) predicate.Account {
-	return predicate.Account(sql.FieldIn(FieldTempUnschedulableReason, vs...))
-}
-
-// TempUnschedulableReasonNotIn applies the NotIn predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonNotIn(vs ...string) predicate.Account {
-	return predicate.Account(sql.FieldNotIn(FieldTempUnschedulableReason, vs...))
-}
-
-// TempUnschedulableReasonGT applies the GT predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonGT(v string) predicate.Account {
-	return predicate.Account(sql.FieldGT(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonGTE applies the GTE predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonGTE(v string) predicate.Account {
-	return predicate.Account(sql.FieldGTE(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonLT applies the LT predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonLT(v string) predicate.Account {
-	return predicate.Account(sql.FieldLT(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonLTE applies the LTE predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonLTE(v string) predicate.Account {
-	return predicate.Account(sql.FieldLTE(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonContains applies the Contains predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonContains(v string) predicate.Account {
-	return predicate.Account(sql.FieldContains(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonHasPrefix applies the HasPrefix predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonHasPrefix(v string) predicate.Account {
-	return predicate.Account(sql.FieldHasPrefix(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonHasSuffix applies the HasSuffix predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonHasSuffix(v string) predicate.Account {
-	return predicate.Account(sql.FieldHasSuffix(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonIsNil applies the IsNil predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonIsNil() predicate.Account {
-	return predicate.Account(sql.FieldIsNull(FieldTempUnschedulableReason))
-}
-
-// TempUnschedulableReasonNotNil applies the NotNil predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonNotNil() predicate.Account {
-	return predicate.Account(sql.FieldNotNull(FieldTempUnschedulableReason))
-}
-
-// TempUnschedulableReasonEqualFold applies the EqualFold predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonEqualFold(v string) predicate.Account {
-	return predicate.Account(sql.FieldEqualFold(FieldTempUnschedulableReason, v))
-}
-
-// TempUnschedulableReasonContainsFold applies the ContainsFold predicate on the "temp_unschedulable_reason" field.
-func TempUnschedulableReasonContainsFold(v string) predicate.Account {
-	return predicate.Account(sql.FieldContainsFold(FieldTempUnschedulableReason, v))
-}
-
 // SessionWindowStartEQ applies the EQ predicate on the "session_window_start" field.
 func SessionWindowStartEQ(v time.Time) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldSessionWindowStart, v))

backend/ent/account_create.go

@@ -73,20 +73,6 @@ func (_c *AccountCreate) SetName(v string) *AccountCreate {
 	return _c
 }
 
-// SetNotes sets the "notes" field.
-func (_c *AccountCreate) SetNotes(v string) *AccountCreate {
-	_c.mutation.SetNotes(v)
-	return _c
-}
-
-// SetNillableNotes sets the "notes" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableNotes(v *string) *AccountCreate {
-	if v != nil {
-		_c.SetNotes(*v)
-	}
-	return _c
-}
-
 // SetPlatform sets the "platform" field.
 func (_c *AccountCreate) SetPlatform(v string) *AccountCreate {
 	_c.mutation.SetPlatform(v)
@@ -139,20 +125,6 @@ func (_c *AccountCreate) SetNillableConcurrency(v *int) *AccountCreate {
 	return _c
 }
 
-// SetLoadFactor sets the "load_factor" field.
-func (_c *AccountCreate) SetLoadFactor(v int) *AccountCreate {
-	_c.mutation.SetLoadFactor(v)
-	return _c
-}
-
-// SetNillableLoadFactor sets the "load_factor" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableLoadFactor(v *int) *AccountCreate {
-	if v != nil {
-		_c.SetLoadFactor(*v)
-	}
-	return _c
-}
-
 // SetPriority sets the "priority" field.
 func (_c *AccountCreate) SetPriority(v int) *AccountCreate {
 	_c.mutation.SetPriority(v)
@@ -167,20 +139,6 @@ func (_c *AccountCreate) SetNillablePriority(v *int) *AccountCreate {
 	return _c
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (_c *AccountCreate) SetRateMultiplier(v float64) *AccountCreate {
-	_c.mutation.SetRateMultiplier(v)
-	return _c
-}
-
-// SetNillableRateMultiplier sets the "rate_multiplier" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableRateMultiplier(v *float64) *AccountCreate {
-	if v != nil {
-		_c.SetRateMultiplier(*v)
-	}
-	return _c
-}
-
 // SetStatus sets the "status" field.
 func (_c *AccountCreate) SetStatus(v string) *AccountCreate {
 	_c.mutation.SetStatus(v)
@@ -223,34 +181,6 @@ func (_c *AccountCreate) SetNillableLastUsedAt(v *time.Time) *AccountCreate {
 	return _c
 }
 
-// SetExpiresAt sets the "expires_at" field.
-func (_c *AccountCreate) SetExpiresAt(v time.Time) *AccountCreate {
-	_c.mutation.SetExpiresAt(v)
-	return _c
-}
-
-// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableExpiresAt(v *time.Time) *AccountCreate {
-	if v != nil {
-		_c.SetExpiresAt(*v)
-	}
-	return _c
-}
-
-// SetAutoPauseOnExpired sets the "auto_pause_on_expired" field.
-func (_c *AccountCreate) SetAutoPauseOnExpired(v bool) *AccountCreate {
-	_c.mutation.SetAutoPauseOnExpired(v)
-	return _c
-}
-
-// SetNillableAutoPauseOnExpired sets the "auto_pause_on_expired" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableAutoPauseOnExpired(v *bool) *AccountCreate {
-	if v != nil {
-		_c.SetAutoPauseOnExpired(*v)
-	}
-	return _c
-}
-
 // SetSchedulable sets the "schedulable" field.
 func (_c *AccountCreate) SetSchedulable(v bool) *AccountCreate {
 	_c.mutation.SetSchedulable(v)
@@ -307,34 +237,6 @@ func (_c *AccountCreate) SetNillableOverloadUntil(v *time.Time) *AccountCreate {
 	return _c
 }
 
-// SetTempUnschedulableUntil sets the "temp_unschedulable_until" field.
-func (_c *AccountCreate) SetTempUnschedulableUntil(v time.Time) *AccountCreate {
-	_c.mutation.SetTempUnschedulableUntil(v)
-	return _c
-}
-
-// SetNillableTempUnschedulableUntil sets the "temp_unschedulable_until" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableTempUnschedulableUntil(v *time.Time) *AccountCreate {
-	if v != nil {
-		_c.SetTempUnschedulableUntil(*v)
-	}
-	return _c
-}
-
-// SetTempUnschedulableReason sets the "temp_unschedulable_reason" field.
-func (_c *AccountCreate) SetTempUnschedulableReason(v string) *AccountCreate {
-	_c.mutation.SetTempUnschedulableReason(v)
-	return _c
-}
-
-// SetNillableTempUnschedulableReason sets the "temp_unschedulable_reason" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableTempUnschedulableReason(v *string) *AccountCreate {
-	if v != nil {
-		_c.SetTempUnschedulableReason(*v)
-	}
-	return _c
-}
-
 // SetSessionWindowStart sets the "session_window_start" field.
 func (_c *AccountCreate) SetSessionWindowStart(v time.Time) *AccountCreate {
 	_c.mutation.SetSessionWindowStart(v)
@@ -485,18 +387,10 @@ func (_c *AccountCreate) defaults() error {
 		v := account.DefaultPriority
 		_c.mutation.SetPriority(v)
 	}
-	if _, ok := _c.mutation.RateMultiplier(); !ok {
-		v := account.DefaultRateMultiplier
-		_c.mutation.SetRateMultiplier(v)
-	}
 	if _, ok := _c.mutation.Status(); !ok {
 		v := account.DefaultStatus
 		_c.mutation.SetStatus(v)
 	}
-	if _, ok := _c.mutation.AutoPauseOnExpired(); !ok {
-		v := account.DefaultAutoPauseOnExpired
-		_c.mutation.SetAutoPauseOnExpired(v)
-	}
 	if _, ok := _c.mutation.Schedulable(); !ok {
 		v := account.DefaultSchedulable
 		_c.mutation.SetSchedulable(v)
@@ -548,9 +442,6 @@ func (_c *AccountCreate) check() error {
 	if _, ok := _c.mutation.Priority(); !ok {
 		return &ValidationError{Name: "priority", err: errors.New(`ent: missing required field "Account.priority"`)}
 	}
-	if _, ok := _c.mutation.RateMultiplier(); !ok {
-		return &ValidationError{Name: "rate_multiplier", err: errors.New(`ent: missing required field "Account.rate_multiplier"`)}
-	}
 	if _, ok := _c.mutation.Status(); !ok {
 		return &ValidationError{Name: "status", err: errors.New(`ent: missing required field "Account.status"`)}
 	}
@@ -559,9 +450,6 @@ func (_c *AccountCreate) check() error {
 			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "Account.status": %w`, err)}
 		}
 	}
-	if _, ok := _c.mutation.AutoPauseOnExpired(); !ok {
-		return &ValidationError{Name: "auto_pause_on_expired", err: errors.New(`ent: missing required field "Account.auto_pause_on_expired"`)}
-	}
 	if _, ok := _c.mutation.Schedulable(); !ok {
 		return &ValidationError{Name: "schedulable", err: errors.New(`ent: missing required field "Account.schedulable"`)}
 	}
@@ -613,10 +501,6 @@ func (_c *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_spec.SetField(account.FieldName, field.TypeString, value)
 		_node.Name = value
 	}
-	if value, ok := _c.mutation.Notes(); ok {
-		_spec.SetField(account.FieldNotes, field.TypeString, value)
-		_node.Notes = &value
-	}
 	if value, ok := _c.mutation.Platform(); ok {
 		_spec.SetField(account.FieldPlatform, field.TypeString, value)
 		_node.Platform = value
@@ -637,18 +521,10 @@ func (_c *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_spec.SetField(account.FieldConcurrency, field.TypeInt, value)
 		_node.Concurrency = value
 	}
-	if value, ok := _c.mutation.LoadFactor(); ok {
-		_spec.SetField(account.FieldLoadFactor, field.TypeInt, value)
-		_node.LoadFactor = &value
-	}
 	if value, ok := _c.mutation.Priority(); ok {
 		_spec.SetField(account.FieldPriority, field.TypeInt, value)
 		_node.Priority = value
 	}
-	if value, ok := _c.mutation.RateMultiplier(); ok {
-		_spec.SetField(account.FieldRateMultiplier, field.TypeFloat64, value)
-		_node.RateMultiplier = value
-	}
 	if value, ok := _c.mutation.Status(); ok {
 		_spec.SetField(account.FieldStatus, field.TypeString, value)
 		_node.Status = value
@@ -661,14 +537,6 @@ func (_c *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_spec.SetField(account.FieldLastUsedAt, field.TypeTime, value)
 		_node.LastUsedAt = &value
 	}
-	if value, ok := _c.mutation.ExpiresAt(); ok {
-		_spec.SetField(account.FieldExpiresAt, field.TypeTime, value)
-		_node.ExpiresAt = &value
-	}
-	if value, ok := _c.mutation.AutoPauseOnExpired(); ok {
-		_spec.SetField(account.FieldAutoPauseOnExpired, field.TypeBool, value)
-		_node.AutoPauseOnExpired = value
-	}
 	if value, ok := _c.mutation.Schedulable(); ok {
 		_spec.SetField(account.FieldSchedulable, field.TypeBool, value)
 		_node.Schedulable = value
@@ -685,14 +553,6 @@ func (_c *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_spec.SetField(account.FieldOverloadUntil, field.TypeTime, value)
 		_node.OverloadUntil = &value
 	}
-	if value, ok := _c.mutation.TempUnschedulableUntil(); ok {
-		_spec.SetField(account.FieldTempUnschedulableUntil, field.TypeTime, value)
-		_node.TempUnschedulableUntil = &value
-	}
-	if value, ok := _c.mutation.TempUnschedulableReason(); ok {
-		_spec.SetField(account.FieldTempUnschedulableReason, field.TypeString, value)
-		_node.TempUnschedulableReason = &value
-	}
 	if value, ok := _c.mutation.SessionWindowStart(); ok {
 		_spec.SetField(account.FieldSessionWindowStart, field.TypeTime, value)
 		_node.SessionWindowStart = &value
@@ -852,24 +712,6 @@ func (u *AccountUpsert) UpdateName() *AccountUpsert {
 	return u
 }
 
-// SetNotes sets the "notes" field.
-func (u *AccountUpsert) SetNotes(v string) *AccountUpsert {
-	u.Set(account.FieldNotes, v)
-	return u
-}
-
-// UpdateNotes sets the "notes" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateNotes() *AccountUpsert {
-	u.SetExcluded(account.FieldNotes)
-	return u
-}
-
-// ClearNotes clears the value of the "notes" field.
-func (u *AccountUpsert) ClearNotes() *AccountUpsert {
-	u.SetNull(account.FieldNotes)
-	return u
-}
-
 // SetPlatform sets the "platform" field.
 func (u *AccountUpsert) SetPlatform(v string) *AccountUpsert {
 	u.Set(account.FieldPlatform, v)
@@ -954,30 +796,6 @@ func (u *AccountUpsert) AddConcurrency(v int) *AccountUpsert {
 	return u
 }
 
-// SetLoadFactor sets the "load_factor" field.
-func (u *AccountUpsert) SetLoadFactor(v int) *AccountUpsert {
-	u.Set(account.FieldLoadFactor, v)
-	return u
-}
-
-// UpdateLoadFactor sets the "load_factor" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateLoadFactor() *AccountUpsert {
-	u.SetExcluded(account.FieldLoadFactor)
-	return u
-}
-
-// AddLoadFactor adds v to the "load_factor" field.
-func (u *AccountUpsert) AddLoadFactor(v int) *AccountUpsert {
-	u.Add(account.FieldLoadFactor, v)
-	return u
-}
-
-// ClearLoadFactor clears the value of the "load_factor" field.
-func (u *AccountUpsert) ClearLoadFactor() *AccountUpsert {
-	u.SetNull(account.FieldLoadFactor)
-	return u
-}
-
 // SetPriority sets the "priority" field.
 func (u *AccountUpsert) SetPriority(v int) *AccountUpsert {
 	u.Set(account.FieldPriority, v)
@@ -996,24 +814,6 @@ func (u *AccountUpsert) AddPriority(v int) *AccountUpsert {
 	return u
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (u *AccountUpsert) SetRateMultiplier(v float64) *AccountUpsert {
-	u.Set(account.FieldRateMultiplier, v)
-	return u
-}
-
-// UpdateRateMultiplier sets the "rate_multiplier" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateRateMultiplier() *AccountUpsert {
-	u.SetExcluded(account.FieldRateMultiplier)
-	return u
-}
-
-// AddRateMultiplier adds v to the "rate_multiplier" field.
-func (u *AccountUpsert) AddRateMultiplier(v float64) *AccountUpsert {
-	u.Add(account.FieldRateMultiplier, v)
-	return u
-}
-
 // SetStatus sets the "status" field.
 func (u *AccountUpsert) SetStatus(v string) *AccountUpsert {
 	u.Set(account.FieldStatus, v)
@@ -1062,36 +862,6 @@ func (u *AccountUpsert) ClearLastUsedAt() *AccountUpsert {
 	return u
 }
 
-// SetExpiresAt sets the "expires_at" field.
-func (u *AccountUpsert) SetExpiresAt(v time.Time) *AccountUpsert {
-	u.Set(account.FieldExpiresAt, v)
-	return u
-}
-
-// UpdateExpiresAt sets the "expires_at" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateExpiresAt() *AccountUpsert {
-	u.SetExcluded(account.FieldExpiresAt)
-	return u
-}
-
-// ClearExpiresAt clears the value of the "expires_at" field.
-func (u *AccountUpsert) ClearExpiresAt() *AccountUpsert {
-	u.SetNull(account.FieldExpiresAt)
-	return u
-}
-
-// SetAutoPauseOnExpired sets the "auto_pause_on_expired" field.
-func (u *AccountUpsert) SetAutoPauseOnExpired(v bool) *AccountUpsert {
-	u.Set(account.FieldAutoPauseOnExpired, v)
-	return u
-}
-
-// UpdateAutoPauseOnExpired sets the "auto_pause_on_expired" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateAutoPauseOnExpired() *AccountUpsert {
-	u.SetExcluded(account.FieldAutoPauseOnExpired)
-	return u
-}
-
 // SetSchedulable sets the "schedulable" field.
 func (u *AccountUpsert) SetSchedulable(v bool) *AccountUpsert {
 	u.Set(account.FieldSchedulable, v)
@@ -1158,42 +928,6 @@ func (u *AccountUpsert) ClearOverloadUntil() *AccountUpsert {
 	return u
 }
 
-// SetTempUnschedulableUntil sets the "temp_unschedulable_until" field.
-func (u *AccountUpsert) SetTempUnschedulableUntil(v time.Time) *AccountUpsert {
-	u.Set(account.FieldTempUnschedulableUntil, v)
-	return u
-}
-
-// UpdateTempUnschedulableUntil sets the "temp_unschedulable_until" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateTempUnschedulableUntil() *AccountUpsert {
-	u.SetExcluded(account.FieldTempUnschedulableUntil)
-	return u
-}
-
-// ClearTempUnschedulableUntil clears the value of the "temp_unschedulable_until" field.
-func (u *AccountUpsert) ClearTempUnschedulableUntil() *AccountUpsert {
-	u.SetNull(account.FieldTempUnschedulableUntil)
-	return u
-}
-
-// SetTempUnschedulableReason sets the "temp_unschedulable_reason" field.
-func (u *AccountUpsert) SetTempUnschedulableReason(v string) *AccountUpsert {
-	u.Set(account.FieldTempUnschedulableReason, v)
-	return u
-}
-
-// UpdateTempUnschedulableReason sets the "temp_unschedulable_reason" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateTempUnschedulableReason() *AccountUpsert {
-	u.SetExcluded(account.FieldTempUnschedulableReason)
-	return u
-}
-
-// ClearTempUnschedulableReason clears the value of the "temp_unschedulable_reason" field.
-func (u *AccountUpsert) ClearTempUnschedulableReason() *AccountUpsert {
-	u.SetNull(account.FieldTempUnschedulableReason)
-	return u
-}
-
 // SetSessionWindowStart sets the "session_window_start" field.
 func (u *AccountUpsert) SetSessionWindowStart(v time.Time) *AccountUpsert {
 	u.Set(account.FieldSessionWindowStart, v)
@@ -1342,27 +1076,6 @@ func (u *AccountUpsertOne) UpdateName() *AccountUpsertOne {
 	})
 }
 
-// SetNotes sets the "notes" field.
-func (u *AccountUpsertOne) SetNotes(v string) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetNotes(v)
-	})
-}
-
-// UpdateNotes sets the "notes" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateNotes() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateNotes()
-	})
-}
-
-// ClearNotes clears the value of the "notes" field.
-func (u *AccountUpsertOne) ClearNotes() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearNotes()
-	})
-}
-
 // SetPlatform sets the "platform" field.
 func (u *AccountUpsertOne) SetPlatform(v string) *AccountUpsertOne {
 	return u.Update(func(s *AccountUpsert) {
@@ -1461,34 +1174,6 @@ func (u *AccountUpsertOne) UpdateConcurrency() *AccountUpsertOne {
 	})
 }
 
-// SetLoadFactor sets the "load_factor" field.
-func (u *AccountUpsertOne) SetLoadFactor(v int) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetLoadFactor(v)
-	})
-}
-
-// AddLoadFactor adds v to the "load_factor" field.
-func (u *AccountUpsertOne) AddLoadFactor(v int) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.AddLoadFactor(v)
-	})
-}
-
-// UpdateLoadFactor sets the "load_factor" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateLoadFactor() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateLoadFactor()
-	})
-}
-
-// ClearLoadFactor clears the value of the "load_factor" field.
-func (u *AccountUpsertOne) ClearLoadFactor() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearLoadFactor()
-	})
-}
-
 // SetPriority sets the "priority" field.
 func (u *AccountUpsertOne) SetPriority(v int) *AccountUpsertOne {
 	return u.Update(func(s *AccountUpsert) {
@@ -1510,27 +1195,6 @@ func (u *AccountUpsertOne) UpdatePriority() *AccountUpsertOne {
 	})
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (u *AccountUpsertOne) SetRateMultiplier(v float64) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetRateMultiplier(v)
-	})
-}
-
-// AddRateMultiplier adds v to the "rate_multiplier" field.
-func (u *AccountUpsertOne) AddRateMultiplier(v float64) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.AddRateMultiplier(v)
-	})
-}
-
-// UpdateRateMultiplier sets the "rate_multiplier" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateRateMultiplier() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateRateMultiplier()
-	})
-}
-
 // SetStatus sets the "status" field.
 func (u *AccountUpsertOne) SetStatus(v string) *AccountUpsertOne {
 	return u.Update(func(s *AccountUpsert) {
@@ -1587,41 +1251,6 @@ func (u *AccountUpsertOne) ClearLastUsedAt() *AccountUpsertOne {
 	})
 }
 
-// SetExpiresAt sets the "expires_at" field.
-func (u *AccountUpsertOne) SetExpiresAt(v time.Time) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetExpiresAt(v)
-	})
-}
-
-// UpdateExpiresAt sets the "expires_at" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateExpiresAt() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateExpiresAt()
-	})
-}
-
-// ClearExpiresAt clears the value of the "expires_at" field.
-func (u *AccountUpsertOne) ClearExpiresAt() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearExpiresAt()
-	})
-}
-
-// SetAutoPauseOnExpired sets the "auto_pause_on_expired" field.
-func (u *AccountUpsertOne) SetAutoPauseOnExpired(v bool) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetAutoPauseOnExpired(v)
-	})
-}
-
-// UpdateAutoPauseOnExpired sets the "auto_pause_on_expired" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateAutoPauseOnExpired() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateAutoPauseOnExpired()
-	})
-}
-
 // SetSchedulable sets the "schedulable" field.
 func (u *AccountUpsertOne) SetSchedulable(v bool) *AccountUpsertOne {
 	return u.Update(func(s *AccountUpsert) {
@@ -1699,48 +1328,6 @@ func (u *AccountUpsertOne) ClearOverloadUntil() *AccountUpsertOne {
 	})
 }
 
-// SetTempUnschedulableUntil sets the "temp_unschedulable_until" field.
-func (u *AccountUpsertOne) SetTempUnschedulableUntil(v time.Time) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetTempUnschedulableUntil(v)
-	})
-}
-
-// UpdateTempUnschedulableUntil sets the "temp_unschedulable_until" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateTempUnschedulableUntil() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateTempUnschedulableUntil()
-	})
-}
-
-// ClearTempUnschedulableUntil clears the value of the "temp_unschedulable_until" field.
-func (u *AccountUpsertOne) ClearTempUnschedulableUntil() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearTempUnschedulableUntil()
-	})
-}
-
-// SetTempUnschedulableReason sets the "temp_unschedulable_reason" field.
-func (u *AccountUpsertOne) SetTempUnschedulableReason(v string) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetTempUnschedulableReason(v)
-	})
-}
-
-// UpdateTempUnschedulableReason sets the "temp_unschedulable_reason" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateTempUnschedulableReason() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateTempUnschedulableReason()
-	})
-}
-
-// ClearTempUnschedulableReason clears the value of the "temp_unschedulable_reason" field.
-func (u *AccountUpsertOne) ClearTempUnschedulableReason() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearTempUnschedulableReason()
-	})
-}
-
 // SetSessionWindowStart sets the "session_window_start" field.
 func (u *AccountUpsertOne) SetSessionWindowStart(v time.Time) *AccountUpsertOne {
 	return u.Update(func(s *AccountUpsert) {
@@ -2064,27 +1651,6 @@ func (u *AccountUpsertBulk) UpdateName() *AccountUpsertBulk {
 	})
 }
 
-// SetNotes sets the "notes" field.
-func (u *AccountUpsertBulk) SetNotes(v string) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetNotes(v)
-	})
-}
-
-// UpdateNotes sets the "notes" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateNotes() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateNotes()
-	})
-}
-
-// ClearNotes clears the value of the "notes" field.
-func (u *AccountUpsertBulk) ClearNotes() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearNotes()
-	})
-}
-
 // SetPlatform sets the "platform" field.
 func (u *AccountUpsertBulk) SetPlatform(v string) *AccountUpsertBulk {
 	return u.Update(func(s *AccountUpsert) {
@@ -2183,34 +1749,6 @@ func (u *AccountUpsertBulk) UpdateConcurrency() *AccountUpsertBulk {
 	})
 }
 
-// SetLoadFactor sets the "load_factor" field.
-func (u *AccountUpsertBulk) SetLoadFactor(v int) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetLoadFactor(v)
-	})
-}
-
-// AddLoadFactor adds v to the "load_factor" field.
-func (u *AccountUpsertBulk) AddLoadFactor(v int) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.AddLoadFactor(v)
-	})
-}
-
-// UpdateLoadFactor sets the "load_factor" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateLoadFactor() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateLoadFactor()
-	})
-}
-
-// ClearLoadFactor clears the value of the "load_factor" field.
-func (u *AccountUpsertBulk) ClearLoadFactor() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearLoadFactor()
-	})
-}
-
 // SetPriority sets the "priority" field.
 func (u *AccountUpsertBulk) SetPriority(v int) *AccountUpsertBulk {
 	return u.Update(func(s *AccountUpsert) {
@@ -2232,27 +1770,6 @@ func (u *AccountUpsertBulk) UpdatePriority() *AccountUpsertBulk {
 	})
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (u *AccountUpsertBulk) SetRateMultiplier(v float64) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetRateMultiplier(v)
-	})
-}
-
-// AddRateMultiplier adds v to the "rate_multiplier" field.
-func (u *AccountUpsertBulk) AddRateMultiplier(v float64) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.AddRateMultiplier(v)
-	})
-}
-
-// UpdateRateMultiplier sets the "rate_multiplier" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateRateMultiplier() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateRateMultiplier()
-	})
-}
-
 // SetStatus sets the "status" field.
 func (u *AccountUpsertBulk) SetStatus(v string) *AccountUpsertBulk {
 	return u.Update(func(s *AccountUpsert) {
@@ -2309,41 +1826,6 @@ func (u *AccountUpsertBulk) ClearLastUsedAt() *AccountUpsertBulk {
 	})
 }
 
-// SetExpiresAt sets the "expires_at" field.
-func (u *AccountUpsertBulk) SetExpiresAt(v time.Time) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetExpiresAt(v)
-	})
-}
-
-// UpdateExpiresAt sets the "expires_at" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateExpiresAt() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateExpiresAt()
-	})
-}
-
-// ClearExpiresAt clears the value of the "expires_at" field.
-func (u *AccountUpsertBulk) ClearExpiresAt() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearExpiresAt()
-	})
-}
-
-// SetAutoPauseOnExpired sets the "auto_pause_on_expired" field.
-func (u *AccountUpsertBulk) SetAutoPauseOnExpired(v bool) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetAutoPauseOnExpired(v)
-	})
-}
-
-// UpdateAutoPauseOnExpired sets the "auto_pause_on_expired" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateAutoPauseOnExpired() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateAutoPauseOnExpired()
-	})
-}
-
 // SetSchedulable sets the "schedulable" field.
 func (u *AccountUpsertBulk) SetSchedulable(v bool) *AccountUpsertBulk {
 	return u.Update(func(s *AccountUpsert) {
@@ -2421,48 +1903,6 @@ func (u *AccountUpsertBulk) ClearOverloadUntil() *AccountUpsertBulk {
 	})
 }
 
-// SetTempUnschedulableUntil sets the "temp_unschedulable_until" field.
-func (u *AccountUpsertBulk) SetTempUnschedulableUntil(v time.Time) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetTempUnschedulableUntil(v)
-	})
-}
-
-// UpdateTempUnschedulableUntil sets the "temp_unschedulable_until" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateTempUnschedulableUntil() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateTempUnschedulableUntil()
-	})
-}
-
-// ClearTempUnschedulableUntil clears the value of the "temp_unschedulable_until" field.
-func (u *AccountUpsertBulk) ClearTempUnschedulableUntil() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearTempUnschedulableUntil()
-	})
-}
-
-// SetTempUnschedulableReason sets the "temp_unschedulable_reason" field.
-func (u *AccountUpsertBulk) SetTempUnschedulableReason(v string) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetTempUnschedulableReason(v)
-	})
-}
-
-// UpdateTempUnschedulableReason sets the "temp_unschedulable_reason" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateTempUnschedulableReason() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateTempUnschedulableReason()
-	})
-}
-
-// ClearTempUnschedulableReason clears the value of the "temp_unschedulable_reason" field.
-func (u *AccountUpsertBulk) ClearTempUnschedulableReason() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.ClearTempUnschedulableReason()
-	})
-}
-
 // SetSessionWindowStart sets the "session_window_start" field.
 func (u *AccountUpsertBulk) SetSessionWindowStart(v time.Time) *AccountUpsertBulk {
 	return u.Update(func(s *AccountUpsert) {

backend/ent/account_query.go

@@ -9,7 +9,6 @@ import (
 	"math"
 
 	"entgo.io/ent"
-	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -32,7 +31,6 @@ type AccountQuery struct {
 	withProxy         *ProxyQuery
 	withUsageLogs     *UsageLogQuery
 	withAccountGroups *AccountGroupQuery
-	modifiers         []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -497,9 +495,6 @@ func (_q *AccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Acco
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -695,9 +690,6 @@ func (_q *AccountQuery) loadAccountGroups(ctx context.Context, query *AccountGro
 
 func (_q *AccountQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	_spec.Node.Columns = _q.ctx.Fields
 	if len(_q.ctx.Fields) > 0 {
 		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
@@ -763,9 +755,6 @@ func (_q *AccountQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if _q.ctx.Unique != nil && *_q.ctx.Unique {
 		selector.Distinct()
 	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
 	for _, p := range _q.predicates {
 		p(selector)
 	}
@@ -783,32 +772,6 @@ func (_q *AccountQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *AccountQuery) ForUpdate(opts ...sql.LockOption) *AccountQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *AccountQuery) ForShare(opts ...sql.LockOption) *AccountQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // AccountGroupBy is the group-by builder for Account entities.
 type AccountGroupBy struct {
 	selector

backend/ent/account_update.go

@@ -71,26 +71,6 @@ func (_u *AccountUpdate) SetNillableName(v *string) *AccountUpdate {
 	return _u
 }
 
-// SetNotes sets the "notes" field.
-func (_u *AccountUpdate) SetNotes(v string) *AccountUpdate {
-	_u.mutation.SetNotes(v)
-	return _u
-}
-
-// SetNillableNotes sets the "notes" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableNotes(v *string) *AccountUpdate {
-	if v != nil {
-		_u.SetNotes(*v)
-	}
-	return _u
-}
-
-// ClearNotes clears the value of the "notes" field.
-func (_u *AccountUpdate) ClearNotes() *AccountUpdate {
-	_u.mutation.ClearNotes()
-	return _u
-}
-
 // SetPlatform sets the "platform" field.
 func (_u *AccountUpdate) SetPlatform(v string) *AccountUpdate {
 	_u.mutation.SetPlatform(v)
@@ -172,33 +152,6 @@ func (_u *AccountUpdate) AddConcurrency(v int) *AccountUpdate {
 	return _u
 }
 
-// SetLoadFactor sets the "load_factor" field.
-func (_u *AccountUpdate) SetLoadFactor(v int) *AccountUpdate {
-	_u.mutation.ResetLoadFactor()
-	_u.mutation.SetLoadFactor(v)
-	return _u
-}
-
-// SetNillableLoadFactor sets the "load_factor" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableLoadFactor(v *int) *AccountUpdate {
-	if v != nil {
-		_u.SetLoadFactor(*v)
-	}
-	return _u
-}
-
-// AddLoadFactor adds value to the "load_factor" field.
-func (_u *AccountUpdate) AddLoadFactor(v int) *AccountUpdate {
-	_u.mutation.AddLoadFactor(v)
-	return _u
-}
-
-// ClearLoadFactor clears the value of the "load_factor" field.
-func (_u *AccountUpdate) ClearLoadFactor() *AccountUpdate {
-	_u.mutation.ClearLoadFactor()
-	return _u
-}
-
 // SetPriority sets the "priority" field.
 func (_u *AccountUpdate) SetPriority(v int) *AccountUpdate {
 	_u.mutation.ResetPriority()
@@ -220,27 +173,6 @@ func (_u *AccountUpdate) AddPriority(v int) *AccountUpdate {
 	return _u
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (_u *AccountUpdate) SetRateMultiplier(v float64) *AccountUpdate {
-	_u.mutation.ResetRateMultiplier()
-	_u.mutation.SetRateMultiplier(v)
-	return _u
-}
-
-// SetNillableRateMultiplier sets the "rate_multiplier" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableRateMultiplier(v *float64) *AccountUpdate {
-	if v != nil {
-		_u.SetRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddRateMultiplier adds value to the "rate_multiplier" field.
-func (_u *AccountUpdate) AddRateMultiplier(v float64) *AccountUpdate {
-	_u.mutation.AddRateMultiplier(v)
-	return _u
-}
-
 // SetStatus sets the "status" field.
 func (_u *AccountUpdate) SetStatus(v string) *AccountUpdate {
 	_u.mutation.SetStatus(v)
@@ -295,40 +227,6 @@ func (_u *AccountUpdate) ClearLastUsedAt() *AccountUpdate {
 	return _u
 }
 
-// SetExpiresAt sets the "expires_at" field.
-func (_u *AccountUpdate) SetExpiresAt(v time.Time) *AccountUpdate {
-	_u.mutation.SetExpiresAt(v)
-	return _u
-}
-
-// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableExpiresAt(v *time.Time) *AccountUpdate {
-	if v != nil {
-		_u.SetExpiresAt(*v)
-	}
-	return _u
-}
-
-// ClearExpiresAt clears the value of the "expires_at" field.
-func (_u *AccountUpdate) ClearExpiresAt() *AccountUpdate {
-	_u.mutation.ClearExpiresAt()
-	return _u
-}
-
-// SetAutoPauseOnExpired sets the "auto_pause_on_expired" field.
-func (_u *AccountUpdate) SetAutoPauseOnExpired(v bool) *AccountUpdate {
-	_u.mutation.SetAutoPauseOnExpired(v)
-	return _u
-}
-
-// SetNillableAutoPauseOnExpired sets the "auto_pause_on_expired" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableAutoPauseOnExpired(v *bool) *AccountUpdate {
-	if v != nil {
-		_u.SetAutoPauseOnExpired(*v)
-	}
-	return _u
-}
-
 // SetSchedulable sets the "schedulable" field.
 func (_u *AccountUpdate) SetSchedulable(v bool) *AccountUpdate {
 	_u.mutation.SetSchedulable(v)
@@ -403,46 +301,6 @@ func (_u *AccountUpdate) ClearOverloadUntil() *AccountUpdate {
 	return _u
 }
 
-// SetTempUnschedulableUntil sets the "temp_unschedulable_until" field.
-func (_u *AccountUpdate) SetTempUnschedulableUntil(v time.Time) *AccountUpdate {
-	_u.mutation.SetTempUnschedulableUntil(v)
-	return _u
-}
-
-// SetNillableTempUnschedulableUntil sets the "temp_unschedulable_until" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableTempUnschedulableUntil(v *time.Time) *AccountUpdate {
-	if v != nil {
-		_u.SetTempUnschedulableUntil(*v)
-	}
-	return _u
-}
-
-// ClearTempUnschedulableUntil clears the value of the "temp_unschedulable_until" field.
-func (_u *AccountUpdate) ClearTempUnschedulableUntil() *AccountUpdate {
-	_u.mutation.ClearTempUnschedulableUntil()
-	return _u
-}
-
-// SetTempUnschedulableReason sets the "temp_unschedulable_reason" field.
-func (_u *AccountUpdate) SetTempUnschedulableReason(v string) *AccountUpdate {
-	_u.mutation.SetTempUnschedulableReason(v)
-	return _u
-}
-
-// SetNillableTempUnschedulableReason sets the "temp_unschedulable_reason" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableTempUnschedulableReason(v *string) *AccountUpdate {
-	if v != nil {
-		_u.SetTempUnschedulableReason(*v)
-	}
-	return _u
-}
-
-// ClearTempUnschedulableReason clears the value of the "temp_unschedulable_reason" field.
-func (_u *AccountUpdate) ClearTempUnschedulableReason() *AccountUpdate {
-	_u.mutation.ClearTempUnschedulableReason()
-	return _u
-}
-
 // SetSessionWindowStart sets the "session_window_start" field.
 func (_u *AccountUpdate) SetSessionWindowStart(v time.Time) *AccountUpdate {
 	_u.mutation.SetSessionWindowStart(v)
@@ -687,12 +545,6 @@ func (_u *AccountUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.Name(); ok {
 		_spec.SetField(account.FieldName, field.TypeString, value)
 	}
-	if value, ok := _u.mutation.Notes(); ok {
-		_spec.SetField(account.FieldNotes, field.TypeString, value)
-	}
-	if _u.mutation.NotesCleared() {
-		_spec.ClearField(account.FieldNotes, field.TypeString)
-	}
 	if value, ok := _u.mutation.Platform(); ok {
 		_spec.SetField(account.FieldPlatform, field.TypeString, value)
 	}
@@ -711,27 +563,12 @@ func (_u *AccountUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.AddedConcurrency(); ok {
 		_spec.AddField(account.FieldConcurrency, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.LoadFactor(); ok {
-		_spec.SetField(account.FieldLoadFactor, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedLoadFactor(); ok {
-		_spec.AddField(account.FieldLoadFactor, field.TypeInt, value)
-	}
-	if _u.mutation.LoadFactorCleared() {
-		_spec.ClearField(account.FieldLoadFactor, field.TypeInt)
-	}
 	if value, ok := _u.mutation.Priority(); ok {
 		_spec.SetField(account.FieldPriority, field.TypeInt, value)
 	}
 	if value, ok := _u.mutation.AddedPriority(); ok {
 		_spec.AddField(account.FieldPriority, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.RateMultiplier(); ok {
-		_spec.SetField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
-		_spec.AddField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
 	if value, ok := _u.mutation.Status(); ok {
 		_spec.SetField(account.FieldStatus, field.TypeString, value)
 	}
@@ -747,15 +584,6 @@ func (_u *AccountUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if _u.mutation.LastUsedAtCleared() {
 		_spec.ClearField(account.FieldLastUsedAt, field.TypeTime)
 	}
-	if value, ok := _u.mutation.ExpiresAt(); ok {
-		_spec.SetField(account.FieldExpiresAt, field.TypeTime, value)
-	}
-	if _u.mutation.ExpiresAtCleared() {
-		_spec.ClearField(account.FieldExpiresAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.AutoPauseOnExpired(); ok {
-		_spec.SetField(account.FieldAutoPauseOnExpired, field.TypeBool, value)
-	}
 	if value, ok := _u.mutation.Schedulable(); ok {
 		_spec.SetField(account.FieldSchedulable, field.TypeBool, value)
 	}
@@ -777,18 +605,6 @@ func (_u *AccountUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if _u.mutation.OverloadUntilCleared() {
 		_spec.ClearField(account.FieldOverloadUntil, field.TypeTime)
 	}
-	if value, ok := _u.mutation.TempUnschedulableUntil(); ok {
-		_spec.SetField(account.FieldTempUnschedulableUntil, field.TypeTime, value)
-	}
-	if _u.mutation.TempUnschedulableUntilCleared() {
-		_spec.ClearField(account.FieldTempUnschedulableUntil, field.TypeTime)
-	}
-	if value, ok := _u.mutation.TempUnschedulableReason(); ok {
-		_spec.SetField(account.FieldTempUnschedulableReason, field.TypeString, value)
-	}
-	if _u.mutation.TempUnschedulableReasonCleared() {
-		_spec.ClearField(account.FieldTempUnschedulableReason, field.TypeString)
-	}
 	if value, ok := _u.mutation.SessionWindowStart(); ok {
 		_spec.SetField(account.FieldSessionWindowStart, field.TypeTime, value)
 	}
@@ -998,26 +814,6 @@ func (_u *AccountUpdateOne) SetNillableName(v *string) *AccountUpdateOne {
 	return _u
 }
 
-// SetNotes sets the "notes" field.
-func (_u *AccountUpdateOne) SetNotes(v string) *AccountUpdateOne {
-	_u.mutation.SetNotes(v)
-	return _u
-}
-
-// SetNillableNotes sets the "notes" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableNotes(v *string) *AccountUpdateOne {
-	if v != nil {
-		_u.SetNotes(*v)
-	}
-	return _u
-}
-
-// ClearNotes clears the value of the "notes" field.
-func (_u *AccountUpdateOne) ClearNotes() *AccountUpdateOne {
-	_u.mutation.ClearNotes()
-	return _u
-}
-
 // SetPlatform sets the "platform" field.
 func (_u *AccountUpdateOne) SetPlatform(v string) *AccountUpdateOne {
 	_u.mutation.SetPlatform(v)
@@ -1099,33 +895,6 @@ func (_u *AccountUpdateOne) AddConcurrency(v int) *AccountUpdateOne {
 	return _u
 }
 
-// SetLoadFactor sets the "load_factor" field.
-func (_u *AccountUpdateOne) SetLoadFactor(v int) *AccountUpdateOne {
-	_u.mutation.ResetLoadFactor()
-	_u.mutation.SetLoadFactor(v)
-	return _u
-}
-
-// SetNillableLoadFactor sets the "load_factor" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableLoadFactor(v *int) *AccountUpdateOne {
-	if v != nil {
-		_u.SetLoadFactor(*v)
-	}
-	return _u
-}
-
-// AddLoadFactor adds value to the "load_factor" field.
-func (_u *AccountUpdateOne) AddLoadFactor(v int) *AccountUpdateOne {
-	_u.mutation.AddLoadFactor(v)
-	return _u
-}
-
-// ClearLoadFactor clears the value of the "load_factor" field.
-func (_u *AccountUpdateOne) ClearLoadFactor() *AccountUpdateOne {
-	_u.mutation.ClearLoadFactor()
-	return _u
-}
-
 // SetPriority sets the "priority" field.
 func (_u *AccountUpdateOne) SetPriority(v int) *AccountUpdateOne {
 	_u.mutation.ResetPriority()
@@ -1147,27 +916,6 @@ func (_u *AccountUpdateOne) AddPriority(v int) *AccountUpdateOne {
 	return _u
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (_u *AccountUpdateOne) SetRateMultiplier(v float64) *AccountUpdateOne {
-	_u.mutation.ResetRateMultiplier()
-	_u.mutation.SetRateMultiplier(v)
-	return _u
-}
-
-// SetNillableRateMultiplier sets the "rate_multiplier" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableRateMultiplier(v *float64) *AccountUpdateOne {
-	if v != nil {
-		_u.SetRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddRateMultiplier adds value to the "rate_multiplier" field.
-func (_u *AccountUpdateOne) AddRateMultiplier(v float64) *AccountUpdateOne {
-	_u.mutation.AddRateMultiplier(v)
-	return _u
-}
-
 // SetStatus sets the "status" field.
 func (_u *AccountUpdateOne) SetStatus(v string) *AccountUpdateOne {
 	_u.mutation.SetStatus(v)
@@ -1222,40 +970,6 @@ func (_u *AccountUpdateOne) ClearLastUsedAt() *AccountUpdateOne {
 	return _u
 }
 
-// SetExpiresAt sets the "expires_at" field.
-func (_u *AccountUpdateOne) SetExpiresAt(v time.Time) *AccountUpdateOne {
-	_u.mutation.SetExpiresAt(v)
-	return _u
-}
-
-// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableExpiresAt(v *time.Time) *AccountUpdateOne {
-	if v != nil {
-		_u.SetExpiresAt(*v)
-	}
-	return _u
-}
-
-// ClearExpiresAt clears the value of the "expires_at" field.
-func (_u *AccountUpdateOne) ClearExpiresAt() *AccountUpdateOne {
-	_u.mutation.ClearExpiresAt()
-	return _u
-}
-
-// SetAutoPauseOnExpired sets the "auto_pause_on_expired" field.
-func (_u *AccountUpdateOne) SetAutoPauseOnExpired(v bool) *AccountUpdateOne {
-	_u.mutation.SetAutoPauseOnExpired(v)
-	return _u
-}
-
-// SetNillableAutoPauseOnExpired sets the "auto_pause_on_expired" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableAutoPauseOnExpired(v *bool) *AccountUpdateOne {
-	if v != nil {
-		_u.SetAutoPauseOnExpired(*v)
-	}
-	return _u
-}
-
 // SetSchedulable sets the "schedulable" field.
 func (_u *AccountUpdateOne) SetSchedulable(v bool) *AccountUpdateOne {
 	_u.mutation.SetSchedulable(v)
@@ -1330,46 +1044,6 @@ func (_u *AccountUpdateOne) ClearOverloadUntil() *AccountUpdateOne {
 	return _u
 }
 
-// SetTempUnschedulableUntil sets the "temp_unschedulable_until" field.
-func (_u *AccountUpdateOne) SetTempUnschedulableUntil(v time.Time) *AccountUpdateOne {
-	_u.mutation.SetTempUnschedulableUntil(v)
-	return _u
-}
-
-// SetNillableTempUnschedulableUntil sets the "temp_unschedulable_until" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableTempUnschedulableUntil(v *time.Time) *AccountUpdateOne {
-	if v != nil {
-		_u.SetTempUnschedulableUntil(*v)
-	}
-	return _u
-}
-
-// ClearTempUnschedulableUntil clears the value of the "temp_unschedulable_until" field.
-func (_u *AccountUpdateOne) ClearTempUnschedulableUntil() *AccountUpdateOne {
-	_u.mutation.ClearTempUnschedulableUntil()
-	return _u
-}
-
-// SetTempUnschedulableReason sets the "temp_unschedulable_reason" field.
-func (_u *AccountUpdateOne) SetTempUnschedulableReason(v string) *AccountUpdateOne {
-	_u.mutation.SetTempUnschedulableReason(v)
-	return _u
-}
-
-// SetNillableTempUnschedulableReason sets the "temp_unschedulable_reason" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableTempUnschedulableReason(v *string) *AccountUpdateOne {
-	if v != nil {
-		_u.SetTempUnschedulableReason(*v)
-	}
-	return _u
-}
-
-// ClearTempUnschedulableReason clears the value of the "temp_unschedulable_reason" field.
-func (_u *AccountUpdateOne) ClearTempUnschedulableReason() *AccountUpdateOne {
-	_u.mutation.ClearTempUnschedulableReason()
-	return _u
-}
-
 // SetSessionWindowStart sets the "session_window_start" field.
 func (_u *AccountUpdateOne) SetSessionWindowStart(v time.Time) *AccountUpdateOne {
 	_u.mutation.SetSessionWindowStart(v)
@@ -1644,12 +1318,6 @@ func (_u *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err er
 	if value, ok := _u.mutation.Name(); ok {
 		_spec.SetField(account.FieldName, field.TypeString, value)
 	}
-	if value, ok := _u.mutation.Notes(); ok {
-		_spec.SetField(account.FieldNotes, field.TypeString, value)
-	}
-	if _u.mutation.NotesCleared() {
-		_spec.ClearField(account.FieldNotes, field.TypeString)
-	}
 	if value, ok := _u.mutation.Platform(); ok {
 		_spec.SetField(account.FieldPlatform, field.TypeString, value)
 	}
@@ -1668,27 +1336,12 @@ func (_u *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err er
 	if value, ok := _u.mutation.AddedConcurrency(); ok {
 		_spec.AddField(account.FieldConcurrency, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.LoadFactor(); ok {
-		_spec.SetField(account.FieldLoadFactor, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedLoadFactor(); ok {
-		_spec.AddField(account.FieldLoadFactor, field.TypeInt, value)
-	}
-	if _u.mutation.LoadFactorCleared() {
-		_spec.ClearField(account.FieldLoadFactor, field.TypeInt)
-	}
 	if value, ok := _u.mutation.Priority(); ok {
 		_spec.SetField(account.FieldPriority, field.TypeInt, value)
 	}
 	if value, ok := _u.mutation.AddedPriority(); ok {
 		_spec.AddField(account.FieldPriority, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.RateMultiplier(); ok {
-		_spec.SetField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
-		_spec.AddField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
 	if value, ok := _u.mutation.Status(); ok {
 		_spec.SetField(account.FieldStatus, field.TypeString, value)
 	}
@@ -1704,15 +1357,6 @@ func (_u *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err er
 	if _u.mutation.LastUsedAtCleared() {
 		_spec.ClearField(account.FieldLastUsedAt, field.TypeTime)
 	}
-	if value, ok := _u.mutation.ExpiresAt(); ok {
-		_spec.SetField(account.FieldExpiresAt, field.TypeTime, value)
-	}
-	if _u.mutation.ExpiresAtCleared() {
-		_spec.ClearField(account.FieldExpiresAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.AutoPauseOnExpired(); ok {
-		_spec.SetField(account.FieldAutoPauseOnExpired, field.TypeBool, value)
-	}
 	if value, ok := _u.mutation.Schedulable(); ok {
 		_spec.SetField(account.FieldSchedulable, field.TypeBool, value)
 	}
@@ -1734,18 +1378,6 @@ func (_u *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err er
 	if _u.mutation.OverloadUntilCleared() {
 		_spec.ClearField(account.FieldOverloadUntil, field.TypeTime)
 	}
-	if value, ok := _u.mutation.TempUnschedulableUntil(); ok {
-		_spec.SetField(account.FieldTempUnschedulableUntil, field.TypeTime, value)
-	}
-	if _u.mutation.TempUnschedulableUntilCleared() {
-		_spec.ClearField(account.FieldTempUnschedulableUntil, field.TypeTime)
-	}
-	if value, ok := _u.mutation.TempUnschedulableReason(); ok {
-		_spec.SetField(account.FieldTempUnschedulableReason, field.TypeString, value)
-	}
-	if _u.mutation.TempUnschedulableReasonCleared() {
-		_spec.ClearField(account.FieldTempUnschedulableReason, field.TypeString)
-	}
 	if value, ok := _u.mutation.SessionWindowStart(); ok {
 		_spec.SetField(account.FieldSessionWindowStart, field.TypeTime, value)
 	}

backend/ent/accountgroup_query.go

@@ -8,7 +8,6 @@ import (
 	"math"
 
 	"entgo.io/ent"
-	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/Wei-Shaw/sub2api/ent/account"
@@ -26,7 +25,6 @@ type AccountGroupQuery struct {
 	predicates  []predicate.AccountGroup
 	withAccount *AccountQuery
 	withGroup   *GroupQuery
-	modifiers   []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -349,9 +347,6 @@ func (_q *AccountGroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -437,9 +432,6 @@ func (_q *AccountGroupQuery) loadGroup(ctx context.Context, query *GroupQuery, n
 
 func (_q *AccountGroupQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	_spec.Unique = false
 	_spec.Node.Columns = nil
 	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
@@ -503,9 +495,6 @@ func (_q *AccountGroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if _q.ctx.Unique != nil && *_q.ctx.Unique {
 		selector.Distinct()
 	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
 	for _, p := range _q.predicates {
 		p(selector)
 	}
@@ -523,32 +512,6 @@ func (_q *AccountGroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *AccountGroupQuery) ForUpdate(opts ...sql.LockOption) *AccountGroupQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *AccountGroupQuery) ForShare(opts ...sql.LockOption) *AccountGroupQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // AccountGroupGroupBy is the group-by builder for AccountGroup entities.
 type AccountGroupGroupBy struct {
 	selector

backend/ent/announcement.go

@@ -1,260 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/internal/domain"
-)
-
-// Announcement is the model entity for the Announcement schema.
-type Announcement struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int64 `json:"id,omitempty"`
-	// 公告标题
-	Title string `json:"title,omitempty"`
-	// 公告内容（支持 Markdown）
-	Content string `json:"content,omitempty"`
-	// 状态: draft, active, archived
-	Status string `json:"status,omitempty"`
-	// 通知模式: silent(仅铃铛), popup(弹窗提醒)
-	NotifyMode string `json:"notify_mode,omitempty"`
-	// 展示条件（JSON 规则）
-	Targeting domain.AnnouncementTargeting `json:"targeting,omitempty"`
-	// 开始展示时间（为空表示立即生效）
-	StartsAt *time.Time `json:"starts_at,omitempty"`
-	// 结束展示时间（为空表示永久生效）
-	EndsAt *time.Time `json:"ends_at,omitempty"`
-	// 创建人用户ID（管理员）
-	CreatedBy *int64 `json:"created_by,omitempty"`
-	// 更新人用户ID（管理员）
-	UpdatedBy *int64 `json:"updated_by,omitempty"`
-	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt time.Time `json:"updated_at,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the AnnouncementQuery when eager-loading is set.
-	Edges        AnnouncementEdges `json:"edges"`
-	selectValues sql.SelectValues
-}
-
-// AnnouncementEdges holds the relations/edges for other nodes in the graph.
-type AnnouncementEdges struct {
-	// Reads holds the value of the reads edge.
-	Reads []*AnnouncementRead `json:"reads,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [1]bool
-}
-
-// ReadsOrErr returns the Reads value or an error if the edge
-// was not loaded in eager-loading.
-func (e AnnouncementEdges) ReadsOrErr() ([]*AnnouncementRead, error) {
-	if e.loadedTypes[0] {
-		return e.Reads, nil
-	}
-	return nil, &NotLoadedError{edge: "reads"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*Announcement) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case announcement.FieldTargeting:
-			values[i] = new([]byte)
-		case announcement.FieldID, announcement.FieldCreatedBy, announcement.FieldUpdatedBy:
-			values[i] = new(sql.NullInt64)
-		case announcement.FieldTitle, announcement.FieldContent, announcement.FieldStatus, announcement.FieldNotifyMode:
-			values[i] = new(sql.NullString)
-		case announcement.FieldStartsAt, announcement.FieldEndsAt, announcement.FieldCreatedAt, announcement.FieldUpdatedAt:
-			values[i] = new(sql.NullTime)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the Announcement fields.
-func (_m *Announcement) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case announcement.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			_m.ID = int64(value.Int64)
-		case announcement.FieldTitle:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field title", values[i])
-			} else if value.Valid {
-				_m.Title = value.String
-			}
-		case announcement.FieldContent:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field content", values[i])
-			} else if value.Valid {
-				_m.Content = value.String
-			}
-		case announcement.FieldStatus:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field status", values[i])
-			} else if value.Valid {
-				_m.Status = value.String
-			}
-		case announcement.FieldNotifyMode:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field notify_mode", values[i])
-			} else if value.Valid {
-				_m.NotifyMode = value.String
-			}
-		case announcement.FieldTargeting:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field targeting", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.Targeting); err != nil {
-					return fmt.Errorf("unmarshal field targeting: %w", err)
-				}
-			}
-		case announcement.FieldStartsAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field starts_at", values[i])
-			} else if value.Valid {
-				_m.StartsAt = new(time.Time)
-				*_m.StartsAt = value.Time
-			}
-		case announcement.FieldEndsAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field ends_at", values[i])
-			} else if value.Valid {
-				_m.EndsAt = new(time.Time)
-				*_m.EndsAt = value.Time
-			}
-		case announcement.FieldCreatedBy:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field created_by", values[i])
-			} else if value.Valid {
-				_m.CreatedBy = new(int64)
-				*_m.CreatedBy = value.Int64
-			}
-		case announcement.FieldUpdatedBy:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field updated_by", values[i])
-			} else if value.Valid {
-				_m.UpdatedBy = new(int64)
-				*_m.UpdatedBy = value.Int64
-			}
-		case announcement.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field created_at", values[i])
-			} else if value.Valid {
-				_m.CreatedAt = value.Time
-			}
-		case announcement.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
-			} else if value.Valid {
-				_m.UpdatedAt = value.Time
-			}
-		default:
-			_m.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the Announcement.
-// This includes values selected through modifiers, order, etc.
-func (_m *Announcement) Value(name string) (ent.Value, error) {
-	return _m.selectValues.Get(name)
-}
-
-// QueryReads queries the "reads" edge of the Announcement entity.
-func (_m *Announcement) QueryReads() *AnnouncementReadQuery {
-	return NewAnnouncementClient(_m.config).QueryReads(_m)
-}
-
-// Update returns a builder for updating this Announcement.
-// Note that you need to call Announcement.Unwrap() before calling this method if this Announcement
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *Announcement) Update() *AnnouncementUpdateOne {
-	return NewAnnouncementClient(_m.config).UpdateOne(_m)
-}
-
-// Unwrap unwraps the Announcement entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (_m *Announcement) Unwrap() *Announcement {
-	_tx, ok := _m.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: Announcement is not a transactional entity")
-	}
-	_m.config.driver = _tx.drv
-	return _m
-}
-
-// String implements the fmt.Stringer.
-func (_m *Announcement) String() string {
-	var builder strings.Builder
-	builder.WriteString("Announcement(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
-	builder.WriteString("title=")
-	builder.WriteString(_m.Title)
-	builder.WriteString(", ")
-	builder.WriteString("content=")
-	builder.WriteString(_m.Content)
-	builder.WriteString(", ")
-	builder.WriteString("status=")
-	builder.WriteString(_m.Status)
-	builder.WriteString(", ")
-	builder.WriteString("notify_mode=")
-	builder.WriteString(_m.NotifyMode)
-	builder.WriteString(", ")
-	builder.WriteString("targeting=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Targeting))
-	builder.WriteString(", ")
-	if v := _m.StartsAt; v != nil {
-		builder.WriteString("starts_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.EndsAt; v != nil {
-		builder.WriteString("ends_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.CreatedBy; v != nil {
-		builder.WriteString("created_by=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.UpdatedBy; v != nil {
-		builder.WriteString("updated_by=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("created_at=")
-	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("updated_at=")
-	builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// Announcements is a parsable slice of Announcement.
-type Announcements []*Announcement

backend/ent/announcement/announcement.go

@@ -1,176 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package announcement
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-const (
-	// Label holds the string label denoting the announcement type in the database.
-	Label = "announcement"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldTitle holds the string denoting the title field in the database.
-	FieldTitle = "title"
-	// FieldContent holds the string denoting the content field in the database.
-	FieldContent = "content"
-	// FieldStatus holds the string denoting the status field in the database.
-	FieldStatus = "status"
-	// FieldNotifyMode holds the string denoting the notify_mode field in the database.
-	FieldNotifyMode = "notify_mode"
-	// FieldTargeting holds the string denoting the targeting field in the database.
-	FieldTargeting = "targeting"
-	// FieldStartsAt holds the string denoting the starts_at field in the database.
-	FieldStartsAt = "starts_at"
-	// FieldEndsAt holds the string denoting the ends_at field in the database.
-	FieldEndsAt = "ends_at"
-	// FieldCreatedBy holds the string denoting the created_by field in the database.
-	FieldCreatedBy = "created_by"
-	// FieldUpdatedBy holds the string denoting the updated_by field in the database.
-	FieldUpdatedBy = "updated_by"
-	// FieldCreatedAt holds the string denoting the created_at field in the database.
-	FieldCreatedAt = "created_at"
-	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
-	FieldUpdatedAt = "updated_at"
-	// EdgeReads holds the string denoting the reads edge name in mutations.
-	EdgeReads = "reads"
-	// Table holds the table name of the announcement in the database.
-	Table = "announcements"
-	// ReadsTable is the table that holds the reads relation/edge.
-	ReadsTable = "announcement_reads"
-	// ReadsInverseTable is the table name for the AnnouncementRead entity.
-	// It exists in this package in order to avoid circular dependency with the "announcementread" package.
-	ReadsInverseTable = "announcement_reads"
-	// ReadsColumn is the table column denoting the reads relation/edge.
-	ReadsColumn = "announcement_id"
-)
-
-// Columns holds all SQL columns for announcement fields.
-var Columns = []string{
-	FieldID,
-	FieldTitle,
-	FieldContent,
-	FieldStatus,
-	FieldNotifyMode,
-	FieldTargeting,
-	FieldStartsAt,
-	FieldEndsAt,
-	FieldCreatedBy,
-	FieldUpdatedBy,
-	FieldCreatedAt,
-	FieldUpdatedAt,
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// TitleValidator is a validator for the "title" field. It is called by the builders before save.
-	TitleValidator func(string) error
-	// ContentValidator is a validator for the "content" field. It is called by the builders before save.
-	ContentValidator func(string) error
-	// DefaultStatus holds the default value on creation for the "status" field.
-	DefaultStatus string
-	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	StatusValidator func(string) error
-	// DefaultNotifyMode holds the default value on creation for the "notify_mode" field.
-	DefaultNotifyMode string
-	// NotifyModeValidator is a validator for the "notify_mode" field. It is called by the builders before save.
-	NotifyModeValidator func(string) error
-	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() time.Time
-	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() time.Time
-	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() time.Time
-)
-
-// OrderOption defines the ordering options for the Announcement queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByTitle orders the results by the title field.
-func ByTitle(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldTitle, opts...).ToFunc()
-}
-
-// ByContent orders the results by the content field.
-func ByContent(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldContent, opts...).ToFunc()
-}
-
-// ByStatus orders the results by the status field.
-func ByStatus(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldStatus, opts...).ToFunc()
-}
-
-// ByNotifyMode orders the results by the notify_mode field.
-func ByNotifyMode(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldNotifyMode, opts...).ToFunc()
-}
-
-// ByStartsAt orders the results by the starts_at field.
-func ByStartsAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldStartsAt, opts...).ToFunc()
-}
-
-// ByEndsAt orders the results by the ends_at field.
-func ByEndsAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldEndsAt, opts...).ToFunc()
-}
-
-// ByCreatedBy orders the results by the created_by field.
-func ByCreatedBy(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedBy, opts...).ToFunc()
-}
-
-// ByUpdatedBy orders the results by the updated_by field.
-func ByUpdatedBy(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUpdatedBy, opts...).ToFunc()
-}
-
-// ByCreatedAt orders the results by the created_at field.
-func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
-}
-
-// ByUpdatedAt orders the results by the updated_at field.
-func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
-}
-
-// ByReadsCount orders the results by reads count.
-func ByReadsCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newReadsStep(), opts...)
-	}
-}
-
-// ByReads orders the results by reads terms.
-func ByReads(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newReadsStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-func newReadsStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(ReadsInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, ReadsTable, ReadsColumn),
-	)
-}

backend/ent/announcement/where.go

@@ -1,694 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package announcement
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldID, id))
-}
-
-// Title applies equality check predicate on the "title" field. It's identical to TitleEQ.
-func Title(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldTitle, v))
-}
-
-// Content applies equality check predicate on the "content" field. It's identical to ContentEQ.
-func Content(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldContent, v))
-}
-
-// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
-func Status(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldStatus, v))
-}
-
-// NotifyMode applies equality check predicate on the "notify_mode" field. It's identical to NotifyModeEQ.
-func NotifyMode(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldNotifyMode, v))
-}
-
-// StartsAt applies equality check predicate on the "starts_at" field. It's identical to StartsAtEQ.
-func StartsAt(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldStartsAt, v))
-}
-
-// EndsAt applies equality check predicate on the "ends_at" field. It's identical to EndsAtEQ.
-func EndsAt(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldEndsAt, v))
-}
-
-// CreatedBy applies equality check predicate on the "created_by" field. It's identical to CreatedByEQ.
-func CreatedBy(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldCreatedBy, v))
-}
-
-// UpdatedBy applies equality check predicate on the "updated_by" field. It's identical to UpdatedByEQ.
-func UpdatedBy(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldUpdatedBy, v))
-}
-
-// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// TitleEQ applies the EQ predicate on the "title" field.
-func TitleEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldTitle, v))
-}
-
-// TitleNEQ applies the NEQ predicate on the "title" field.
-func TitleNEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldTitle, v))
-}
-
-// TitleIn applies the In predicate on the "title" field.
-func TitleIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldTitle, vs...))
-}
-
-// TitleNotIn applies the NotIn predicate on the "title" field.
-func TitleNotIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldTitle, vs...))
-}
-
-// TitleGT applies the GT predicate on the "title" field.
-func TitleGT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldTitle, v))
-}
-
-// TitleGTE applies the GTE predicate on the "title" field.
-func TitleGTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldTitle, v))
-}
-
-// TitleLT applies the LT predicate on the "title" field.
-func TitleLT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldTitle, v))
-}
-
-// TitleLTE applies the LTE predicate on the "title" field.
-func TitleLTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldTitle, v))
-}
-
-// TitleContains applies the Contains predicate on the "title" field.
-func TitleContains(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContains(FieldTitle, v))
-}
-
-// TitleHasPrefix applies the HasPrefix predicate on the "title" field.
-func TitleHasPrefix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasPrefix(FieldTitle, v))
-}
-
-// TitleHasSuffix applies the HasSuffix predicate on the "title" field.
-func TitleHasSuffix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasSuffix(FieldTitle, v))
-}
-
-// TitleEqualFold applies the EqualFold predicate on the "title" field.
-func TitleEqualFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEqualFold(FieldTitle, v))
-}
-
-// TitleContainsFold applies the ContainsFold predicate on the "title" field.
-func TitleContainsFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContainsFold(FieldTitle, v))
-}
-
-// ContentEQ applies the EQ predicate on the "content" field.
-func ContentEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldContent, v))
-}
-
-// ContentNEQ applies the NEQ predicate on the "content" field.
-func ContentNEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldContent, v))
-}
-
-// ContentIn applies the In predicate on the "content" field.
-func ContentIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldContent, vs...))
-}
-
-// ContentNotIn applies the NotIn predicate on the "content" field.
-func ContentNotIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldContent, vs...))
-}
-
-// ContentGT applies the GT predicate on the "content" field.
-func ContentGT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldContent, v))
-}
-
-// ContentGTE applies the GTE predicate on the "content" field.
-func ContentGTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldContent, v))
-}
-
-// ContentLT applies the LT predicate on the "content" field.
-func ContentLT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldContent, v))
-}
-
-// ContentLTE applies the LTE predicate on the "content" field.
-func ContentLTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldContent, v))
-}
-
-// ContentContains applies the Contains predicate on the "content" field.
-func ContentContains(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContains(FieldContent, v))
-}
-
-// ContentHasPrefix applies the HasPrefix predicate on the "content" field.
-func ContentHasPrefix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasPrefix(FieldContent, v))
-}
-
-// ContentHasSuffix applies the HasSuffix predicate on the "content" field.
-func ContentHasSuffix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasSuffix(FieldContent, v))
-}
-
-// ContentEqualFold applies the EqualFold predicate on the "content" field.
-func ContentEqualFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEqualFold(FieldContent, v))
-}
-
-// ContentContainsFold applies the ContainsFold predicate on the "content" field.
-func ContentContainsFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContainsFold(FieldContent, v))
-}
-
-// StatusEQ applies the EQ predicate on the "status" field.
-func StatusEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldStatus, v))
-}
-
-// StatusNEQ applies the NEQ predicate on the "status" field.
-func StatusNEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldStatus, v))
-}
-
-// StatusIn applies the In predicate on the "status" field.
-func StatusIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldStatus, vs...))
-}
-
-// StatusNotIn applies the NotIn predicate on the "status" field.
-func StatusNotIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldStatus, vs...))
-}
-
-// StatusGT applies the GT predicate on the "status" field.
-func StatusGT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldStatus, v))
-}
-
-// StatusGTE applies the GTE predicate on the "status" field.
-func StatusGTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldStatus, v))
-}
-
-// StatusLT applies the LT predicate on the "status" field.
-func StatusLT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldStatus, v))
-}
-
-// StatusLTE applies the LTE predicate on the "status" field.
-func StatusLTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldStatus, v))
-}
-
-// StatusContains applies the Contains predicate on the "status" field.
-func StatusContains(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContains(FieldStatus, v))
-}
-
-// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
-func StatusHasPrefix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasPrefix(FieldStatus, v))
-}
-
-// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
-func StatusHasSuffix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasSuffix(FieldStatus, v))
-}
-
-// StatusEqualFold applies the EqualFold predicate on the "status" field.
-func StatusEqualFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEqualFold(FieldStatus, v))
-}
-
-// StatusContainsFold applies the ContainsFold predicate on the "status" field.
-func StatusContainsFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContainsFold(FieldStatus, v))
-}
-
-// NotifyModeEQ applies the EQ predicate on the "notify_mode" field.
-func NotifyModeEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldNotifyMode, v))
-}
-
-// NotifyModeNEQ applies the NEQ predicate on the "notify_mode" field.
-func NotifyModeNEQ(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldNotifyMode, v))
-}
-
-// NotifyModeIn applies the In predicate on the "notify_mode" field.
-func NotifyModeIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldNotifyMode, vs...))
-}
-
-// NotifyModeNotIn applies the NotIn predicate on the "notify_mode" field.
-func NotifyModeNotIn(vs ...string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldNotifyMode, vs...))
-}
-
-// NotifyModeGT applies the GT predicate on the "notify_mode" field.
-func NotifyModeGT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldNotifyMode, v))
-}
-
-// NotifyModeGTE applies the GTE predicate on the "notify_mode" field.
-func NotifyModeGTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldNotifyMode, v))
-}
-
-// NotifyModeLT applies the LT predicate on the "notify_mode" field.
-func NotifyModeLT(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldNotifyMode, v))
-}
-
-// NotifyModeLTE applies the LTE predicate on the "notify_mode" field.
-func NotifyModeLTE(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldNotifyMode, v))
-}
-
-// NotifyModeContains applies the Contains predicate on the "notify_mode" field.
-func NotifyModeContains(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContains(FieldNotifyMode, v))
-}
-
-// NotifyModeHasPrefix applies the HasPrefix predicate on the "notify_mode" field.
-func NotifyModeHasPrefix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasPrefix(FieldNotifyMode, v))
-}
-
-// NotifyModeHasSuffix applies the HasSuffix predicate on the "notify_mode" field.
-func NotifyModeHasSuffix(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldHasSuffix(FieldNotifyMode, v))
-}
-
-// NotifyModeEqualFold applies the EqualFold predicate on the "notify_mode" field.
-func NotifyModeEqualFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEqualFold(FieldNotifyMode, v))
-}
-
-// NotifyModeContainsFold applies the ContainsFold predicate on the "notify_mode" field.
-func NotifyModeContainsFold(v string) predicate.Announcement {
-	return predicate.Announcement(sql.FieldContainsFold(FieldNotifyMode, v))
-}
-
-// TargetingIsNil applies the IsNil predicate on the "targeting" field.
-func TargetingIsNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldIsNull(FieldTargeting))
-}
-
-// TargetingNotNil applies the NotNil predicate on the "targeting" field.
-func TargetingNotNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotNull(FieldTargeting))
-}
-
-// StartsAtEQ applies the EQ predicate on the "starts_at" field.
-func StartsAtEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldStartsAt, v))
-}
-
-// StartsAtNEQ applies the NEQ predicate on the "starts_at" field.
-func StartsAtNEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldStartsAt, v))
-}
-
-// StartsAtIn applies the In predicate on the "starts_at" field.
-func StartsAtIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldStartsAt, vs...))
-}
-
-// StartsAtNotIn applies the NotIn predicate on the "starts_at" field.
-func StartsAtNotIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldStartsAt, vs...))
-}
-
-// StartsAtGT applies the GT predicate on the "starts_at" field.
-func StartsAtGT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldStartsAt, v))
-}
-
-// StartsAtGTE applies the GTE predicate on the "starts_at" field.
-func StartsAtGTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldStartsAt, v))
-}
-
-// StartsAtLT applies the LT predicate on the "starts_at" field.
-func StartsAtLT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldStartsAt, v))
-}
-
-// StartsAtLTE applies the LTE predicate on the "starts_at" field.
-func StartsAtLTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldStartsAt, v))
-}
-
-// StartsAtIsNil applies the IsNil predicate on the "starts_at" field.
-func StartsAtIsNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldIsNull(FieldStartsAt))
-}
-
-// StartsAtNotNil applies the NotNil predicate on the "starts_at" field.
-func StartsAtNotNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotNull(FieldStartsAt))
-}
-
-// EndsAtEQ applies the EQ predicate on the "ends_at" field.
-func EndsAtEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldEndsAt, v))
-}
-
-// EndsAtNEQ applies the NEQ predicate on the "ends_at" field.
-func EndsAtNEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldEndsAt, v))
-}
-
-// EndsAtIn applies the In predicate on the "ends_at" field.
-func EndsAtIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldEndsAt, vs...))
-}
-
-// EndsAtNotIn applies the NotIn predicate on the "ends_at" field.
-func EndsAtNotIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldEndsAt, vs...))
-}
-
-// EndsAtGT applies the GT predicate on the "ends_at" field.
-func EndsAtGT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldEndsAt, v))
-}
-
-// EndsAtGTE applies the GTE predicate on the "ends_at" field.
-func EndsAtGTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldEndsAt, v))
-}
-
-// EndsAtLT applies the LT predicate on the "ends_at" field.
-func EndsAtLT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldEndsAt, v))
-}
-
-// EndsAtLTE applies the LTE predicate on the "ends_at" field.
-func EndsAtLTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldEndsAt, v))
-}
-
-// EndsAtIsNil applies the IsNil predicate on the "ends_at" field.
-func EndsAtIsNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldIsNull(FieldEndsAt))
-}
-
-// EndsAtNotNil applies the NotNil predicate on the "ends_at" field.
-func EndsAtNotNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotNull(FieldEndsAt))
-}
-
-// CreatedByEQ applies the EQ predicate on the "created_by" field.
-func CreatedByEQ(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldCreatedBy, v))
-}
-
-// CreatedByNEQ applies the NEQ predicate on the "created_by" field.
-func CreatedByNEQ(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldCreatedBy, v))
-}
-
-// CreatedByIn applies the In predicate on the "created_by" field.
-func CreatedByIn(vs ...int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldCreatedBy, vs...))
-}
-
-// CreatedByNotIn applies the NotIn predicate on the "created_by" field.
-func CreatedByNotIn(vs ...int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldCreatedBy, vs...))
-}
-
-// CreatedByGT applies the GT predicate on the "created_by" field.
-func CreatedByGT(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldCreatedBy, v))
-}
-
-// CreatedByGTE applies the GTE predicate on the "created_by" field.
-func CreatedByGTE(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldCreatedBy, v))
-}
-
-// CreatedByLT applies the LT predicate on the "created_by" field.
-func CreatedByLT(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldCreatedBy, v))
-}
-
-// CreatedByLTE applies the LTE predicate on the "created_by" field.
-func CreatedByLTE(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldCreatedBy, v))
-}
-
-// CreatedByIsNil applies the IsNil predicate on the "created_by" field.
-func CreatedByIsNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldIsNull(FieldCreatedBy))
-}
-
-// CreatedByNotNil applies the NotNil predicate on the "created_by" field.
-func CreatedByNotNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotNull(FieldCreatedBy))
-}
-
-// UpdatedByEQ applies the EQ predicate on the "updated_by" field.
-func UpdatedByEQ(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldUpdatedBy, v))
-}
-
-// UpdatedByNEQ applies the NEQ predicate on the "updated_by" field.
-func UpdatedByNEQ(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldUpdatedBy, v))
-}
-
-// UpdatedByIn applies the In predicate on the "updated_by" field.
-func UpdatedByIn(vs ...int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldUpdatedBy, vs...))
-}
-
-// UpdatedByNotIn applies the NotIn predicate on the "updated_by" field.
-func UpdatedByNotIn(vs ...int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldUpdatedBy, vs...))
-}
-
-// UpdatedByGT applies the GT predicate on the "updated_by" field.
-func UpdatedByGT(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldUpdatedBy, v))
-}
-
-// UpdatedByGTE applies the GTE predicate on the "updated_by" field.
-func UpdatedByGTE(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldUpdatedBy, v))
-}
-
-// UpdatedByLT applies the LT predicate on the "updated_by" field.
-func UpdatedByLT(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldUpdatedBy, v))
-}
-
-// UpdatedByLTE applies the LTE predicate on the "updated_by" field.
-func UpdatedByLTE(v int64) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldUpdatedBy, v))
-}
-
-// UpdatedByIsNil applies the IsNil predicate on the "updated_by" field.
-func UpdatedByIsNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldIsNull(FieldUpdatedBy))
-}
-
-// UpdatedByNotNil applies the NotNil predicate on the "updated_by" field.
-func UpdatedByNotNil() predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotNull(FieldUpdatedBy))
-}
-
-// CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldCreatedAt, v))
-}
-
-// CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldCreatedAt, v))
-}
-
-// CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldCreatedAt, v))
-}
-
-// CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldCreatedAt, v))
-}
-
-// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldNotIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldGTE(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v time.Time) predicate.Announcement {
-	return predicate.Announcement(sql.FieldLTE(FieldUpdatedAt, v))
-}
-
-// HasReads applies the HasEdge predicate on the "reads" edge.
-func HasReads() predicate.Announcement {
-	return predicate.Announcement(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, ReadsTable, ReadsColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasReadsWith applies the HasEdge predicate on the "reads" edge with a given conditions (other predicates).
-func HasReadsWith(preds ...predicate.AnnouncementRead) predicate.Announcement {
-	return predicate.Announcement(func(s *sql.Selector) {
-		step := newReadsStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.Announcement) predicate.Announcement {
-	return predicate.Announcement(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.Announcement) predicate.Announcement {
-	return predicate.Announcement(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.Announcement) predicate.Announcement {
-	return predicate.Announcement(sql.NotPredicates(p))
-}

backend/ent/announcement_delete.go

@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// AnnouncementDelete is the builder for deleting a Announcement entity.
-type AnnouncementDelete struct {
-	config
-	hooks    []Hook
-	mutation *AnnouncementMutation
-}
-
-// Where appends a list predicates to the AnnouncementDelete builder.
-func (_d *AnnouncementDelete) Where(ps ...predicate.Announcement) *AnnouncementDelete {
-	_d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *AnnouncementDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *AnnouncementDelete) ExecX(ctx context.Context) int {
-	n, err := _d.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (_d *AnnouncementDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(announcement.Table, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64))
-	if ps := _d.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	_d.mutation.done = true
-	return affected, err
-}
-
-// AnnouncementDeleteOne is the builder for deleting a single Announcement entity.
-type AnnouncementDeleteOne struct {
-	_d *AnnouncementDelete
-}
-
-// Where appends a list predicates to the AnnouncementDelete builder.
-func (_d *AnnouncementDeleteOne) Where(ps ...predicate.Announcement) *AnnouncementDeleteOne {
-	_d._d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query.
-func (_d *AnnouncementDeleteOne) Exec(ctx context.Context) error {
-	n, err := _d._d.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{announcement.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *AnnouncementDeleteOne) ExecX(ctx context.Context) {
-	if err := _d.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/announcement_query.go

@@ -1,643 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"database/sql/driver"
-	"fmt"
-	"math"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// AnnouncementQuery is the builder for querying Announcement entities.
-type AnnouncementQuery struct {
-	config
-	ctx        *QueryContext
-	order      []announcement.OrderOption
-	inters     []Interceptor
-	predicates []predicate.Announcement
-	withReads  *AnnouncementReadQuery
-	modifiers  []func(*sql.Selector)
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the AnnouncementQuery builder.
-func (_q *AnnouncementQuery) Where(ps ...predicate.Announcement) *AnnouncementQuery {
-	_q.predicates = append(_q.predicates, ps...)
-	return _q
-}
-
-// Limit the number of records to be returned by this query.
-func (_q *AnnouncementQuery) Limit(limit int) *AnnouncementQuery {
-	_q.ctx.Limit = &limit
-	return _q
-}
-
-// Offset to start from.
-func (_q *AnnouncementQuery) Offset(offset int) *AnnouncementQuery {
-	_q.ctx.Offset = &offset
-	return _q
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (_q *AnnouncementQuery) Unique(unique bool) *AnnouncementQuery {
-	_q.ctx.Unique = &unique
-	return _q
-}
-
-// Order specifies how the records should be ordered.
-func (_q *AnnouncementQuery) Order(o ...announcement.OrderOption) *AnnouncementQuery {
-	_q.order = append(_q.order, o...)
-	return _q
-}
-
-// QueryReads chains the current query on the "reads" edge.
-func (_q *AnnouncementQuery) QueryReads() *AnnouncementReadQuery {
-	query := (&AnnouncementReadClient{config: _q.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := _q.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := _q.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(announcement.Table, announcement.FieldID, selector),
-			sqlgraph.To(announcementread.Table, announcementread.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, announcement.ReadsTable, announcement.ReadsColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first Announcement entity from the query.
-// Returns a *NotFoundError when no Announcement was found.
-func (_q *AnnouncementQuery) First(ctx context.Context) (*Announcement, error) {
-	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{announcement.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (_q *AnnouncementQuery) FirstX(ctx context.Context) *Announcement {
-	node, err := _q.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first Announcement ID from the query.
-// Returns a *NotFoundError when no Announcement ID was found.
-func (_q *AnnouncementQuery) FirstID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{announcement.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *AnnouncementQuery) FirstIDX(ctx context.Context) int64 {
-	id, err := _q.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single Announcement entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one Announcement entity is found.
-// Returns a *NotFoundError when no Announcement entities are found.
-func (_q *AnnouncementQuery) Only(ctx context.Context) (*Announcement, error) {
-	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{announcement.Label}
-	default:
-		return nil, &NotSingularError{announcement.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (_q *AnnouncementQuery) OnlyX(ctx context.Context) *Announcement {
-	node, err := _q.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only Announcement ID in the query.
-// Returns a *NotSingularError when more than one Announcement ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (_q *AnnouncementQuery) OnlyID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{announcement.Label}
-	default:
-		err = &NotSingularError{announcement.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *AnnouncementQuery) OnlyIDX(ctx context.Context) int64 {
-	id, err := _q.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of Announcements.
-func (_q *AnnouncementQuery) All(ctx context.Context) ([]*Announcement, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*Announcement, *AnnouncementQuery]()
-	return withInterceptors[[]*Announcement](ctx, _q, qr, _q.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (_q *AnnouncementQuery) AllX(ctx context.Context) []*Announcement {
-	nodes, err := _q.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of Announcement IDs.
-func (_q *AnnouncementQuery) IDs(ctx context.Context) (ids []int64, err error) {
-	if _q.ctx.Unique == nil && _q.path != nil {
-		_q.Unique(true)
-	}
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
-	if err = _q.Select(announcement.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (_q *AnnouncementQuery) IDsX(ctx context.Context) []int64 {
-	ids, err := _q.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (_q *AnnouncementQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, _q, querierCount[*AnnouncementQuery](), _q.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (_q *AnnouncementQuery) CountX(ctx context.Context) int {
-	count, err := _q.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (_q *AnnouncementQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
-	switch _, err := _q.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (_q *AnnouncementQuery) ExistX(ctx context.Context) bool {
-	exist, err := _q.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the AnnouncementQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (_q *AnnouncementQuery) Clone() *AnnouncementQuery {
-	if _q == nil {
-		return nil
-	}
-	return &AnnouncementQuery{
-		config:     _q.config,
-		ctx:        _q.ctx.Clone(),
-		order:      append([]announcement.OrderOption{}, _q.order...),
-		inters:     append([]Interceptor{}, _q.inters...),
-		predicates: append([]predicate.Announcement{}, _q.predicates...),
-		withReads:  _q.withReads.Clone(),
-		// clone intermediate query.
-		sql:  _q.sql.Clone(),
-		path: _q.path,
-	}
-}
-
-// WithReads tells the query-builder to eager-load the nodes that are connected to
-// the "reads" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *AnnouncementQuery) WithReads(opts ...func(*AnnouncementReadQuery)) *AnnouncementQuery {
-	query := (&AnnouncementReadClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withReads = query
-	return _q
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		Title string `json:"title,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.Announcement.Query().
-//		GroupBy(announcement.FieldTitle).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (_q *AnnouncementQuery) GroupBy(field string, fields ...string) *AnnouncementGroupBy {
-	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &AnnouncementGroupBy{build: _q}
-	grbuild.flds = &_q.ctx.Fields
-	grbuild.label = announcement.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		Title string `json:"title,omitempty"`
-//	}
-//
-//	client.Announcement.Query().
-//		Select(announcement.FieldTitle).
-//		Scan(ctx, &v)
-func (_q *AnnouncementQuery) Select(fields ...string) *AnnouncementSelect {
-	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &AnnouncementSelect{AnnouncementQuery: _q}
-	sbuild.label = announcement.Label
-	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a AnnouncementSelect configured with the given aggregations.
-func (_q *AnnouncementQuery) Aggregate(fns ...AggregateFunc) *AnnouncementSelect {
-	return _q.Select().Aggregate(fns...)
-}
-
-func (_q *AnnouncementQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range _q.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, _q); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range _q.ctx.Fields {
-		if !announcement.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if _q.path != nil {
-		prev, err := _q.path(ctx)
-		if err != nil {
-			return err
-		}
-		_q.sql = prev
-	}
-	return nil
-}
-
-func (_q *AnnouncementQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Announcement, error) {
-	var (
-		nodes       = []*Announcement{}
-		_spec       = _q.querySpec()
-		loadedTypes = [1]bool{
-			_q.withReads != nil,
-		}
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*Announcement).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &Announcement{config: _q.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := _q.withReads; query != nil {
-		if err := _q.loadReads(ctx, query, nodes,
-			func(n *Announcement) { n.Edges.Reads = []*AnnouncementRead{} },
-			func(n *Announcement, e *AnnouncementRead) { n.Edges.Reads = append(n.Edges.Reads, e) }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (_q *AnnouncementQuery) loadReads(ctx context.Context, query *AnnouncementReadQuery, nodes []*Announcement, init func(*Announcement), assign func(*Announcement, *AnnouncementRead)) error {
-	fks := make([]driver.Value, 0, len(nodes))
-	nodeids := make(map[int64]*Announcement)
-	for i := range nodes {
-		fks = append(fks, nodes[i].ID)
-		nodeids[nodes[i].ID] = nodes[i]
-		if init != nil {
-			init(nodes[i])
-		}
-	}
-	if len(query.ctx.Fields) > 0 {
-		query.ctx.AppendFieldOnce(announcementread.FieldAnnouncementID)
-	}
-	query.Where(predicate.AnnouncementRead(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(announcement.ReadsColumn), fks...))
-	}))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		fk := n.AnnouncementID
-		node, ok := nodeids[fk]
-		if !ok {
-			return fmt.Errorf(`unexpected referenced foreign-key "announcement_id" returned %v for node %v`, fk, n.ID)
-		}
-		assign(node, n)
-	}
-	return nil
-}
-
-func (_q *AnnouncementQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	_spec.Node.Columns = _q.ctx.Fields
-	if len(_q.ctx.Fields) > 0 {
-		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
-}
-
-func (_q *AnnouncementQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(announcement.Table, announcement.Columns, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64))
-	_spec.From = _q.sql
-	if unique := _q.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if _q.path != nil {
-		_spec.Unique = true
-	}
-	if fields := _q.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, announcement.FieldID)
-		for i := range fields {
-			if fields[i] != announcement.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-	}
-	if ps := _q.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := _q.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (_q *AnnouncementQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(_q.driver.Dialect())
-	t1 := builder.Table(announcement.Table)
-	columns := _q.ctx.Fields
-	if len(columns) == 0 {
-		columns = announcement.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if _q.sql != nil {
-		selector = _q.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if _q.ctx.Unique != nil && *_q.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
-	for _, p := range _q.predicates {
-		p(selector)
-	}
-	for _, p := range _q.order {
-		p(selector)
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *AnnouncementQuery) ForUpdate(opts ...sql.LockOption) *AnnouncementQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *AnnouncementQuery) ForShare(opts ...sql.LockOption) *AnnouncementQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// AnnouncementGroupBy is the group-by builder for Announcement entities.
-type AnnouncementGroupBy struct {
-	selector
-	build *AnnouncementQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (_g *AnnouncementGroupBy) Aggregate(fns ...AggregateFunc) *AnnouncementGroupBy {
-	_g.fns = append(_g.fns, fns...)
-	return _g
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_g *AnnouncementGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
-	if err := _g.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*AnnouncementQuery, *AnnouncementGroupBy](ctx, _g.build, _g, _g.build.inters, v)
-}
-
-func (_g *AnnouncementGroupBy) sqlScan(ctx context.Context, root *AnnouncementQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(_g.fns))
-	for _, fn := range _g.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
-		for _, f := range *_g.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*_g.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// AnnouncementSelect is the builder for selecting fields of Announcement entities.
-type AnnouncementSelect struct {
-	*AnnouncementQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (_s *AnnouncementSelect) Aggregate(fns ...AggregateFunc) *AnnouncementSelect {
-	_s.fns = append(_s.fns, fns...)
-	return _s
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_s *AnnouncementSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
-	if err := _s.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*AnnouncementQuery, *AnnouncementSelect](ctx, _s.AnnouncementQuery, _s, _s.inters, v)
-}
-
-func (_s *AnnouncementSelect) sqlScan(ctx context.Context, root *AnnouncementQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(_s.fns))
-	for _, fn := range _s.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*_s.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}

backend/ent/announcement_update.go

@@ -1,868 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/internal/domain"
-)
-
-// AnnouncementUpdate is the builder for updating Announcement entities.
-type AnnouncementUpdate struct {
-	config
-	hooks    []Hook
-	mutation *AnnouncementMutation
-}
-
-// Where appends a list predicates to the AnnouncementUpdate builder.
-func (_u *AnnouncementUpdate) Where(ps ...predicate.Announcement) *AnnouncementUpdate {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// SetTitle sets the "title" field.
-func (_u *AnnouncementUpdate) SetTitle(v string) *AnnouncementUpdate {
-	_u.mutation.SetTitle(v)
-	return _u
-}
-
-// SetNillableTitle sets the "title" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableTitle(v *string) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetTitle(*v)
-	}
-	return _u
-}
-
-// SetContent sets the "content" field.
-func (_u *AnnouncementUpdate) SetContent(v string) *AnnouncementUpdate {
-	_u.mutation.SetContent(v)
-	return _u
-}
-
-// SetNillableContent sets the "content" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableContent(v *string) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetContent(*v)
-	}
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *AnnouncementUpdate) SetStatus(v string) *AnnouncementUpdate {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableStatus(v *string) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetNotifyMode sets the "notify_mode" field.
-func (_u *AnnouncementUpdate) SetNotifyMode(v string) *AnnouncementUpdate {
-	_u.mutation.SetNotifyMode(v)
-	return _u
-}
-
-// SetNillableNotifyMode sets the "notify_mode" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableNotifyMode(v *string) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetNotifyMode(*v)
-	}
-	return _u
-}
-
-// SetTargeting sets the "targeting" field.
-func (_u *AnnouncementUpdate) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementUpdate {
-	_u.mutation.SetTargeting(v)
-	return _u
-}
-
-// SetNillableTargeting sets the "targeting" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableTargeting(v *domain.AnnouncementTargeting) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetTargeting(*v)
-	}
-	return _u
-}
-
-// ClearTargeting clears the value of the "targeting" field.
-func (_u *AnnouncementUpdate) ClearTargeting() *AnnouncementUpdate {
-	_u.mutation.ClearTargeting()
-	return _u
-}
-
-// SetStartsAt sets the "starts_at" field.
-func (_u *AnnouncementUpdate) SetStartsAt(v time.Time) *AnnouncementUpdate {
-	_u.mutation.SetStartsAt(v)
-	return _u
-}
-
-// SetNillableStartsAt sets the "starts_at" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableStartsAt(v *time.Time) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetStartsAt(*v)
-	}
-	return _u
-}
-
-// ClearStartsAt clears the value of the "starts_at" field.
-func (_u *AnnouncementUpdate) ClearStartsAt() *AnnouncementUpdate {
-	_u.mutation.ClearStartsAt()
-	return _u
-}
-
-// SetEndsAt sets the "ends_at" field.
-func (_u *AnnouncementUpdate) SetEndsAt(v time.Time) *AnnouncementUpdate {
-	_u.mutation.SetEndsAt(v)
-	return _u
-}
-
-// SetNillableEndsAt sets the "ends_at" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableEndsAt(v *time.Time) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetEndsAt(*v)
-	}
-	return _u
-}
-
-// ClearEndsAt clears the value of the "ends_at" field.
-func (_u *AnnouncementUpdate) ClearEndsAt() *AnnouncementUpdate {
-	_u.mutation.ClearEndsAt()
-	return _u
-}
-
-// SetCreatedBy sets the "created_by" field.
-func (_u *AnnouncementUpdate) SetCreatedBy(v int64) *AnnouncementUpdate {
-	_u.mutation.ResetCreatedBy()
-	_u.mutation.SetCreatedBy(v)
-	return _u
-}
-
-// SetNillableCreatedBy sets the "created_by" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableCreatedBy(v *int64) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetCreatedBy(*v)
-	}
-	return _u
-}
-
-// AddCreatedBy adds value to the "created_by" field.
-func (_u *AnnouncementUpdate) AddCreatedBy(v int64) *AnnouncementUpdate {
-	_u.mutation.AddCreatedBy(v)
-	return _u
-}
-
-// ClearCreatedBy clears the value of the "created_by" field.
-func (_u *AnnouncementUpdate) ClearCreatedBy() *AnnouncementUpdate {
-	_u.mutation.ClearCreatedBy()
-	return _u
-}
-
-// SetUpdatedBy sets the "updated_by" field.
-func (_u *AnnouncementUpdate) SetUpdatedBy(v int64) *AnnouncementUpdate {
-	_u.mutation.ResetUpdatedBy()
-	_u.mutation.SetUpdatedBy(v)
-	return _u
-}
-
-// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil.
-func (_u *AnnouncementUpdate) SetNillableUpdatedBy(v *int64) *AnnouncementUpdate {
-	if v != nil {
-		_u.SetUpdatedBy(*v)
-	}
-	return _u
-}
-
-// AddUpdatedBy adds value to the "updated_by" field.
-func (_u *AnnouncementUpdate) AddUpdatedBy(v int64) *AnnouncementUpdate {
-	_u.mutation.AddUpdatedBy(v)
-	return _u
-}
-
-// ClearUpdatedBy clears the value of the "updated_by" field.
-func (_u *AnnouncementUpdate) ClearUpdatedBy() *AnnouncementUpdate {
-	_u.mutation.ClearUpdatedBy()
-	return _u
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *AnnouncementUpdate) SetUpdatedAt(v time.Time) *AnnouncementUpdate {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// AddReadIDs adds the "reads" edge to the AnnouncementRead entity by IDs.
-func (_u *AnnouncementUpdate) AddReadIDs(ids ...int64) *AnnouncementUpdate {
-	_u.mutation.AddReadIDs(ids...)
-	return _u
-}
-
-// AddReads adds the "reads" edges to the AnnouncementRead entity.
-func (_u *AnnouncementUpdate) AddReads(v ...*AnnouncementRead) *AnnouncementUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddReadIDs(ids...)
-}
-
-// Mutation returns the AnnouncementMutation object of the builder.
-func (_u *AnnouncementUpdate) Mutation() *AnnouncementMutation {
-	return _u.mutation
-}
-
-// ClearReads clears all "reads" edges to the AnnouncementRead entity.
-func (_u *AnnouncementUpdate) ClearReads() *AnnouncementUpdate {
-	_u.mutation.ClearReads()
-	return _u
-}
-
-// RemoveReadIDs removes the "reads" edge to AnnouncementRead entities by IDs.
-func (_u *AnnouncementUpdate) RemoveReadIDs(ids ...int64) *AnnouncementUpdate {
-	_u.mutation.RemoveReadIDs(ids...)
-	return _u
-}
-
-// RemoveReads removes "reads" edges to AnnouncementRead entities.
-func (_u *AnnouncementUpdate) RemoveReads(v ...*AnnouncementRead) *AnnouncementUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemoveReadIDs(ids...)
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *AnnouncementUpdate) Save(ctx context.Context) (int, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *AnnouncementUpdate) SaveX(ctx context.Context) int {
-	affected, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (_u *AnnouncementUpdate) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *AnnouncementUpdate) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *AnnouncementUpdate) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := announcement.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *AnnouncementUpdate) check() error {
-	if v, ok := _u.mutation.Title(); ok {
-		if err := announcement.TitleValidator(v); err != nil {
-			return &ValidationError{Name: "title", err: fmt.Errorf(`ent: validator failed for field "Announcement.title": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Content(); ok {
-		if err := announcement.ContentValidator(v); err != nil {
-			return &ValidationError{Name: "content", err: fmt.Errorf(`ent: validator failed for field "Announcement.content": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Status(); ok {
-		if err := announcement.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "Announcement.status": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.NotifyMode(); ok {
-		if err := announcement.NotifyModeValidator(v); err != nil {
-			return &ValidationError{Name: "notify_mode", err: fmt.Errorf(`ent: validator failed for field "Announcement.notify_mode": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *AnnouncementUpdate) sqlSave(ctx context.Context) (_node int, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(announcement.Table, announcement.Columns, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64))
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.Title(); ok {
-		_spec.SetField(announcement.FieldTitle, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Content(); ok {
-		_spec.SetField(announcement.FieldContent, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(announcement.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.NotifyMode(); ok {
-		_spec.SetField(announcement.FieldNotifyMode, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Targeting(); ok {
-		_spec.SetField(announcement.FieldTargeting, field.TypeJSON, value)
-	}
-	if _u.mutation.TargetingCleared() {
-		_spec.ClearField(announcement.FieldTargeting, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.StartsAt(); ok {
-		_spec.SetField(announcement.FieldStartsAt, field.TypeTime, value)
-	}
-	if _u.mutation.StartsAtCleared() {
-		_spec.ClearField(announcement.FieldStartsAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.EndsAt(); ok {
-		_spec.SetField(announcement.FieldEndsAt, field.TypeTime, value)
-	}
-	if _u.mutation.EndsAtCleared() {
-		_spec.ClearField(announcement.FieldEndsAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.CreatedBy(); ok {
-		_spec.SetField(announcement.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedCreatedBy(); ok {
-		_spec.AddField(announcement.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if _u.mutation.CreatedByCleared() {
-		_spec.ClearField(announcement.FieldCreatedBy, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.UpdatedBy(); ok {
-		_spec.SetField(announcement.FieldUpdatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedUpdatedBy(); ok {
-		_spec.AddField(announcement.FieldUpdatedBy, field.TypeInt64, value)
-	}
-	if _u.mutation.UpdatedByCleared() {
-		_spec.ClearField(announcement.FieldUpdatedBy, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(announcement.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if _u.mutation.ReadsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   announcement.ReadsTable,
-			Columns: []string{announcement.ReadsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedReadsIDs(); len(nodes) > 0 && !_u.mutation.ReadsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   announcement.ReadsTable,
-			Columns: []string{announcement.ReadsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.ReadsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   announcement.ReadsTable,
-			Columns: []string{announcement.ReadsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{announcement.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}
-
-// AnnouncementUpdateOne is the builder for updating a single Announcement entity.
-type AnnouncementUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *AnnouncementMutation
-}
-
-// SetTitle sets the "title" field.
-func (_u *AnnouncementUpdateOne) SetTitle(v string) *AnnouncementUpdateOne {
-	_u.mutation.SetTitle(v)
-	return _u
-}
-
-// SetNillableTitle sets the "title" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableTitle(v *string) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetTitle(*v)
-	}
-	return _u
-}
-
-// SetContent sets the "content" field.
-func (_u *AnnouncementUpdateOne) SetContent(v string) *AnnouncementUpdateOne {
-	_u.mutation.SetContent(v)
-	return _u
-}
-
-// SetNillableContent sets the "content" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableContent(v *string) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetContent(*v)
-	}
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *AnnouncementUpdateOne) SetStatus(v string) *AnnouncementUpdateOne {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableStatus(v *string) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetNotifyMode sets the "notify_mode" field.
-func (_u *AnnouncementUpdateOne) SetNotifyMode(v string) *AnnouncementUpdateOne {
-	_u.mutation.SetNotifyMode(v)
-	return _u
-}
-
-// SetNillableNotifyMode sets the "notify_mode" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableNotifyMode(v *string) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetNotifyMode(*v)
-	}
-	return _u
-}
-
-// SetTargeting sets the "targeting" field.
-func (_u *AnnouncementUpdateOne) SetTargeting(v domain.AnnouncementTargeting) *AnnouncementUpdateOne {
-	_u.mutation.SetTargeting(v)
-	return _u
-}
-
-// SetNillableTargeting sets the "targeting" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableTargeting(v *domain.AnnouncementTargeting) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetTargeting(*v)
-	}
-	return _u
-}
-
-// ClearTargeting clears the value of the "targeting" field.
-func (_u *AnnouncementUpdateOne) ClearTargeting() *AnnouncementUpdateOne {
-	_u.mutation.ClearTargeting()
-	return _u
-}
-
-// SetStartsAt sets the "starts_at" field.
-func (_u *AnnouncementUpdateOne) SetStartsAt(v time.Time) *AnnouncementUpdateOne {
-	_u.mutation.SetStartsAt(v)
-	return _u
-}
-
-// SetNillableStartsAt sets the "starts_at" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableStartsAt(v *time.Time) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetStartsAt(*v)
-	}
-	return _u
-}
-
-// ClearStartsAt clears the value of the "starts_at" field.
-func (_u *AnnouncementUpdateOne) ClearStartsAt() *AnnouncementUpdateOne {
-	_u.mutation.ClearStartsAt()
-	return _u
-}
-
-// SetEndsAt sets the "ends_at" field.
-func (_u *AnnouncementUpdateOne) SetEndsAt(v time.Time) *AnnouncementUpdateOne {
-	_u.mutation.SetEndsAt(v)
-	return _u
-}
-
-// SetNillableEndsAt sets the "ends_at" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableEndsAt(v *time.Time) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetEndsAt(*v)
-	}
-	return _u
-}
-
-// ClearEndsAt clears the value of the "ends_at" field.
-func (_u *AnnouncementUpdateOne) ClearEndsAt() *AnnouncementUpdateOne {
-	_u.mutation.ClearEndsAt()
-	return _u
-}
-
-// SetCreatedBy sets the "created_by" field.
-func (_u *AnnouncementUpdateOne) SetCreatedBy(v int64) *AnnouncementUpdateOne {
-	_u.mutation.ResetCreatedBy()
-	_u.mutation.SetCreatedBy(v)
-	return _u
-}
-
-// SetNillableCreatedBy sets the "created_by" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableCreatedBy(v *int64) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetCreatedBy(*v)
-	}
-	return _u
-}
-
-// AddCreatedBy adds value to the "created_by" field.
-func (_u *AnnouncementUpdateOne) AddCreatedBy(v int64) *AnnouncementUpdateOne {
-	_u.mutation.AddCreatedBy(v)
-	return _u
-}
-
-// ClearCreatedBy clears the value of the "created_by" field.
-func (_u *AnnouncementUpdateOne) ClearCreatedBy() *AnnouncementUpdateOne {
-	_u.mutation.ClearCreatedBy()
-	return _u
-}
-
-// SetUpdatedBy sets the "updated_by" field.
-func (_u *AnnouncementUpdateOne) SetUpdatedBy(v int64) *AnnouncementUpdateOne {
-	_u.mutation.ResetUpdatedBy()
-	_u.mutation.SetUpdatedBy(v)
-	return _u
-}
-
-// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil.
-func (_u *AnnouncementUpdateOne) SetNillableUpdatedBy(v *int64) *AnnouncementUpdateOne {
-	if v != nil {
-		_u.SetUpdatedBy(*v)
-	}
-	return _u
-}
-
-// AddUpdatedBy adds value to the "updated_by" field.
-func (_u *AnnouncementUpdateOne) AddUpdatedBy(v int64) *AnnouncementUpdateOne {
-	_u.mutation.AddUpdatedBy(v)
-	return _u
-}
-
-// ClearUpdatedBy clears the value of the "updated_by" field.
-func (_u *AnnouncementUpdateOne) ClearUpdatedBy() *AnnouncementUpdateOne {
-	_u.mutation.ClearUpdatedBy()
-	return _u
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *AnnouncementUpdateOne) SetUpdatedAt(v time.Time) *AnnouncementUpdateOne {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// AddReadIDs adds the "reads" edge to the AnnouncementRead entity by IDs.
-func (_u *AnnouncementUpdateOne) AddReadIDs(ids ...int64) *AnnouncementUpdateOne {
-	_u.mutation.AddReadIDs(ids...)
-	return _u
-}
-
-// AddReads adds the "reads" edges to the AnnouncementRead entity.
-func (_u *AnnouncementUpdateOne) AddReads(v ...*AnnouncementRead) *AnnouncementUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddReadIDs(ids...)
-}
-
-// Mutation returns the AnnouncementMutation object of the builder.
-func (_u *AnnouncementUpdateOne) Mutation() *AnnouncementMutation {
-	return _u.mutation
-}
-
-// ClearReads clears all "reads" edges to the AnnouncementRead entity.
-func (_u *AnnouncementUpdateOne) ClearReads() *AnnouncementUpdateOne {
-	_u.mutation.ClearReads()
-	return _u
-}
-
-// RemoveReadIDs removes the "reads" edge to AnnouncementRead entities by IDs.
-func (_u *AnnouncementUpdateOne) RemoveReadIDs(ids ...int64) *AnnouncementUpdateOne {
-	_u.mutation.RemoveReadIDs(ids...)
-	return _u
-}
-
-// RemoveReads removes "reads" edges to AnnouncementRead entities.
-func (_u *AnnouncementUpdateOne) RemoveReads(v ...*AnnouncementRead) *AnnouncementUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemoveReadIDs(ids...)
-}
-
-// Where appends a list predicates to the AnnouncementUpdate builder.
-func (_u *AnnouncementUpdateOne) Where(ps ...predicate.Announcement) *AnnouncementUpdateOne {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (_u *AnnouncementUpdateOne) Select(field string, fields ...string) *AnnouncementUpdateOne {
-	_u.fields = append([]string{field}, fields...)
-	return _u
-}
-
-// Save executes the query and returns the updated Announcement entity.
-func (_u *AnnouncementUpdateOne) Save(ctx context.Context) (*Announcement, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *AnnouncementUpdateOne) SaveX(ctx context.Context) *Announcement {
-	node, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (_u *AnnouncementUpdateOne) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *AnnouncementUpdateOne) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *AnnouncementUpdateOne) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := announcement.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *AnnouncementUpdateOne) check() error {
-	if v, ok := _u.mutation.Title(); ok {
-		if err := announcement.TitleValidator(v); err != nil {
-			return &ValidationError{Name: "title", err: fmt.Errorf(`ent: validator failed for field "Announcement.title": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Content(); ok {
-		if err := announcement.ContentValidator(v); err != nil {
-			return &ValidationError{Name: "content", err: fmt.Errorf(`ent: validator failed for field "Announcement.content": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Status(); ok {
-		if err := announcement.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "Announcement.status": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.NotifyMode(); ok {
-		if err := announcement.NotifyModeValidator(v); err != nil {
-			return &ValidationError{Name: "notify_mode", err: fmt.Errorf(`ent: validator failed for field "Announcement.notify_mode": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *AnnouncementUpdateOne) sqlSave(ctx context.Context) (_node *Announcement, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(announcement.Table, announcement.Columns, sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64))
-	id, ok := _u.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Announcement.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := _u.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, announcement.FieldID)
-		for _, f := range fields {
-			if !announcement.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != announcement.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.Title(); ok {
-		_spec.SetField(announcement.FieldTitle, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Content(); ok {
-		_spec.SetField(announcement.FieldContent, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(announcement.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.NotifyMode(); ok {
-		_spec.SetField(announcement.FieldNotifyMode, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Targeting(); ok {
-		_spec.SetField(announcement.FieldTargeting, field.TypeJSON, value)
-	}
-	if _u.mutation.TargetingCleared() {
-		_spec.ClearField(announcement.FieldTargeting, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.StartsAt(); ok {
-		_spec.SetField(announcement.FieldStartsAt, field.TypeTime, value)
-	}
-	if _u.mutation.StartsAtCleared() {
-		_spec.ClearField(announcement.FieldStartsAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.EndsAt(); ok {
-		_spec.SetField(announcement.FieldEndsAt, field.TypeTime, value)
-	}
-	if _u.mutation.EndsAtCleared() {
-		_spec.ClearField(announcement.FieldEndsAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.CreatedBy(); ok {
-		_spec.SetField(announcement.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedCreatedBy(); ok {
-		_spec.AddField(announcement.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if _u.mutation.CreatedByCleared() {
-		_spec.ClearField(announcement.FieldCreatedBy, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.UpdatedBy(); ok {
-		_spec.SetField(announcement.FieldUpdatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedUpdatedBy(); ok {
-		_spec.AddField(announcement.FieldUpdatedBy, field.TypeInt64, value)
-	}
-	if _u.mutation.UpdatedByCleared() {
-		_spec.ClearField(announcement.FieldUpdatedBy, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(announcement.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if _u.mutation.ReadsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   announcement.ReadsTable,
-			Columns: []string{announcement.ReadsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedReadsIDs(); len(nodes) > 0 && !_u.mutation.ReadsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   announcement.ReadsTable,
-			Columns: []string{announcement.ReadsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.ReadsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   announcement.ReadsTable,
-			Columns: []string{announcement.ReadsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	_node = &Announcement{config: _u.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{announcement.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}

backend/ent/announcementread.go

@@ -1,185 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// AnnouncementRead is the model entity for the AnnouncementRead schema.
-type AnnouncementRead struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int64 `json:"id,omitempty"`
-	// AnnouncementID holds the value of the "announcement_id" field.
-	AnnouncementID int64 `json:"announcement_id,omitempty"`
-	// UserID holds the value of the "user_id" field.
-	UserID int64 `json:"user_id,omitempty"`
-	// 用户首次已读时间
-	ReadAt time.Time `json:"read_at,omitempty"`
-	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the AnnouncementReadQuery when eager-loading is set.
-	Edges        AnnouncementReadEdges `json:"edges"`
-	selectValues sql.SelectValues
-}
-
-// AnnouncementReadEdges holds the relations/edges for other nodes in the graph.
-type AnnouncementReadEdges struct {
-	// Announcement holds the value of the announcement edge.
-	Announcement *Announcement `json:"announcement,omitempty"`
-	// User holds the value of the user edge.
-	User *User `json:"user,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [2]bool
-}
-
-// AnnouncementOrErr returns the Announcement value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e AnnouncementReadEdges) AnnouncementOrErr() (*Announcement, error) {
-	if e.Announcement != nil {
-		return e.Announcement, nil
-	} else if e.loadedTypes[0] {
-		return nil, &NotFoundError{label: announcement.Label}
-	}
-	return nil, &NotLoadedError{edge: "announcement"}
-}
-
-// UserOrErr returns the User value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e AnnouncementReadEdges) UserOrErr() (*User, error) {
-	if e.User != nil {
-		return e.User, nil
-	} else if e.loadedTypes[1] {
-		return nil, &NotFoundError{label: user.Label}
-	}
-	return nil, &NotLoadedError{edge: "user"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*AnnouncementRead) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case announcementread.FieldID, announcementread.FieldAnnouncementID, announcementread.FieldUserID:
-			values[i] = new(sql.NullInt64)
-		case announcementread.FieldReadAt, announcementread.FieldCreatedAt:
-			values[i] = new(sql.NullTime)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the AnnouncementRead fields.
-func (_m *AnnouncementRead) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case announcementread.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			_m.ID = int64(value.Int64)
-		case announcementread.FieldAnnouncementID:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field announcement_id", values[i])
-			} else if value.Valid {
-				_m.AnnouncementID = value.Int64
-			}
-		case announcementread.FieldUserID:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field user_id", values[i])
-			} else if value.Valid {
-				_m.UserID = value.Int64
-			}
-		case announcementread.FieldReadAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field read_at", values[i])
-			} else if value.Valid {
-				_m.ReadAt = value.Time
-			}
-		case announcementread.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field created_at", values[i])
-			} else if value.Valid {
-				_m.CreatedAt = value.Time
-			}
-		default:
-			_m.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the AnnouncementRead.
-// This includes values selected through modifiers, order, etc.
-func (_m *AnnouncementRead) Value(name string) (ent.Value, error) {
-	return _m.selectValues.Get(name)
-}
-
-// QueryAnnouncement queries the "announcement" edge of the AnnouncementRead entity.
-func (_m *AnnouncementRead) QueryAnnouncement() *AnnouncementQuery {
-	return NewAnnouncementReadClient(_m.config).QueryAnnouncement(_m)
-}
-
-// QueryUser queries the "user" edge of the AnnouncementRead entity.
-func (_m *AnnouncementRead) QueryUser() *UserQuery {
-	return NewAnnouncementReadClient(_m.config).QueryUser(_m)
-}
-
-// Update returns a builder for updating this AnnouncementRead.
-// Note that you need to call AnnouncementRead.Unwrap() before calling this method if this AnnouncementRead
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *AnnouncementRead) Update() *AnnouncementReadUpdateOne {
-	return NewAnnouncementReadClient(_m.config).UpdateOne(_m)
-}
-
-// Unwrap unwraps the AnnouncementRead entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (_m *AnnouncementRead) Unwrap() *AnnouncementRead {
-	_tx, ok := _m.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: AnnouncementRead is not a transactional entity")
-	}
-	_m.config.driver = _tx.drv
-	return _m
-}
-
-// String implements the fmt.Stringer.
-func (_m *AnnouncementRead) String() string {
-	var builder strings.Builder
-	builder.WriteString("AnnouncementRead(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
-	builder.WriteString("announcement_id=")
-	builder.WriteString(fmt.Sprintf("%v", _m.AnnouncementID))
-	builder.WriteString(", ")
-	builder.WriteString("user_id=")
-	builder.WriteString(fmt.Sprintf("%v", _m.UserID))
-	builder.WriteString(", ")
-	builder.WriteString("read_at=")
-	builder.WriteString(_m.ReadAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("created_at=")
-	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// AnnouncementReads is a parsable slice of AnnouncementRead.
-type AnnouncementReads []*AnnouncementRead

backend/ent/announcementread/announcementread.go

@@ -1,127 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package announcementread
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-const (
-	// Label holds the string label denoting the announcementread type in the database.
-	Label = "announcement_read"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldAnnouncementID holds the string denoting the announcement_id field in the database.
-	FieldAnnouncementID = "announcement_id"
-	// FieldUserID holds the string denoting the user_id field in the database.
-	FieldUserID = "user_id"
-	// FieldReadAt holds the string denoting the read_at field in the database.
-	FieldReadAt = "read_at"
-	// FieldCreatedAt holds the string denoting the created_at field in the database.
-	FieldCreatedAt = "created_at"
-	// EdgeAnnouncement holds the string denoting the announcement edge name in mutations.
-	EdgeAnnouncement = "announcement"
-	// EdgeUser holds the string denoting the user edge name in mutations.
-	EdgeUser = "user"
-	// Table holds the table name of the announcementread in the database.
-	Table = "announcement_reads"
-	// AnnouncementTable is the table that holds the announcement relation/edge.
-	AnnouncementTable = "announcement_reads"
-	// AnnouncementInverseTable is the table name for the Announcement entity.
-	// It exists in this package in order to avoid circular dependency with the "announcement" package.
-	AnnouncementInverseTable = "announcements"
-	// AnnouncementColumn is the table column denoting the announcement relation/edge.
-	AnnouncementColumn = "announcement_id"
-	// UserTable is the table that holds the user relation/edge.
-	UserTable = "announcement_reads"
-	// UserInverseTable is the table name for the User entity.
-	// It exists in this package in order to avoid circular dependency with the "user" package.
-	UserInverseTable = "users"
-	// UserColumn is the table column denoting the user relation/edge.
-	UserColumn = "user_id"
-)
-
-// Columns holds all SQL columns for announcementread fields.
-var Columns = []string{
-	FieldID,
-	FieldAnnouncementID,
-	FieldUserID,
-	FieldReadAt,
-	FieldCreatedAt,
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// DefaultReadAt holds the default value on creation for the "read_at" field.
-	DefaultReadAt func() time.Time
-	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() time.Time
-)
-
-// OrderOption defines the ordering options for the AnnouncementRead queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByAnnouncementID orders the results by the announcement_id field.
-func ByAnnouncementID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldAnnouncementID, opts...).ToFunc()
-}
-
-// ByUserID orders the results by the user_id field.
-func ByUserID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUserID, opts...).ToFunc()
-}
-
-// ByReadAt orders the results by the read_at field.
-func ByReadAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldReadAt, opts...).ToFunc()
-}
-
-// ByCreatedAt orders the results by the created_at field.
-func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
-}
-
-// ByAnnouncementField orders the results by announcement field.
-func ByAnnouncementField(field string, opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newAnnouncementStep(), sql.OrderByField(field, opts...))
-	}
-}
-
-// ByUserField orders the results by user field.
-func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
-	}
-}
-func newAnnouncementStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(AnnouncementInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2O, true, AnnouncementTable, AnnouncementColumn),
-	)
-}
-func newUserStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(UserInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
-	)
-}

backend/ent/announcementread/where.go

@@ -1,257 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package announcementread
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldLTE(FieldID, id))
-}
-
-// AnnouncementID applies equality check predicate on the "announcement_id" field. It's identical to AnnouncementIDEQ.
-func AnnouncementID(v int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldAnnouncementID, v))
-}
-
-// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
-func UserID(v int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldUserID, v))
-}
-
-// ReadAt applies equality check predicate on the "read_at" field. It's identical to ReadAtEQ.
-func ReadAt(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldReadAt, v))
-}
-
-// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// AnnouncementIDEQ applies the EQ predicate on the "announcement_id" field.
-func AnnouncementIDEQ(v int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldAnnouncementID, v))
-}
-
-// AnnouncementIDNEQ applies the NEQ predicate on the "announcement_id" field.
-func AnnouncementIDNEQ(v int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNEQ(FieldAnnouncementID, v))
-}
-
-// AnnouncementIDIn applies the In predicate on the "announcement_id" field.
-func AnnouncementIDIn(vs ...int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldIn(FieldAnnouncementID, vs...))
-}
-
-// AnnouncementIDNotIn applies the NotIn predicate on the "announcement_id" field.
-func AnnouncementIDNotIn(vs ...int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNotIn(FieldAnnouncementID, vs...))
-}
-
-// UserIDEQ applies the EQ predicate on the "user_id" field.
-func UserIDEQ(v int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldUserID, v))
-}
-
-// UserIDNEQ applies the NEQ predicate on the "user_id" field.
-func UserIDNEQ(v int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNEQ(FieldUserID, v))
-}
-
-// UserIDIn applies the In predicate on the "user_id" field.
-func UserIDIn(vs ...int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldIn(FieldUserID, vs...))
-}
-
-// UserIDNotIn applies the NotIn predicate on the "user_id" field.
-func UserIDNotIn(vs ...int64) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNotIn(FieldUserID, vs...))
-}
-
-// ReadAtEQ applies the EQ predicate on the "read_at" field.
-func ReadAtEQ(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldReadAt, v))
-}
-
-// ReadAtNEQ applies the NEQ predicate on the "read_at" field.
-func ReadAtNEQ(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNEQ(FieldReadAt, v))
-}
-
-// ReadAtIn applies the In predicate on the "read_at" field.
-func ReadAtIn(vs ...time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldIn(FieldReadAt, vs...))
-}
-
-// ReadAtNotIn applies the NotIn predicate on the "read_at" field.
-func ReadAtNotIn(vs ...time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNotIn(FieldReadAt, vs...))
-}
-
-// ReadAtGT applies the GT predicate on the "read_at" field.
-func ReadAtGT(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldGT(FieldReadAt, v))
-}
-
-// ReadAtGTE applies the GTE predicate on the "read_at" field.
-func ReadAtGTE(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldGTE(FieldReadAt, v))
-}
-
-// ReadAtLT applies the LT predicate on the "read_at" field.
-func ReadAtLT(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldLT(FieldReadAt, v))
-}
-
-// ReadAtLTE applies the LTE predicate on the "read_at" field.
-func ReadAtLTE(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldLTE(FieldReadAt, v))
-}
-
-// CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldNotIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldGT(FieldCreatedAt, v))
-}
-
-// CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldGTE(FieldCreatedAt, v))
-}
-
-// CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldLT(FieldCreatedAt, v))
-}
-
-// CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.FieldLTE(FieldCreatedAt, v))
-}
-
-// HasAnnouncement applies the HasEdge predicate on the "announcement" edge.
-func HasAnnouncement() predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, AnnouncementTable, AnnouncementColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasAnnouncementWith applies the HasEdge predicate on the "announcement" edge with a given conditions (other predicates).
-func HasAnnouncementWith(preds ...predicate.Announcement) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(func(s *sql.Selector) {
-		step := newAnnouncementStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// HasUser applies the HasEdge predicate on the "user" edge.
-func HasUser() predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
-func HasUserWith(preds ...predicate.User) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(func(s *sql.Selector) {
-		step := newUserStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.AnnouncementRead) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.AnnouncementRead) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.AnnouncementRead) predicate.AnnouncementRead {
-	return predicate.AnnouncementRead(sql.NotPredicates(p))
-}

backend/ent/announcementread_create.go

@@ -1,660 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// AnnouncementReadCreate is the builder for creating a AnnouncementRead entity.
-type AnnouncementReadCreate struct {
-	config
-	mutation *AnnouncementReadMutation
-	hooks    []Hook
-	conflict []sql.ConflictOption
-}
-
-// SetAnnouncementID sets the "announcement_id" field.
-func (_c *AnnouncementReadCreate) SetAnnouncementID(v int64) *AnnouncementReadCreate {
-	_c.mutation.SetAnnouncementID(v)
-	return _c
-}
-
-// SetUserID sets the "user_id" field.
-func (_c *AnnouncementReadCreate) SetUserID(v int64) *AnnouncementReadCreate {
-	_c.mutation.SetUserID(v)
-	return _c
-}
-
-// SetReadAt sets the "read_at" field.
-func (_c *AnnouncementReadCreate) SetReadAt(v time.Time) *AnnouncementReadCreate {
-	_c.mutation.SetReadAt(v)
-	return _c
-}
-
-// SetNillableReadAt sets the "read_at" field if the given value is not nil.
-func (_c *AnnouncementReadCreate) SetNillableReadAt(v *time.Time) *AnnouncementReadCreate {
-	if v != nil {
-		_c.SetReadAt(*v)
-	}
-	return _c
-}
-
-// SetCreatedAt sets the "created_at" field.
-func (_c *AnnouncementReadCreate) SetCreatedAt(v time.Time) *AnnouncementReadCreate {
-	_c.mutation.SetCreatedAt(v)
-	return _c
-}
-
-// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
-func (_c *AnnouncementReadCreate) SetNillableCreatedAt(v *time.Time) *AnnouncementReadCreate {
-	if v != nil {
-		_c.SetCreatedAt(*v)
-	}
-	return _c
-}
-
-// SetAnnouncement sets the "announcement" edge to the Announcement entity.
-func (_c *AnnouncementReadCreate) SetAnnouncement(v *Announcement) *AnnouncementReadCreate {
-	return _c.SetAnnouncementID(v.ID)
-}
-
-// SetUser sets the "user" edge to the User entity.
-func (_c *AnnouncementReadCreate) SetUser(v *User) *AnnouncementReadCreate {
-	return _c.SetUserID(v.ID)
-}
-
-// Mutation returns the AnnouncementReadMutation object of the builder.
-func (_c *AnnouncementReadCreate) Mutation() *AnnouncementReadMutation {
-	return _c.mutation
-}
-
-// Save creates the AnnouncementRead in the database.
-func (_c *AnnouncementReadCreate) Save(ctx context.Context) (*AnnouncementRead, error) {
-	_c.defaults()
-	return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
-}
-
-// SaveX calls Save and panics if Save returns an error.
-func (_c *AnnouncementReadCreate) SaveX(ctx context.Context) *AnnouncementRead {
-	v, err := _c.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (_c *AnnouncementReadCreate) Exec(ctx context.Context) error {
-	_, err := _c.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_c *AnnouncementReadCreate) ExecX(ctx context.Context) {
-	if err := _c.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_c *AnnouncementReadCreate) defaults() {
-	if _, ok := _c.mutation.ReadAt(); !ok {
-		v := announcementread.DefaultReadAt()
-		_c.mutation.SetReadAt(v)
-	}
-	if _, ok := _c.mutation.CreatedAt(); !ok {
-		v := announcementread.DefaultCreatedAt()
-		_c.mutation.SetCreatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_c *AnnouncementReadCreate) check() error {
-	if _, ok := _c.mutation.AnnouncementID(); !ok {
-		return &ValidationError{Name: "announcement_id", err: errors.New(`ent: missing required field "AnnouncementRead.announcement_id"`)}
-	}
-	if _, ok := _c.mutation.UserID(); !ok {
-		return &ValidationError{Name: "user_id", err: errors.New(`ent: missing required field "AnnouncementRead.user_id"`)}
-	}
-	if _, ok := _c.mutation.ReadAt(); !ok {
-		return &ValidationError{Name: "read_at", err: errors.New(`ent: missing required field "AnnouncementRead.read_at"`)}
-	}
-	if _, ok := _c.mutation.CreatedAt(); !ok {
-		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "AnnouncementRead.created_at"`)}
-	}
-	if len(_c.mutation.AnnouncementIDs()) == 0 {
-		return &ValidationError{Name: "announcement", err: errors.New(`ent: missing required edge "AnnouncementRead.announcement"`)}
-	}
-	if len(_c.mutation.UserIDs()) == 0 {
-		return &ValidationError{Name: "user", err: errors.New(`ent: missing required edge "AnnouncementRead.user"`)}
-	}
-	return nil
-}
-
-func (_c *AnnouncementReadCreate) sqlSave(ctx context.Context) (*AnnouncementRead, error) {
-	if err := _c.check(); err != nil {
-		return nil, err
-	}
-	_node, _spec := _c.createSpec()
-	if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil {
-		if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	id := _spec.ID.Value.(int64)
-	_node.ID = int64(id)
-	_c.mutation.id = &_node.ID
-	_c.mutation.done = true
-	return _node, nil
-}
-
-func (_c *AnnouncementReadCreate) createSpec() (*AnnouncementRead, *sqlgraph.CreateSpec) {
-	var (
-		_node = &AnnouncementRead{config: _c.config}
-		_spec = sqlgraph.NewCreateSpec(announcementread.Table, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64))
-	)
-	_spec.OnConflict = _c.conflict
-	if value, ok := _c.mutation.ReadAt(); ok {
-		_spec.SetField(announcementread.FieldReadAt, field.TypeTime, value)
-		_node.ReadAt = value
-	}
-	if value, ok := _c.mutation.CreatedAt(); ok {
-		_spec.SetField(announcementread.FieldCreatedAt, field.TypeTime, value)
-		_node.CreatedAt = value
-	}
-	if nodes := _c.mutation.AnnouncementIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.AnnouncementTable,
-			Columns: []string{announcementread.AnnouncementColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.AnnouncementID = nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	if nodes := _c.mutation.UserIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.UserTable,
-			Columns: []string{announcementread.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.UserID = nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	return _node, _spec
-}
-
-// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
-// of the `INSERT` statement. For example:
-//
-//	client.AnnouncementRead.Create().
-//		SetAnnouncementID(v).
-//		OnConflict(
-//			// Update the row with the new values
-//			// the was proposed for insertion.
-//			sql.ResolveWithNewValues(),
-//		).
-//		// Override some of the fields with custom
-//		// update values.
-//		Update(func(u *ent.AnnouncementReadUpsert) {
-//			SetAnnouncementID(v+v).
-//		}).
-//		Exec(ctx)
-func (_c *AnnouncementReadCreate) OnConflict(opts ...sql.ConflictOption) *AnnouncementReadUpsertOne {
-	_c.conflict = opts
-	return &AnnouncementReadUpsertOne{
-		create: _c,
-	}
-}
-
-// OnConflictColumns calls `OnConflict` and configures the columns
-// as conflict target. Using this option is equivalent to using:
-//
-//	client.AnnouncementRead.Create().
-//		OnConflict(sql.ConflictColumns(columns...)).
-//		Exec(ctx)
-func (_c *AnnouncementReadCreate) OnConflictColumns(columns ...string) *AnnouncementReadUpsertOne {
-	_c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
-	return &AnnouncementReadUpsertOne{
-		create: _c,
-	}
-}
-
-type (
-	// AnnouncementReadUpsertOne is the builder for "upsert"-ing
-	//  one AnnouncementRead node.
-	AnnouncementReadUpsertOne struct {
-		create *AnnouncementReadCreate
-	}
-
-	// AnnouncementReadUpsert is the "OnConflict" setter.
-	AnnouncementReadUpsert struct {
-		*sql.UpdateSet
-	}
-)
-
-// SetAnnouncementID sets the "announcement_id" field.
-func (u *AnnouncementReadUpsert) SetAnnouncementID(v int64) *AnnouncementReadUpsert {
-	u.Set(announcementread.FieldAnnouncementID, v)
-	return u
-}
-
-// UpdateAnnouncementID sets the "announcement_id" field to the value that was provided on create.
-func (u *AnnouncementReadUpsert) UpdateAnnouncementID() *AnnouncementReadUpsert {
-	u.SetExcluded(announcementread.FieldAnnouncementID)
-	return u
-}
-
-// SetUserID sets the "user_id" field.
-func (u *AnnouncementReadUpsert) SetUserID(v int64) *AnnouncementReadUpsert {
-	u.Set(announcementread.FieldUserID, v)
-	return u
-}
-
-// UpdateUserID sets the "user_id" field to the value that was provided on create.
-func (u *AnnouncementReadUpsert) UpdateUserID() *AnnouncementReadUpsert {
-	u.SetExcluded(announcementread.FieldUserID)
-	return u
-}
-
-// SetReadAt sets the "read_at" field.
-func (u *AnnouncementReadUpsert) SetReadAt(v time.Time) *AnnouncementReadUpsert {
-	u.Set(announcementread.FieldReadAt, v)
-	return u
-}
-
-// UpdateReadAt sets the "read_at" field to the value that was provided on create.
-func (u *AnnouncementReadUpsert) UpdateReadAt() *AnnouncementReadUpsert {
-	u.SetExcluded(announcementread.FieldReadAt)
-	return u
-}
-
-// UpdateNewValues updates the mutable fields using the new values that were set on create.
-// Using this option is equivalent to using:
-//
-//	client.AnnouncementRead.Create().
-//		OnConflict(
-//			sql.ResolveWithNewValues(),
-//		).
-//		Exec(ctx)
-func (u *AnnouncementReadUpsertOne) UpdateNewValues() *AnnouncementReadUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
-	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
-		if _, exists := u.create.mutation.CreatedAt(); exists {
-			s.SetIgnore(announcementread.FieldCreatedAt)
-		}
-	}))
-	return u
-}
-
-// Ignore sets each column to itself in case of conflict.
-// Using this option is equivalent to using:
-//
-//	client.AnnouncementRead.Create().
-//	    OnConflict(sql.ResolveWithIgnore()).
-//	    Exec(ctx)
-func (u *AnnouncementReadUpsertOne) Ignore() *AnnouncementReadUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
-	return u
-}
-
-// DoNothing configures the conflict_action to `DO NOTHING`.
-// Supported only by SQLite and PostgreSQL.
-func (u *AnnouncementReadUpsertOne) DoNothing() *AnnouncementReadUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.DoNothing())
-	return u
-}
-
-// Update allows overriding fields `UPDATE` values. See the AnnouncementReadCreate.OnConflict
-// documentation for more info.
-func (u *AnnouncementReadUpsertOne) Update(set func(*AnnouncementReadUpsert)) *AnnouncementReadUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
-		set(&AnnouncementReadUpsert{UpdateSet: update})
-	}))
-	return u
-}
-
-// SetAnnouncementID sets the "announcement_id" field.
-func (u *AnnouncementReadUpsertOne) SetAnnouncementID(v int64) *AnnouncementReadUpsertOne {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.SetAnnouncementID(v)
-	})
-}
-
-// UpdateAnnouncementID sets the "announcement_id" field to the value that was provided on create.
-func (u *AnnouncementReadUpsertOne) UpdateAnnouncementID() *AnnouncementReadUpsertOne {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.UpdateAnnouncementID()
-	})
-}
-
-// SetUserID sets the "user_id" field.
-func (u *AnnouncementReadUpsertOne) SetUserID(v int64) *AnnouncementReadUpsertOne {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.SetUserID(v)
-	})
-}
-
-// UpdateUserID sets the "user_id" field to the value that was provided on create.
-func (u *AnnouncementReadUpsertOne) UpdateUserID() *AnnouncementReadUpsertOne {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.UpdateUserID()
-	})
-}
-
-// SetReadAt sets the "read_at" field.
-func (u *AnnouncementReadUpsertOne) SetReadAt(v time.Time) *AnnouncementReadUpsertOne {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.SetReadAt(v)
-	})
-}
-
-// UpdateReadAt sets the "read_at" field to the value that was provided on create.
-func (u *AnnouncementReadUpsertOne) UpdateReadAt() *AnnouncementReadUpsertOne {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.UpdateReadAt()
-	})
-}
-
-// Exec executes the query.
-func (u *AnnouncementReadUpsertOne) Exec(ctx context.Context) error {
-	if len(u.create.conflict) == 0 {
-		return errors.New("ent: missing options for AnnouncementReadCreate.OnConflict")
-	}
-	return u.create.Exec(ctx)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (u *AnnouncementReadUpsertOne) ExecX(ctx context.Context) {
-	if err := u.create.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// Exec executes the UPSERT query and returns the inserted/updated ID.
-func (u *AnnouncementReadUpsertOne) ID(ctx context.Context) (id int64, err error) {
-	node, err := u.create.Save(ctx)
-	if err != nil {
-		return id, err
-	}
-	return node.ID, nil
-}
-
-// IDX is like ID, but panics if an error occurs.
-func (u *AnnouncementReadUpsertOne) IDX(ctx context.Context) int64 {
-	id, err := u.ID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// AnnouncementReadCreateBulk is the builder for creating many AnnouncementRead entities in bulk.
-type AnnouncementReadCreateBulk struct {
-	config
-	err      error
-	builders []*AnnouncementReadCreate
-	conflict []sql.ConflictOption
-}
-
-// Save creates the AnnouncementRead entities in the database.
-func (_c *AnnouncementReadCreateBulk) Save(ctx context.Context) ([]*AnnouncementRead, error) {
-	if _c.err != nil {
-		return nil, _c.err
-	}
-	specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
-	nodes := make([]*AnnouncementRead, len(_c.builders))
-	mutators := make([]Mutator, len(_c.builders))
-	for i := range _c.builders {
-		func(i int, root context.Context) {
-			builder := _c.builders[i]
-			builder.defaults()
-			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-				mutation, ok := m.(*AnnouncementReadMutation)
-				if !ok {
-					return nil, fmt.Errorf("unexpected mutation type %T", m)
-				}
-				if err := builder.check(); err != nil {
-					return nil, err
-				}
-				builder.mutation = mutation
-				var err error
-				nodes[i], specs[i] = builder.createSpec()
-				if i < len(mutators)-1 {
-					_, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
-				} else {
-					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
-					spec.OnConflict = _c.conflict
-					// Invoke the actual operation on the latest mutation in the chain.
-					if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil {
-						if sqlgraph.IsConstraintError(err) {
-							err = &ConstraintError{msg: err.Error(), wrap: err}
-						}
-					}
-				}
-				if err != nil {
-					return nil, err
-				}
-				mutation.id = &nodes[i].ID
-				if specs[i].ID.Value != nil {
-					id := specs[i].ID.Value.(int64)
-					nodes[i].ID = int64(id)
-				}
-				mutation.done = true
-				return nodes[i], nil
-			})
-			for i := len(builder.hooks) - 1; i >= 0; i-- {
-				mut = builder.hooks[i](mut)
-			}
-			mutators[i] = mut
-		}(i, ctx)
-	}
-	if len(mutators) > 0 {
-		if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_c *AnnouncementReadCreateBulk) SaveX(ctx context.Context) []*AnnouncementRead {
-	v, err := _c.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (_c *AnnouncementReadCreateBulk) Exec(ctx context.Context) error {
-	_, err := _c.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_c *AnnouncementReadCreateBulk) ExecX(ctx context.Context) {
-	if err := _c.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
-// of the `INSERT` statement. For example:
-//
-//	client.AnnouncementRead.CreateBulk(builders...).
-//		OnConflict(
-//			// Update the row with the new values
-//			// the was proposed for insertion.
-//			sql.ResolveWithNewValues(),
-//		).
-//		// Override some of the fields with custom
-//		// update values.
-//		Update(func(u *ent.AnnouncementReadUpsert) {
-//			SetAnnouncementID(v+v).
-//		}).
-//		Exec(ctx)
-func (_c *AnnouncementReadCreateBulk) OnConflict(opts ...sql.ConflictOption) *AnnouncementReadUpsertBulk {
-	_c.conflict = opts
-	return &AnnouncementReadUpsertBulk{
-		create: _c,
-	}
-}
-
-// OnConflictColumns calls `OnConflict` and configures the columns
-// as conflict target. Using this option is equivalent to using:
-//
-//	client.AnnouncementRead.Create().
-//		OnConflict(sql.ConflictColumns(columns...)).
-//		Exec(ctx)
-func (_c *AnnouncementReadCreateBulk) OnConflictColumns(columns ...string) *AnnouncementReadUpsertBulk {
-	_c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
-	return &AnnouncementReadUpsertBulk{
-		create: _c,
-	}
-}
-
-// AnnouncementReadUpsertBulk is the builder for "upsert"-ing
-// a bulk of AnnouncementRead nodes.
-type AnnouncementReadUpsertBulk struct {
-	create *AnnouncementReadCreateBulk
-}
-
-// UpdateNewValues updates the mutable fields using the new values that
-// were set on create. Using this option is equivalent to using:
-//
-//	client.AnnouncementRead.Create().
-//		OnConflict(
-//			sql.ResolveWithNewValues(),
-//		).
-//		Exec(ctx)
-func (u *AnnouncementReadUpsertBulk) UpdateNewValues() *AnnouncementReadUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
-	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
-		for _, b := range u.create.builders {
-			if _, exists := b.mutation.CreatedAt(); exists {
-				s.SetIgnore(announcementread.FieldCreatedAt)
-			}
-		}
-	}))
-	return u
-}
-
-// Ignore sets each column to itself in case of conflict.
-// Using this option is equivalent to using:
-//
-//	client.AnnouncementRead.Create().
-//		OnConflict(sql.ResolveWithIgnore()).
-//		Exec(ctx)
-func (u *AnnouncementReadUpsertBulk) Ignore() *AnnouncementReadUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
-	return u
-}
-
-// DoNothing configures the conflict_action to `DO NOTHING`.
-// Supported only by SQLite and PostgreSQL.
-func (u *AnnouncementReadUpsertBulk) DoNothing() *AnnouncementReadUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.DoNothing())
-	return u
-}
-
-// Update allows overriding fields `UPDATE` values. See the AnnouncementReadCreateBulk.OnConflict
-// documentation for more info.
-func (u *AnnouncementReadUpsertBulk) Update(set func(*AnnouncementReadUpsert)) *AnnouncementReadUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
-		set(&AnnouncementReadUpsert{UpdateSet: update})
-	}))
-	return u
-}
-
-// SetAnnouncementID sets the "announcement_id" field.
-func (u *AnnouncementReadUpsertBulk) SetAnnouncementID(v int64) *AnnouncementReadUpsertBulk {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.SetAnnouncementID(v)
-	})
-}
-
-// UpdateAnnouncementID sets the "announcement_id" field to the value that was provided on create.
-func (u *AnnouncementReadUpsertBulk) UpdateAnnouncementID() *AnnouncementReadUpsertBulk {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.UpdateAnnouncementID()
-	})
-}
-
-// SetUserID sets the "user_id" field.
-func (u *AnnouncementReadUpsertBulk) SetUserID(v int64) *AnnouncementReadUpsertBulk {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.SetUserID(v)
-	})
-}
-
-// UpdateUserID sets the "user_id" field to the value that was provided on create.
-func (u *AnnouncementReadUpsertBulk) UpdateUserID() *AnnouncementReadUpsertBulk {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.UpdateUserID()
-	})
-}
-
-// SetReadAt sets the "read_at" field.
-func (u *AnnouncementReadUpsertBulk) SetReadAt(v time.Time) *AnnouncementReadUpsertBulk {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.SetReadAt(v)
-	})
-}
-
-// UpdateReadAt sets the "read_at" field to the value that was provided on create.
-func (u *AnnouncementReadUpsertBulk) UpdateReadAt() *AnnouncementReadUpsertBulk {
-	return u.Update(func(s *AnnouncementReadUpsert) {
-		s.UpdateReadAt()
-	})
-}
-
-// Exec executes the query.
-func (u *AnnouncementReadUpsertBulk) Exec(ctx context.Context) error {
-	if u.create.err != nil {
-		return u.create.err
-	}
-	for i, b := range u.create.builders {
-		if len(b.conflict) != 0 {
-			return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the AnnouncementReadCreateBulk instead", i)
-		}
-	}
-	if len(u.create.conflict) == 0 {
-		return errors.New("ent: missing options for AnnouncementReadCreateBulk.OnConflict")
-	}
-	return u.create.Exec(ctx)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (u *AnnouncementReadUpsertBulk) ExecX(ctx context.Context) {
-	if err := u.create.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/announcementread_delete.go

@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// AnnouncementReadDelete is the builder for deleting a AnnouncementRead entity.
-type AnnouncementReadDelete struct {
-	config
-	hooks    []Hook
-	mutation *AnnouncementReadMutation
-}
-
-// Where appends a list predicates to the AnnouncementReadDelete builder.
-func (_d *AnnouncementReadDelete) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadDelete {
-	_d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *AnnouncementReadDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *AnnouncementReadDelete) ExecX(ctx context.Context) int {
-	n, err := _d.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (_d *AnnouncementReadDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(announcementread.Table, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64))
-	if ps := _d.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	_d.mutation.done = true
-	return affected, err
-}
-
-// AnnouncementReadDeleteOne is the builder for deleting a single AnnouncementRead entity.
-type AnnouncementReadDeleteOne struct {
-	_d *AnnouncementReadDelete
-}
-
-// Where appends a list predicates to the AnnouncementReadDelete builder.
-func (_d *AnnouncementReadDeleteOne) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadDeleteOne {
-	_d._d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query.
-func (_d *AnnouncementReadDeleteOne) Exec(ctx context.Context) error {
-	n, err := _d._d.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{announcementread.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *AnnouncementReadDeleteOne) ExecX(ctx context.Context) {
-	if err := _d.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/announcementread_query.go

@@ -1,718 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"fmt"
-	"math"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// AnnouncementReadQuery is the builder for querying AnnouncementRead entities.
-type AnnouncementReadQuery struct {
-	config
-	ctx              *QueryContext
-	order            []announcementread.OrderOption
-	inters           []Interceptor
-	predicates       []predicate.AnnouncementRead
-	withAnnouncement *AnnouncementQuery
-	withUser         *UserQuery
-	modifiers        []func(*sql.Selector)
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the AnnouncementReadQuery builder.
-func (_q *AnnouncementReadQuery) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadQuery {
-	_q.predicates = append(_q.predicates, ps...)
-	return _q
-}
-
-// Limit the number of records to be returned by this query.
-func (_q *AnnouncementReadQuery) Limit(limit int) *AnnouncementReadQuery {
-	_q.ctx.Limit = &limit
-	return _q
-}
-
-// Offset to start from.
-func (_q *AnnouncementReadQuery) Offset(offset int) *AnnouncementReadQuery {
-	_q.ctx.Offset = &offset
-	return _q
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (_q *AnnouncementReadQuery) Unique(unique bool) *AnnouncementReadQuery {
-	_q.ctx.Unique = &unique
-	return _q
-}
-
-// Order specifies how the records should be ordered.
-func (_q *AnnouncementReadQuery) Order(o ...announcementread.OrderOption) *AnnouncementReadQuery {
-	_q.order = append(_q.order, o...)
-	return _q
-}
-
-// QueryAnnouncement chains the current query on the "announcement" edge.
-func (_q *AnnouncementReadQuery) QueryAnnouncement() *AnnouncementQuery {
-	query := (&AnnouncementClient{config: _q.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := _q.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := _q.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(announcementread.Table, announcementread.FieldID, selector),
-			sqlgraph.To(announcement.Table, announcement.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, announcementread.AnnouncementTable, announcementread.AnnouncementColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// QueryUser chains the current query on the "user" edge.
-func (_q *AnnouncementReadQuery) QueryUser() *UserQuery {
-	query := (&UserClient{config: _q.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := _q.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := _q.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(announcementread.Table, announcementread.FieldID, selector),
-			sqlgraph.To(user.Table, user.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, announcementread.UserTable, announcementread.UserColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first AnnouncementRead entity from the query.
-// Returns a *NotFoundError when no AnnouncementRead was found.
-func (_q *AnnouncementReadQuery) First(ctx context.Context) (*AnnouncementRead, error) {
-	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{announcementread.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) FirstX(ctx context.Context) *AnnouncementRead {
-	node, err := _q.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first AnnouncementRead ID from the query.
-// Returns a *NotFoundError when no AnnouncementRead ID was found.
-func (_q *AnnouncementReadQuery) FirstID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{announcementread.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) FirstIDX(ctx context.Context) int64 {
-	id, err := _q.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single AnnouncementRead entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one AnnouncementRead entity is found.
-// Returns a *NotFoundError when no AnnouncementRead entities are found.
-func (_q *AnnouncementReadQuery) Only(ctx context.Context) (*AnnouncementRead, error) {
-	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{announcementread.Label}
-	default:
-		return nil, &NotSingularError{announcementread.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) OnlyX(ctx context.Context) *AnnouncementRead {
-	node, err := _q.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only AnnouncementRead ID in the query.
-// Returns a *NotSingularError when more than one AnnouncementRead ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (_q *AnnouncementReadQuery) OnlyID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{announcementread.Label}
-	default:
-		err = &NotSingularError{announcementread.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) OnlyIDX(ctx context.Context) int64 {
-	id, err := _q.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of AnnouncementReads.
-func (_q *AnnouncementReadQuery) All(ctx context.Context) ([]*AnnouncementRead, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*AnnouncementRead, *AnnouncementReadQuery]()
-	return withInterceptors[[]*AnnouncementRead](ctx, _q, qr, _q.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) AllX(ctx context.Context) []*AnnouncementRead {
-	nodes, err := _q.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of AnnouncementRead IDs.
-func (_q *AnnouncementReadQuery) IDs(ctx context.Context) (ids []int64, err error) {
-	if _q.ctx.Unique == nil && _q.path != nil {
-		_q.Unique(true)
-	}
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
-	if err = _q.Select(announcementread.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) IDsX(ctx context.Context) []int64 {
-	ids, err := _q.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (_q *AnnouncementReadQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, _q, querierCount[*AnnouncementReadQuery](), _q.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) CountX(ctx context.Context) int {
-	count, err := _q.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (_q *AnnouncementReadQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
-	switch _, err := _q.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (_q *AnnouncementReadQuery) ExistX(ctx context.Context) bool {
-	exist, err := _q.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the AnnouncementReadQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (_q *AnnouncementReadQuery) Clone() *AnnouncementReadQuery {
-	if _q == nil {
-		return nil
-	}
-	return &AnnouncementReadQuery{
-		config:           _q.config,
-		ctx:              _q.ctx.Clone(),
-		order:            append([]announcementread.OrderOption{}, _q.order...),
-		inters:           append([]Interceptor{}, _q.inters...),
-		predicates:       append([]predicate.AnnouncementRead{}, _q.predicates...),
-		withAnnouncement: _q.withAnnouncement.Clone(),
-		withUser:         _q.withUser.Clone(),
-		// clone intermediate query.
-		sql:  _q.sql.Clone(),
-		path: _q.path,
-	}
-}
-
-// WithAnnouncement tells the query-builder to eager-load the nodes that are connected to
-// the "announcement" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *AnnouncementReadQuery) WithAnnouncement(opts ...func(*AnnouncementQuery)) *AnnouncementReadQuery {
-	query := (&AnnouncementClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withAnnouncement = query
-	return _q
-}
-
-// WithUser tells the query-builder to eager-load the nodes that are connected to
-// the "user" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *AnnouncementReadQuery) WithUser(opts ...func(*UserQuery)) *AnnouncementReadQuery {
-	query := (&UserClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withUser = query
-	return _q
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		AnnouncementID int64 `json:"announcement_id,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.AnnouncementRead.Query().
-//		GroupBy(announcementread.FieldAnnouncementID).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (_q *AnnouncementReadQuery) GroupBy(field string, fields ...string) *AnnouncementReadGroupBy {
-	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &AnnouncementReadGroupBy{build: _q}
-	grbuild.flds = &_q.ctx.Fields
-	grbuild.label = announcementread.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		AnnouncementID int64 `json:"announcement_id,omitempty"`
-//	}
-//
-//	client.AnnouncementRead.Query().
-//		Select(announcementread.FieldAnnouncementID).
-//		Scan(ctx, &v)
-func (_q *AnnouncementReadQuery) Select(fields ...string) *AnnouncementReadSelect {
-	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &AnnouncementReadSelect{AnnouncementReadQuery: _q}
-	sbuild.label = announcementread.Label
-	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a AnnouncementReadSelect configured with the given aggregations.
-func (_q *AnnouncementReadQuery) Aggregate(fns ...AggregateFunc) *AnnouncementReadSelect {
-	return _q.Select().Aggregate(fns...)
-}
-
-func (_q *AnnouncementReadQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range _q.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, _q); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range _q.ctx.Fields {
-		if !announcementread.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if _q.path != nil {
-		prev, err := _q.path(ctx)
-		if err != nil {
-			return err
-		}
-		_q.sql = prev
-	}
-	return nil
-}
-
-func (_q *AnnouncementReadQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AnnouncementRead, error) {
-	var (
-		nodes       = []*AnnouncementRead{}
-		_spec       = _q.querySpec()
-		loadedTypes = [2]bool{
-			_q.withAnnouncement != nil,
-			_q.withUser != nil,
-		}
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*AnnouncementRead).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &AnnouncementRead{config: _q.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := _q.withAnnouncement; query != nil {
-		if err := _q.loadAnnouncement(ctx, query, nodes, nil,
-			func(n *AnnouncementRead, e *Announcement) { n.Edges.Announcement = e }); err != nil {
-			return nil, err
-		}
-	}
-	if query := _q.withUser; query != nil {
-		if err := _q.loadUser(ctx, query, nodes, nil,
-			func(n *AnnouncementRead, e *User) { n.Edges.User = e }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (_q *AnnouncementReadQuery) loadAnnouncement(ctx context.Context, query *AnnouncementQuery, nodes []*AnnouncementRead, init func(*AnnouncementRead), assign func(*AnnouncementRead, *Announcement)) error {
-	ids := make([]int64, 0, len(nodes))
-	nodeids := make(map[int64][]*AnnouncementRead)
-	for i := range nodes {
-		fk := nodes[i].AnnouncementID
-		if _, ok := nodeids[fk]; !ok {
-			ids = append(ids, fk)
-		}
-		nodeids[fk] = append(nodeids[fk], nodes[i])
-	}
-	if len(ids) == 0 {
-		return nil
-	}
-	query.Where(announcement.IDIn(ids...))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nodeids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected foreign-key "announcement_id" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
-func (_q *AnnouncementReadQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*AnnouncementRead, init func(*AnnouncementRead), assign func(*AnnouncementRead, *User)) error {
-	ids := make([]int64, 0, len(nodes))
-	nodeids := make(map[int64][]*AnnouncementRead)
-	for i := range nodes {
-		fk := nodes[i].UserID
-		if _, ok := nodeids[fk]; !ok {
-			ids = append(ids, fk)
-		}
-		nodeids[fk] = append(nodeids[fk], nodes[i])
-	}
-	if len(ids) == 0 {
-		return nil
-	}
-	query.Where(user.IDIn(ids...))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nodeids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
-
-func (_q *AnnouncementReadQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	_spec.Node.Columns = _q.ctx.Fields
-	if len(_q.ctx.Fields) > 0 {
-		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
-}
-
-func (_q *AnnouncementReadQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(announcementread.Table, announcementread.Columns, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64))
-	_spec.From = _q.sql
-	if unique := _q.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if _q.path != nil {
-		_spec.Unique = true
-	}
-	if fields := _q.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, announcementread.FieldID)
-		for i := range fields {
-			if fields[i] != announcementread.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-		if _q.withAnnouncement != nil {
-			_spec.Node.AddColumnOnce(announcementread.FieldAnnouncementID)
-		}
-		if _q.withUser != nil {
-			_spec.Node.AddColumnOnce(announcementread.FieldUserID)
-		}
-	}
-	if ps := _q.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := _q.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (_q *AnnouncementReadQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(_q.driver.Dialect())
-	t1 := builder.Table(announcementread.Table)
-	columns := _q.ctx.Fields
-	if len(columns) == 0 {
-		columns = announcementread.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if _q.sql != nil {
-		selector = _q.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if _q.ctx.Unique != nil && *_q.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
-	for _, p := range _q.predicates {
-		p(selector)
-	}
-	for _, p := range _q.order {
-		p(selector)
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *AnnouncementReadQuery) ForUpdate(opts ...sql.LockOption) *AnnouncementReadQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *AnnouncementReadQuery) ForShare(opts ...sql.LockOption) *AnnouncementReadQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// AnnouncementReadGroupBy is the group-by builder for AnnouncementRead entities.
-type AnnouncementReadGroupBy struct {
-	selector
-	build *AnnouncementReadQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (_g *AnnouncementReadGroupBy) Aggregate(fns ...AggregateFunc) *AnnouncementReadGroupBy {
-	_g.fns = append(_g.fns, fns...)
-	return _g
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_g *AnnouncementReadGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
-	if err := _g.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*AnnouncementReadQuery, *AnnouncementReadGroupBy](ctx, _g.build, _g, _g.build.inters, v)
-}
-
-func (_g *AnnouncementReadGroupBy) sqlScan(ctx context.Context, root *AnnouncementReadQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(_g.fns))
-	for _, fn := range _g.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
-		for _, f := range *_g.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*_g.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// AnnouncementReadSelect is the builder for selecting fields of AnnouncementRead entities.
-type AnnouncementReadSelect struct {
-	*AnnouncementReadQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (_s *AnnouncementReadSelect) Aggregate(fns ...AggregateFunc) *AnnouncementReadSelect {
-	_s.fns = append(_s.fns, fns...)
-	return _s
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_s *AnnouncementReadSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
-	if err := _s.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*AnnouncementReadQuery, *AnnouncementReadSelect](ctx, _s.AnnouncementReadQuery, _s, _s.inters, v)
-}
-
-func (_s *AnnouncementReadSelect) sqlScan(ctx context.Context, root *AnnouncementReadQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(_s.fns))
-	for _, fn := range _s.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*_s.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}

backend/ent/announcementread_update.go

@@ -1,456 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// AnnouncementReadUpdate is the builder for updating AnnouncementRead entities.
-type AnnouncementReadUpdate struct {
-	config
-	hooks    []Hook
-	mutation *AnnouncementReadMutation
-}
-
-// Where appends a list predicates to the AnnouncementReadUpdate builder.
-func (_u *AnnouncementReadUpdate) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadUpdate {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// SetAnnouncementID sets the "announcement_id" field.
-func (_u *AnnouncementReadUpdate) SetAnnouncementID(v int64) *AnnouncementReadUpdate {
-	_u.mutation.SetAnnouncementID(v)
-	return _u
-}
-
-// SetNillableAnnouncementID sets the "announcement_id" field if the given value is not nil.
-func (_u *AnnouncementReadUpdate) SetNillableAnnouncementID(v *int64) *AnnouncementReadUpdate {
-	if v != nil {
-		_u.SetAnnouncementID(*v)
-	}
-	return _u
-}
-
-// SetUserID sets the "user_id" field.
-func (_u *AnnouncementReadUpdate) SetUserID(v int64) *AnnouncementReadUpdate {
-	_u.mutation.SetUserID(v)
-	return _u
-}
-
-// SetNillableUserID sets the "user_id" field if the given value is not nil.
-func (_u *AnnouncementReadUpdate) SetNillableUserID(v *int64) *AnnouncementReadUpdate {
-	if v != nil {
-		_u.SetUserID(*v)
-	}
-	return _u
-}
-
-// SetReadAt sets the "read_at" field.
-func (_u *AnnouncementReadUpdate) SetReadAt(v time.Time) *AnnouncementReadUpdate {
-	_u.mutation.SetReadAt(v)
-	return _u
-}
-
-// SetNillableReadAt sets the "read_at" field if the given value is not nil.
-func (_u *AnnouncementReadUpdate) SetNillableReadAt(v *time.Time) *AnnouncementReadUpdate {
-	if v != nil {
-		_u.SetReadAt(*v)
-	}
-	return _u
-}
-
-// SetAnnouncement sets the "announcement" edge to the Announcement entity.
-func (_u *AnnouncementReadUpdate) SetAnnouncement(v *Announcement) *AnnouncementReadUpdate {
-	return _u.SetAnnouncementID(v.ID)
-}
-
-// SetUser sets the "user" edge to the User entity.
-func (_u *AnnouncementReadUpdate) SetUser(v *User) *AnnouncementReadUpdate {
-	return _u.SetUserID(v.ID)
-}
-
-// Mutation returns the AnnouncementReadMutation object of the builder.
-func (_u *AnnouncementReadUpdate) Mutation() *AnnouncementReadMutation {
-	return _u.mutation
-}
-
-// ClearAnnouncement clears the "announcement" edge to the Announcement entity.
-func (_u *AnnouncementReadUpdate) ClearAnnouncement() *AnnouncementReadUpdate {
-	_u.mutation.ClearAnnouncement()
-	return _u
-}
-
-// ClearUser clears the "user" edge to the User entity.
-func (_u *AnnouncementReadUpdate) ClearUser() *AnnouncementReadUpdate {
-	_u.mutation.ClearUser()
-	return _u
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *AnnouncementReadUpdate) Save(ctx context.Context) (int, error) {
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *AnnouncementReadUpdate) SaveX(ctx context.Context) int {
-	affected, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (_u *AnnouncementReadUpdate) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *AnnouncementReadUpdate) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *AnnouncementReadUpdate) check() error {
-	if _u.mutation.AnnouncementCleared() && len(_u.mutation.AnnouncementIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "AnnouncementRead.announcement"`)
-	}
-	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "AnnouncementRead.user"`)
-	}
-	return nil
-}
-
-func (_u *AnnouncementReadUpdate) sqlSave(ctx context.Context) (_node int, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(announcementread.Table, announcementread.Columns, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64))
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.ReadAt(); ok {
-		_spec.SetField(announcementread.FieldReadAt, field.TypeTime, value)
-	}
-	if _u.mutation.AnnouncementCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.AnnouncementTable,
-			Columns: []string{announcementread.AnnouncementColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.AnnouncementIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.AnnouncementTable,
-			Columns: []string{announcementread.AnnouncementColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _u.mutation.UserCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.UserTable,
-			Columns: []string{announcementread.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.UserTable,
-			Columns: []string{announcementread.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{announcementread.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}
-
-// AnnouncementReadUpdateOne is the builder for updating a single AnnouncementRead entity.
-type AnnouncementReadUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *AnnouncementReadMutation
-}
-
-// SetAnnouncementID sets the "announcement_id" field.
-func (_u *AnnouncementReadUpdateOne) SetAnnouncementID(v int64) *AnnouncementReadUpdateOne {
-	_u.mutation.SetAnnouncementID(v)
-	return _u
-}
-
-// SetNillableAnnouncementID sets the "announcement_id" field if the given value is not nil.
-func (_u *AnnouncementReadUpdateOne) SetNillableAnnouncementID(v *int64) *AnnouncementReadUpdateOne {
-	if v != nil {
-		_u.SetAnnouncementID(*v)
-	}
-	return _u
-}
-
-// SetUserID sets the "user_id" field.
-func (_u *AnnouncementReadUpdateOne) SetUserID(v int64) *AnnouncementReadUpdateOne {
-	_u.mutation.SetUserID(v)
-	return _u
-}
-
-// SetNillableUserID sets the "user_id" field if the given value is not nil.
-func (_u *AnnouncementReadUpdateOne) SetNillableUserID(v *int64) *AnnouncementReadUpdateOne {
-	if v != nil {
-		_u.SetUserID(*v)
-	}
-	return _u
-}
-
-// SetReadAt sets the "read_at" field.
-func (_u *AnnouncementReadUpdateOne) SetReadAt(v time.Time) *AnnouncementReadUpdateOne {
-	_u.mutation.SetReadAt(v)
-	return _u
-}
-
-// SetNillableReadAt sets the "read_at" field if the given value is not nil.
-func (_u *AnnouncementReadUpdateOne) SetNillableReadAt(v *time.Time) *AnnouncementReadUpdateOne {
-	if v != nil {
-		_u.SetReadAt(*v)
-	}
-	return _u
-}
-
-// SetAnnouncement sets the "announcement" edge to the Announcement entity.
-func (_u *AnnouncementReadUpdateOne) SetAnnouncement(v *Announcement) *AnnouncementReadUpdateOne {
-	return _u.SetAnnouncementID(v.ID)
-}
-
-// SetUser sets the "user" edge to the User entity.
-func (_u *AnnouncementReadUpdateOne) SetUser(v *User) *AnnouncementReadUpdateOne {
-	return _u.SetUserID(v.ID)
-}
-
-// Mutation returns the AnnouncementReadMutation object of the builder.
-func (_u *AnnouncementReadUpdateOne) Mutation() *AnnouncementReadMutation {
-	return _u.mutation
-}
-
-// ClearAnnouncement clears the "announcement" edge to the Announcement entity.
-func (_u *AnnouncementReadUpdateOne) ClearAnnouncement() *AnnouncementReadUpdateOne {
-	_u.mutation.ClearAnnouncement()
-	return _u
-}
-
-// ClearUser clears the "user" edge to the User entity.
-func (_u *AnnouncementReadUpdateOne) ClearUser() *AnnouncementReadUpdateOne {
-	_u.mutation.ClearUser()
-	return _u
-}
-
-// Where appends a list predicates to the AnnouncementReadUpdate builder.
-func (_u *AnnouncementReadUpdateOne) Where(ps ...predicate.AnnouncementRead) *AnnouncementReadUpdateOne {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (_u *AnnouncementReadUpdateOne) Select(field string, fields ...string) *AnnouncementReadUpdateOne {
-	_u.fields = append([]string{field}, fields...)
-	return _u
-}
-
-// Save executes the query and returns the updated AnnouncementRead entity.
-func (_u *AnnouncementReadUpdateOne) Save(ctx context.Context) (*AnnouncementRead, error) {
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *AnnouncementReadUpdateOne) SaveX(ctx context.Context) *AnnouncementRead {
-	node, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (_u *AnnouncementReadUpdateOne) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *AnnouncementReadUpdateOne) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *AnnouncementReadUpdateOne) check() error {
-	if _u.mutation.AnnouncementCleared() && len(_u.mutation.AnnouncementIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "AnnouncementRead.announcement"`)
-	}
-	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "AnnouncementRead.user"`)
-	}
-	return nil
-}
-
-func (_u *AnnouncementReadUpdateOne) sqlSave(ctx context.Context) (_node *AnnouncementRead, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(announcementread.Table, announcementread.Columns, sqlgraph.NewFieldSpec(announcementread.FieldID, field.TypeInt64))
-	id, ok := _u.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "AnnouncementRead.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := _u.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, announcementread.FieldID)
-		for _, f := range fields {
-			if !announcementread.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != announcementread.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.ReadAt(); ok {
-		_spec.SetField(announcementread.FieldReadAt, field.TypeTime, value)
-	}
-	if _u.mutation.AnnouncementCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.AnnouncementTable,
-			Columns: []string{announcementread.AnnouncementColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.AnnouncementIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.AnnouncementTable,
-			Columns: []string{announcementread.AnnouncementColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(announcement.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _u.mutation.UserCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.UserTable,
-			Columns: []string{announcementread.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   announcementread.UserTable,
-			Columns: []string{announcementread.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	_node = &AnnouncementRead{config: _u.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{announcementread.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}

backend/ent/apikey.go

@@ -3,7 +3,6 @@
 package ent
 
 import (
-	"encoding/json"
 	"fmt"
 	"strings"
 	"time"
@@ -15,8 +14,8 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/user"
 )
 
-// APIKey is the model entity for the APIKey schema.
-type APIKey struct {
+// ApiKey is the model entity for the ApiKey schema.
+type ApiKey struct {
 	config `json:"-"`
 	// ID of the ent.
 	ID int64 `json:"id,omitempty"`
@@ -36,44 +35,14 @@ type APIKey struct {
 	GroupID *int64 `json:"group_id,omitempty"`
 	// Status holds the value of the "status" field.
 	Status string `json:"status,omitempty"`
-	// Last usage time of this API key
-	LastUsedAt *time.Time `json:"last_used_at,omitempty"`
-	// Allowed IPs/CIDRs, e.g. ["192.168.1.100", "10.0.0.0/8"]
-	IPWhitelist []string `json:"ip_whitelist,omitempty"`
-	// Blocked IPs/CIDRs
-	IPBlacklist []string `json:"ip_blacklist,omitempty"`
-	// Quota limit in USD for this API key (0 = unlimited)
-	Quota float64 `json:"quota,omitempty"`
-	// Used quota amount in USD
-	QuotaUsed float64 `json:"quota_used,omitempty"`
-	// Expiration time for this API key (null = never expires)
-	ExpiresAt *time.Time `json:"expires_at,omitempty"`
-	// Rate limit in USD per 5 hours (0 = unlimited)
-	RateLimit5h float64 `json:"rate_limit_5h,omitempty"`
-	// Rate limit in USD per day (0 = unlimited)
-	RateLimit1d float64 `json:"rate_limit_1d,omitempty"`
-	// Rate limit in USD per 7 days (0 = unlimited)
-	RateLimit7d float64 `json:"rate_limit_7d,omitempty"`
-	// Used amount in USD for the current 5h window
-	Usage5h float64 `json:"usage_5h,omitempty"`
-	// Used amount in USD for the current 1d window
-	Usage1d float64 `json:"usage_1d,omitempty"`
-	// Used amount in USD for the current 7d window
-	Usage7d float64 `json:"usage_7d,omitempty"`
-	// Start time of the current 5h rate limit window
-	Window5hStart *time.Time `json:"window_5h_start,omitempty"`
-	// Start time of the current 1d rate limit window
-	Window1dStart *time.Time `json:"window_1d_start,omitempty"`
-	// Start time of the current 7d rate limit window
-	Window7dStart *time.Time `json:"window_7d_start,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the APIKeyQuery when eager-loading is set.
-	Edges        APIKeyEdges `json:"edges"`
+	// The values are being populated by the ApiKeyQuery when eager-loading is set.
+	Edges        ApiKeyEdges `json:"edges"`
 	selectValues sql.SelectValues
 }
 
-// APIKeyEdges holds the relations/edges for other nodes in the graph.
-type APIKeyEdges struct {
+// ApiKeyEdges holds the relations/edges for other nodes in the graph.
+type ApiKeyEdges struct {
 	// User holds the value of the user edge.
 	User *User `json:"user,omitempty"`
 	// Group holds the value of the group edge.
@@ -87,7 +56,7 @@ type APIKeyEdges struct {
 
 // UserOrErr returns the User value or an error if the edge
 // was not loaded in eager-loading, or loaded but was not found.
-func (e APIKeyEdges) UserOrErr() (*User, error) {
+func (e ApiKeyEdges) UserOrErr() (*User, error) {
 	if e.User != nil {
 		return e.User, nil
 	} else if e.loadedTypes[0] {
@@ -98,7 +67,7 @@ func (e APIKeyEdges) UserOrErr() (*User, error) {
 
 // GroupOrErr returns the Group value or an error if the edge
 // was not loaded in eager-loading, or loaded but was not found.
-func (e APIKeyEdges) GroupOrErr() (*Group, error) {
+func (e ApiKeyEdges) GroupOrErr() (*Group, error) {
 	if e.Group != nil {
 		return e.Group, nil
 	} else if e.loadedTypes[1] {
@@ -109,7 +78,7 @@ func (e APIKeyEdges) GroupOrErr() (*Group, error) {
 
 // UsageLogsOrErr returns the UsageLogs value or an error if the edge
 // was not loaded in eager-loading.
-func (e APIKeyEdges) UsageLogsOrErr() ([]*UsageLog, error) {
+func (e ApiKeyEdges) UsageLogsOrErr() ([]*UsageLog, error) {
 	if e.loadedTypes[2] {
 		return e.UsageLogs, nil
 	}
@@ -117,19 +86,15 @@ func (e APIKeyEdges) UsageLogsOrErr() ([]*UsageLog, error) {
 }
 
 // scanValues returns the types for scanning values from sql.Rows.
-func (*APIKey) scanValues(columns []string) ([]any, error) {
+func (*ApiKey) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case apikey.FieldIPWhitelist, apikey.FieldIPBlacklist:
-			values[i] = new([]byte)
-		case apikey.FieldQuota, apikey.FieldQuotaUsed, apikey.FieldRateLimit5h, apikey.FieldRateLimit1d, apikey.FieldRateLimit7d, apikey.FieldUsage5h, apikey.FieldUsage1d, apikey.FieldUsage7d:
-			values[i] = new(sql.NullFloat64)
 		case apikey.FieldID, apikey.FieldUserID, apikey.FieldGroupID:
 			values[i] = new(sql.NullInt64)
 		case apikey.FieldKey, apikey.FieldName, apikey.FieldStatus:
 			values[i] = new(sql.NullString)
-		case apikey.FieldCreatedAt, apikey.FieldUpdatedAt, apikey.FieldDeletedAt, apikey.FieldLastUsedAt, apikey.FieldExpiresAt, apikey.FieldWindow5hStart, apikey.FieldWindow1dStart, apikey.FieldWindow7dStart:
+		case apikey.FieldCreatedAt, apikey.FieldUpdatedAt, apikey.FieldDeletedAt:
 			values[i] = new(sql.NullTime)
 		default:
 			values[i] = new(sql.UnknownType)
@@ -139,8 +104,8 @@ func (*APIKey) scanValues(columns []string) ([]any, error) {
 }
 
 // assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the APIKey fields.
-func (_m *APIKey) assignValues(columns []string, values []any) error {
+// to the ApiKey fields.
+func (_m *ApiKey) assignValues(columns []string, values []any) error {
 	if m, n := len(values), len(columns); m < n {
 		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
 	}
@@ -202,105 +167,6 @@ func (_m *APIKey) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.Status = value.String
 			}
-		case apikey.FieldLastUsedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field last_used_at", values[i])
-			} else if value.Valid {
-				_m.LastUsedAt = new(time.Time)
-				*_m.LastUsedAt = value.Time
-			}
-		case apikey.FieldIPWhitelist:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field ip_whitelist", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.IPWhitelist); err != nil {
-					return fmt.Errorf("unmarshal field ip_whitelist: %w", err)
-				}
-			}
-		case apikey.FieldIPBlacklist:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field ip_blacklist", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.IPBlacklist); err != nil {
-					return fmt.Errorf("unmarshal field ip_blacklist: %w", err)
-				}
-			}
-		case apikey.FieldQuota:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field quota", values[i])
-			} else if value.Valid {
-				_m.Quota = value.Float64
-			}
-		case apikey.FieldQuotaUsed:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field quota_used", values[i])
-			} else if value.Valid {
-				_m.QuotaUsed = value.Float64
-			}
-		case apikey.FieldExpiresAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
-			} else if value.Valid {
-				_m.ExpiresAt = new(time.Time)
-				*_m.ExpiresAt = value.Time
-			}
-		case apikey.FieldRateLimit5h:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field rate_limit_5h", values[i])
-			} else if value.Valid {
-				_m.RateLimit5h = value.Float64
-			}
-		case apikey.FieldRateLimit1d:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field rate_limit_1d", values[i])
-			} else if value.Valid {
-				_m.RateLimit1d = value.Float64
-			}
-		case apikey.FieldRateLimit7d:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field rate_limit_7d", values[i])
-			} else if value.Valid {
-				_m.RateLimit7d = value.Float64
-			}
-		case apikey.FieldUsage5h:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field usage_5h", values[i])
-			} else if value.Valid {
-				_m.Usage5h = value.Float64
-			}
-		case apikey.FieldUsage1d:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field usage_1d", values[i])
-			} else if value.Valid {
-				_m.Usage1d = value.Float64
-			}
-		case apikey.FieldUsage7d:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field usage_7d", values[i])
-			} else if value.Valid {
-				_m.Usage7d = value.Float64
-			}
-		case apikey.FieldWindow5hStart:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field window_5h_start", values[i])
-			} else if value.Valid {
-				_m.Window5hStart = new(time.Time)
-				*_m.Window5hStart = value.Time
-			}
-		case apikey.FieldWindow1dStart:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field window_1d_start", values[i])
-			} else if value.Valid {
-				_m.Window1dStart = new(time.Time)
-				*_m.Window1dStart = value.Time
-			}
-		case apikey.FieldWindow7dStart:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field window_7d_start", values[i])
-			} else if value.Valid {
-				_m.Window7dStart = new(time.Time)
-				*_m.Window7dStart = value.Time
-			}
 		default:
 			_m.selectValues.Set(columns[i], values[i])
 		}
@@ -308,49 +174,49 @@ func (_m *APIKey) assignValues(columns []string, values []any) error {
 	return nil
 }
 
-// Value returns the ent.Value that was dynamically selected and assigned to the APIKey.
+// Value returns the ent.Value that was dynamically selected and assigned to the ApiKey.
 // This includes values selected through modifiers, order, etc.
-func (_m *APIKey) Value(name string) (ent.Value, error) {
+func (_m *ApiKey) Value(name string) (ent.Value, error) {
 	return _m.selectValues.Get(name)
 }
 
-// QueryUser queries the "user" edge of the APIKey entity.
-func (_m *APIKey) QueryUser() *UserQuery {
-	return NewAPIKeyClient(_m.config).QueryUser(_m)
+// QueryUser queries the "user" edge of the ApiKey entity.
+func (_m *ApiKey) QueryUser() *UserQuery {
+	return NewApiKeyClient(_m.config).QueryUser(_m)
 }
 
-// QueryGroup queries the "group" edge of the APIKey entity.
-func (_m *APIKey) QueryGroup() *GroupQuery {
-	return NewAPIKeyClient(_m.config).QueryGroup(_m)
+// QueryGroup queries the "group" edge of the ApiKey entity.
+func (_m *ApiKey) QueryGroup() *GroupQuery {
+	return NewApiKeyClient(_m.config).QueryGroup(_m)
 }
 
-// QueryUsageLogs queries the "usage_logs" edge of the APIKey entity.
-func (_m *APIKey) QueryUsageLogs() *UsageLogQuery {
-	return NewAPIKeyClient(_m.config).QueryUsageLogs(_m)
+// QueryUsageLogs queries the "usage_logs" edge of the ApiKey entity.
+func (_m *ApiKey) QueryUsageLogs() *UsageLogQuery {
+	return NewApiKeyClient(_m.config).QueryUsageLogs(_m)
 }
 
-// Update returns a builder for updating this APIKey.
-// Note that you need to call APIKey.Unwrap() before calling this method if this APIKey
+// Update returns a builder for updating this ApiKey.
+// Note that you need to call ApiKey.Unwrap() before calling this method if this ApiKey
 // was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *APIKey) Update() *APIKeyUpdateOne {
-	return NewAPIKeyClient(_m.config).UpdateOne(_m)
+func (_m *ApiKey) Update() *ApiKeyUpdateOne {
+	return NewApiKeyClient(_m.config).UpdateOne(_m)
 }
 
-// Unwrap unwraps the APIKey entity that was returned from a transaction after it was closed,
+// Unwrap unwraps the ApiKey entity that was returned from a transaction after it was closed,
 // so that all future queries will be executed through the driver which created the transaction.
-func (_m *APIKey) Unwrap() *APIKey {
+func (_m *ApiKey) Unwrap() *ApiKey {
 	_tx, ok := _m.config.driver.(*txDriver)
 	if !ok {
-		panic("ent: APIKey is not a transactional entity")
+		panic("ent: ApiKey is not a transactional entity")
 	}
 	_m.config.driver = _tx.drv
 	return _m
 }
 
 // String implements the fmt.Stringer.
-func (_m *APIKey) String() string {
+func (_m *ApiKey) String() string {
 	var builder strings.Builder
-	builder.WriteString("APIKey(")
+	builder.WriteString("ApiKey(")
 	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
 	builder.WriteString("created_at=")
 	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
@@ -379,64 +245,9 @@ func (_m *APIKey) String() string {
 	builder.WriteString(", ")
 	builder.WriteString("status=")
 	builder.WriteString(_m.Status)
-	builder.WriteString(", ")
-	if v := _m.LastUsedAt; v != nil {
-		builder.WriteString("last_used_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("ip_whitelist=")
-	builder.WriteString(fmt.Sprintf("%v", _m.IPWhitelist))
-	builder.WriteString(", ")
-	builder.WriteString("ip_blacklist=")
-	builder.WriteString(fmt.Sprintf("%v", _m.IPBlacklist))
-	builder.WriteString(", ")
-	builder.WriteString("quota=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Quota))
-	builder.WriteString(", ")
-	builder.WriteString("quota_used=")
-	builder.WriteString(fmt.Sprintf("%v", _m.QuotaUsed))
-	builder.WriteString(", ")
-	if v := _m.ExpiresAt; v != nil {
-		builder.WriteString("expires_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("rate_limit_5h=")
-	builder.WriteString(fmt.Sprintf("%v", _m.RateLimit5h))
-	builder.WriteString(", ")
-	builder.WriteString("rate_limit_1d=")
-	builder.WriteString(fmt.Sprintf("%v", _m.RateLimit1d))
-	builder.WriteString(", ")
-	builder.WriteString("rate_limit_7d=")
-	builder.WriteString(fmt.Sprintf("%v", _m.RateLimit7d))
-	builder.WriteString(", ")
-	builder.WriteString("usage_5h=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Usage5h))
-	builder.WriteString(", ")
-	builder.WriteString("usage_1d=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Usage1d))
-	builder.WriteString(", ")
-	builder.WriteString("usage_7d=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Usage7d))
-	builder.WriteString(", ")
-	if v := _m.Window5hStart; v != nil {
-		builder.WriteString("window_5h_start=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.Window1dStart; v != nil {
-		builder.WriteString("window_1d_start=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.Window7dStart; v != nil {
-		builder.WriteString("window_7d_start=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
 	builder.WriteByte(')')
 	return builder.String()
 }
 
-// APIKeys is a parsable slice of APIKey.
-type APIKeys []*APIKey
+// ApiKeys is a parsable slice of ApiKey.
+type ApiKeys []*ApiKey

backend/ent/apikey/apikey.go

@@ -31,36 +31,6 @@ const (
 	FieldGroupID = "group_id"
 	// FieldStatus holds the string denoting the status field in the database.
 	FieldStatus = "status"
-	// FieldLastUsedAt holds the string denoting the last_used_at field in the database.
-	FieldLastUsedAt = "last_used_at"
-	// FieldIPWhitelist holds the string denoting the ip_whitelist field in the database.
-	FieldIPWhitelist = "ip_whitelist"
-	// FieldIPBlacklist holds the string denoting the ip_blacklist field in the database.
-	FieldIPBlacklist = "ip_blacklist"
-	// FieldQuota holds the string denoting the quota field in the database.
-	FieldQuota = "quota"
-	// FieldQuotaUsed holds the string denoting the quota_used field in the database.
-	FieldQuotaUsed = "quota_used"
-	// FieldExpiresAt holds the string denoting the expires_at field in the database.
-	FieldExpiresAt = "expires_at"
-	// FieldRateLimit5h holds the string denoting the rate_limit_5h field in the database.
-	FieldRateLimit5h = "rate_limit_5h"
-	// FieldRateLimit1d holds the string denoting the rate_limit_1d field in the database.
-	FieldRateLimit1d = "rate_limit_1d"
-	// FieldRateLimit7d holds the string denoting the rate_limit_7d field in the database.
-	FieldRateLimit7d = "rate_limit_7d"
-	// FieldUsage5h holds the string denoting the usage_5h field in the database.
-	FieldUsage5h = "usage_5h"
-	// FieldUsage1d holds the string denoting the usage_1d field in the database.
-	FieldUsage1d = "usage_1d"
-	// FieldUsage7d holds the string denoting the usage_7d field in the database.
-	FieldUsage7d = "usage_7d"
-	// FieldWindow5hStart holds the string denoting the window_5h_start field in the database.
-	FieldWindow5hStart = "window_5h_start"
-	// FieldWindow1dStart holds the string denoting the window_1d_start field in the database.
-	FieldWindow1dStart = "window_1d_start"
-	// FieldWindow7dStart holds the string denoting the window_7d_start field in the database.
-	FieldWindow7dStart = "window_7d_start"
 	// EdgeUser holds the string denoting the user edge name in mutations.
 	EdgeUser = "user"
 	// EdgeGroup holds the string denoting the group edge name in mutations.
@@ -103,21 +73,6 @@ var Columns = []string{
 	FieldName,
 	FieldGroupID,
 	FieldStatus,
-	FieldLastUsedAt,
-	FieldIPWhitelist,
-	FieldIPBlacklist,
-	FieldQuota,
-	FieldQuotaUsed,
-	FieldExpiresAt,
-	FieldRateLimit5h,
-	FieldRateLimit1d,
-	FieldRateLimit7d,
-	FieldUsage5h,
-	FieldUsage1d,
-	FieldUsage7d,
-	FieldWindow5hStart,
-	FieldWindow1dStart,
-	FieldWindow7dStart,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).
@@ -152,25 +107,9 @@ var (
 	DefaultStatus string
 	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
 	StatusValidator func(string) error
-	// DefaultQuota holds the default value on creation for the "quota" field.
-	DefaultQuota float64
-	// DefaultQuotaUsed holds the default value on creation for the "quota_used" field.
-	DefaultQuotaUsed float64
-	// DefaultRateLimit5h holds the default value on creation for the "rate_limit_5h" field.
-	DefaultRateLimit5h float64
-	// DefaultRateLimit1d holds the default value on creation for the "rate_limit_1d" field.
-	DefaultRateLimit1d float64
-	// DefaultRateLimit7d holds the default value on creation for the "rate_limit_7d" field.
-	DefaultRateLimit7d float64
-	// DefaultUsage5h holds the default value on creation for the "usage_5h" field.
-	DefaultUsage5h float64
-	// DefaultUsage1d holds the default value on creation for the "usage_1d" field.
-	DefaultUsage1d float64
-	// DefaultUsage7d holds the default value on creation for the "usage_7d" field.
-	DefaultUsage7d float64
 )
 
-// OrderOption defines the ordering options for the APIKey queries.
+// OrderOption defines the ordering options for the ApiKey queries.
 type OrderOption func(*sql.Selector)
 
 // ByID orders the results by the id field.
@@ -218,71 +157,6 @@ func ByStatus(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldStatus, opts...).ToFunc()
 }
 
-// ByLastUsedAt orders the results by the last_used_at field.
-func ByLastUsedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldLastUsedAt, opts...).ToFunc()
-}
-
-// ByQuota orders the results by the quota field.
-func ByQuota(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldQuota, opts...).ToFunc()
-}
-
-// ByQuotaUsed orders the results by the quota_used field.
-func ByQuotaUsed(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldQuotaUsed, opts...).ToFunc()
-}
-
-// ByExpiresAt orders the results by the expires_at field.
-func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
-}
-
-// ByRateLimit5h orders the results by the rate_limit_5h field.
-func ByRateLimit5h(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldRateLimit5h, opts...).ToFunc()
-}
-
-// ByRateLimit1d orders the results by the rate_limit_1d field.
-func ByRateLimit1d(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldRateLimit1d, opts...).ToFunc()
-}
-
-// ByRateLimit7d orders the results by the rate_limit_7d field.
-func ByRateLimit7d(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldRateLimit7d, opts...).ToFunc()
-}
-
-// ByUsage5h orders the results by the usage_5h field.
-func ByUsage5h(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUsage5h, opts...).ToFunc()
-}
-
-// ByUsage1d orders the results by the usage_1d field.
-func ByUsage1d(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUsage1d, opts...).ToFunc()
-}
-
-// ByUsage7d orders the results by the usage_7d field.
-func ByUsage7d(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUsage7d, opts...).ToFunc()
-}
-
-// ByWindow5hStart orders the results by the window_5h_start field.
-func ByWindow5hStart(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldWindow5hStart, opts...).ToFunc()
-}
-
-// ByWindow1dStart orders the results by the window_1d_start field.
-func ByWindow1dStart(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldWindow1dStart, opts...).ToFunc()
-}
-
-// ByWindow7dStart orders the results by the window_7d_start field.
-func ByWindow7dStart(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldWindow7dStart, opts...).ToFunc()
-}
-
 // ByUserField orders the results by user field.
 func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {

backend/ent/apikey_delete.go

@@ -12,26 +12,26 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/predicate"
 )
 
-// APIKeyDelete is the builder for deleting a APIKey entity.
-type APIKeyDelete struct {
+// ApiKeyDelete is the builder for deleting a ApiKey entity.
+type ApiKeyDelete struct {
 	config
 	hooks    []Hook
-	mutation *APIKeyMutation
+	mutation *ApiKeyMutation
 }
 
-// Where appends a list predicates to the APIKeyDelete builder.
-func (_d *APIKeyDelete) Where(ps ...predicate.APIKey) *APIKeyDelete {
+// Where appends a list predicates to the ApiKeyDelete builder.
+func (_d *ApiKeyDelete) Where(ps ...predicate.ApiKey) *ApiKeyDelete {
 	_d.mutation.Where(ps...)
 	return _d
 }
 
 // Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *APIKeyDelete) Exec(ctx context.Context) (int, error) {
+func (_d *ApiKeyDelete) Exec(ctx context.Context) (int, error) {
 	return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (_d *APIKeyDelete) ExecX(ctx context.Context) int {
+func (_d *ApiKeyDelete) ExecX(ctx context.Context) int {
 	n, err := _d.Exec(ctx)
 	if err != nil {
 		panic(err)
@@ -39,7 +39,7 @@ func (_d *APIKeyDelete) ExecX(ctx context.Context) int {
 	return n
 }
 
-func (_d *APIKeyDelete) sqlExec(ctx context.Context) (int, error) {
+func (_d *ApiKeyDelete) sqlExec(ctx context.Context) (int, error) {
 	_spec := sqlgraph.NewDeleteSpec(apikey.Table, sqlgraph.NewFieldSpec(apikey.FieldID, field.TypeInt64))
 	if ps := _d.mutation.predicates; len(ps) > 0 {
 		_spec.Predicate = func(selector *sql.Selector) {
@@ -56,19 +56,19 @@ func (_d *APIKeyDelete) sqlExec(ctx context.Context) (int, error) {
 	return affected, err
 }
 
-// APIKeyDeleteOne is the builder for deleting a single APIKey entity.
-type APIKeyDeleteOne struct {
-	_d *APIKeyDelete
+// ApiKeyDeleteOne is the builder for deleting a single ApiKey entity.
+type ApiKeyDeleteOne struct {
+	_d *ApiKeyDelete
 }
 
-// Where appends a list predicates to the APIKeyDelete builder.
-func (_d *APIKeyDeleteOne) Where(ps ...predicate.APIKey) *APIKeyDeleteOne {
+// Where appends a list predicates to the ApiKeyDelete builder.
+func (_d *ApiKeyDeleteOne) Where(ps ...predicate.ApiKey) *ApiKeyDeleteOne {
 	_d._d.mutation.Where(ps...)
 	return _d
 }
 
 // Exec executes the deletion query.
-func (_d *APIKeyDeleteOne) Exec(ctx context.Context) error {
+func (_d *ApiKeyDeleteOne) Exec(ctx context.Context) error {
 	n, err := _d._d.Exec(ctx)
 	switch {
 	case err != nil:
@@ -81,7 +81,7 @@ func (_d *APIKeyDeleteOne) Exec(ctx context.Context) error {
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (_d *APIKeyDeleteOne) ExecX(ctx context.Context) {
+func (_d *ApiKeyDeleteOne) ExecX(ctx context.Context) {
 	if err := _d.Exec(ctx); err != nil {
 		panic(err)
 	}

backend/ent/apikey_query.go

@@ -9,7 +9,6 @@ import (
 	"math"
 
 	"entgo.io/ent"
-	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -20,55 +19,54 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/user"
 )
 
-// APIKeyQuery is the builder for querying APIKey entities.
-type APIKeyQuery struct {
+// ApiKeyQuery is the builder for querying ApiKey entities.
+type ApiKeyQuery struct {
 	config
 	ctx           *QueryContext
 	order         []apikey.OrderOption
 	inters        []Interceptor
-	predicates    []predicate.APIKey
+	predicates    []predicate.ApiKey
 	withUser      *UserQuery
 	withGroup     *GroupQuery
 	withUsageLogs *UsageLogQuery
-	modifiers     []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
 }
 
-// Where adds a new predicate for the APIKeyQuery builder.
-func (_q *APIKeyQuery) Where(ps ...predicate.APIKey) *APIKeyQuery {
+// Where adds a new predicate for the ApiKeyQuery builder.
+func (_q *ApiKeyQuery) Where(ps ...predicate.ApiKey) *ApiKeyQuery {
 	_q.predicates = append(_q.predicates, ps...)
 	return _q
 }
 
 // Limit the number of records to be returned by this query.
-func (_q *APIKeyQuery) Limit(limit int) *APIKeyQuery {
+func (_q *ApiKeyQuery) Limit(limit int) *ApiKeyQuery {
 	_q.ctx.Limit = &limit
 	return _q
 }
 
 // Offset to start from.
-func (_q *APIKeyQuery) Offset(offset int) *APIKeyQuery {
+func (_q *ApiKeyQuery) Offset(offset int) *ApiKeyQuery {
 	_q.ctx.Offset = &offset
 	return _q
 }
 
 // Unique configures the query builder to filter duplicate records on query.
 // By default, unique is set to true, and can be disabled using this method.
-func (_q *APIKeyQuery) Unique(unique bool) *APIKeyQuery {
+func (_q *ApiKeyQuery) Unique(unique bool) *ApiKeyQuery {
 	_q.ctx.Unique = &unique
 	return _q
 }
 
 // Order specifies how the records should be ordered.
-func (_q *APIKeyQuery) Order(o ...apikey.OrderOption) *APIKeyQuery {
+func (_q *ApiKeyQuery) Order(o ...apikey.OrderOption) *ApiKeyQuery {
 	_q.order = append(_q.order, o...)
 	return _q
 }
 
 // QueryUser chains the current query on the "user" edge.
-func (_q *APIKeyQuery) QueryUser() *UserQuery {
+func (_q *ApiKeyQuery) QueryUser() *UserQuery {
 	query := (&UserClient{config: _q.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := _q.prepareQuery(ctx); err != nil {
@@ -90,7 +88,7 @@ func (_q *APIKeyQuery) QueryUser() *UserQuery {
 }
 
 // QueryGroup chains the current query on the "group" edge.
-func (_q *APIKeyQuery) QueryGroup() *GroupQuery {
+func (_q *ApiKeyQuery) QueryGroup() *GroupQuery {
 	query := (&GroupClient{config: _q.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := _q.prepareQuery(ctx); err != nil {
@@ -112,7 +110,7 @@ func (_q *APIKeyQuery) QueryGroup() *GroupQuery {
 }
 
 // QueryUsageLogs chains the current query on the "usage_logs" edge.
-func (_q *APIKeyQuery) QueryUsageLogs() *UsageLogQuery {
+func (_q *ApiKeyQuery) QueryUsageLogs() *UsageLogQuery {
 	query := (&UsageLogClient{config: _q.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := _q.prepareQuery(ctx); err != nil {
@@ -133,9 +131,9 @@ func (_q *APIKeyQuery) QueryUsageLogs() *UsageLogQuery {
 	return query
 }
 
-// First returns the first APIKey entity from the query.
-// Returns a *NotFoundError when no APIKey was found.
-func (_q *APIKeyQuery) First(ctx context.Context) (*APIKey, error) {
+// First returns the first ApiKey entity from the query.
+// Returns a *NotFoundError when no ApiKey was found.
+func (_q *ApiKeyQuery) First(ctx context.Context) (*ApiKey, error) {
 	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
 	if err != nil {
 		return nil, err
@@ -147,7 +145,7 @@ func (_q *APIKeyQuery) First(ctx context.Context) (*APIKey, error) {
 }
 
 // FirstX is like First, but panics if an error occurs.
-func (_q *APIKeyQuery) FirstX(ctx context.Context) *APIKey {
+func (_q *ApiKeyQuery) FirstX(ctx context.Context) *ApiKey {
 	node, err := _q.First(ctx)
 	if err != nil && !IsNotFound(err) {
 		panic(err)
@@ -155,9 +153,9 @@ func (_q *APIKeyQuery) FirstX(ctx context.Context) *APIKey {
 	return node
 }
 
-// FirstID returns the first APIKey ID from the query.
-// Returns a *NotFoundError when no APIKey ID was found.
-func (_q *APIKeyQuery) FirstID(ctx context.Context) (id int64, err error) {
+// FirstID returns the first ApiKey ID from the query.
+// Returns a *NotFoundError when no ApiKey ID was found.
+func (_q *ApiKeyQuery) FirstID(ctx context.Context) (id int64, err error) {
 	var ids []int64
 	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
 		return
@@ -170,7 +168,7 @@ func (_q *APIKeyQuery) FirstID(ctx context.Context) (id int64, err error) {
 }
 
 // FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *APIKeyQuery) FirstIDX(ctx context.Context) int64 {
+func (_q *ApiKeyQuery) FirstIDX(ctx context.Context) int64 {
 	id, err := _q.FirstID(ctx)
 	if err != nil && !IsNotFound(err) {
 		panic(err)
@@ -178,10 +176,10 @@ func (_q *APIKeyQuery) FirstIDX(ctx context.Context) int64 {
 	return id
 }
 
-// Only returns a single APIKey entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one APIKey entity is found.
-// Returns a *NotFoundError when no APIKey entities are found.
-func (_q *APIKeyQuery) Only(ctx context.Context) (*APIKey, error) {
+// Only returns a single ApiKey entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ApiKey entity is found.
+// Returns a *NotFoundError when no ApiKey entities are found.
+func (_q *ApiKeyQuery) Only(ctx context.Context) (*ApiKey, error) {
 	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
 	if err != nil {
 		return nil, err
@@ -197,7 +195,7 @@ func (_q *APIKeyQuery) Only(ctx context.Context) (*APIKey, error) {
 }
 
 // OnlyX is like Only, but panics if an error occurs.
-func (_q *APIKeyQuery) OnlyX(ctx context.Context) *APIKey {
+func (_q *ApiKeyQuery) OnlyX(ctx context.Context) *ApiKey {
 	node, err := _q.Only(ctx)
 	if err != nil {
 		panic(err)
@@ -205,10 +203,10 @@ func (_q *APIKeyQuery) OnlyX(ctx context.Context) *APIKey {
 	return node
 }
 
-// OnlyID is like Only, but returns the only APIKey ID in the query.
-// Returns a *NotSingularError when more than one APIKey ID is found.
+// OnlyID is like Only, but returns the only ApiKey ID in the query.
+// Returns a *NotSingularError when more than one ApiKey ID is found.
 // Returns a *NotFoundError when no entities are found.
-func (_q *APIKeyQuery) OnlyID(ctx context.Context) (id int64, err error) {
+func (_q *ApiKeyQuery) OnlyID(ctx context.Context) (id int64, err error) {
 	var ids []int64
 	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
 		return
@@ -225,7 +223,7 @@ func (_q *APIKeyQuery) OnlyID(ctx context.Context) (id int64, err error) {
 }
 
 // OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *APIKeyQuery) OnlyIDX(ctx context.Context) int64 {
+func (_q *ApiKeyQuery) OnlyIDX(ctx context.Context) int64 {
 	id, err := _q.OnlyID(ctx)
 	if err != nil {
 		panic(err)
@@ -233,18 +231,18 @@ func (_q *APIKeyQuery) OnlyIDX(ctx context.Context) int64 {
 	return id
 }
 
-// All executes the query and returns a list of APIKeys.
-func (_q *APIKeyQuery) All(ctx context.Context) ([]*APIKey, error) {
+// All executes the query and returns a list of ApiKeys.
+func (_q *ApiKeyQuery) All(ctx context.Context) ([]*ApiKey, error) {
 	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
 	if err := _q.prepareQuery(ctx); err != nil {
 		return nil, err
 	}
-	qr := querierAll[[]*APIKey, *APIKeyQuery]()
-	return withInterceptors[[]*APIKey](ctx, _q, qr, _q.inters)
+	qr := querierAll[[]*ApiKey, *ApiKeyQuery]()
+	return withInterceptors[[]*ApiKey](ctx, _q, qr, _q.inters)
 }
 
 // AllX is like All, but panics if an error occurs.
-func (_q *APIKeyQuery) AllX(ctx context.Context) []*APIKey {
+func (_q *ApiKeyQuery) AllX(ctx context.Context) []*ApiKey {
 	nodes, err := _q.All(ctx)
 	if err != nil {
 		panic(err)
@@ -252,8 +250,8 @@ func (_q *APIKeyQuery) AllX(ctx context.Context) []*APIKey {
 	return nodes
 }
 
-// IDs executes the query and returns a list of APIKey IDs.
-func (_q *APIKeyQuery) IDs(ctx context.Context) (ids []int64, err error) {
+// IDs executes the query and returns a list of ApiKey IDs.
+func (_q *ApiKeyQuery) IDs(ctx context.Context) (ids []int64, err error) {
 	if _q.ctx.Unique == nil && _q.path != nil {
 		_q.Unique(true)
 	}
@@ -265,7 +263,7 @@ func (_q *APIKeyQuery) IDs(ctx context.Context) (ids []int64, err error) {
 }
 
 // IDsX is like IDs, but panics if an error occurs.
-func (_q *APIKeyQuery) IDsX(ctx context.Context) []int64 {
+func (_q *ApiKeyQuery) IDsX(ctx context.Context) []int64 {
 	ids, err := _q.IDs(ctx)
 	if err != nil {
 		panic(err)
@@ -274,16 +272,16 @@ func (_q *APIKeyQuery) IDsX(ctx context.Context) []int64 {
 }
 
 // Count returns the count of the given query.
-func (_q *APIKeyQuery) Count(ctx context.Context) (int, error) {
+func (_q *ApiKeyQuery) Count(ctx context.Context) (int, error) {
 	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
 	if err := _q.prepareQuery(ctx); err != nil {
 		return 0, err
 	}
-	return withInterceptors[int](ctx, _q, querierCount[*APIKeyQuery](), _q.inters)
+	return withInterceptors[int](ctx, _q, querierCount[*ApiKeyQuery](), _q.inters)
 }
 
 // CountX is like Count, but panics if an error occurs.
-func (_q *APIKeyQuery) CountX(ctx context.Context) int {
+func (_q *ApiKeyQuery) CountX(ctx context.Context) int {
 	count, err := _q.Count(ctx)
 	if err != nil {
 		panic(err)
@@ -292,7 +290,7 @@ func (_q *APIKeyQuery) CountX(ctx context.Context) int {
 }
 
 // Exist returns true if the query has elements in the graph.
-func (_q *APIKeyQuery) Exist(ctx context.Context) (bool, error) {
+func (_q *ApiKeyQuery) Exist(ctx context.Context) (bool, error) {
 	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
 	switch _, err := _q.FirstID(ctx); {
 	case IsNotFound(err):
@@ -305,7 +303,7 @@ func (_q *APIKeyQuery) Exist(ctx context.Context) (bool, error) {
 }
 
 // ExistX is like Exist, but panics if an error occurs.
-func (_q *APIKeyQuery) ExistX(ctx context.Context) bool {
+func (_q *ApiKeyQuery) ExistX(ctx context.Context) bool {
 	exist, err := _q.Exist(ctx)
 	if err != nil {
 		panic(err)
@@ -313,18 +311,18 @@ func (_q *APIKeyQuery) ExistX(ctx context.Context) bool {
 	return exist
 }
 
-// Clone returns a duplicate of the APIKeyQuery builder, including all associated steps. It can be
+// Clone returns a duplicate of the ApiKeyQuery builder, including all associated steps. It can be
 // used to prepare common query builders and use them differently after the clone is made.
-func (_q *APIKeyQuery) Clone() *APIKeyQuery {
+func (_q *ApiKeyQuery) Clone() *ApiKeyQuery {
 	if _q == nil {
 		return nil
 	}
-	return &APIKeyQuery{
+	return &ApiKeyQuery{
 		config:        _q.config,
 		ctx:           _q.ctx.Clone(),
 		order:         append([]apikey.OrderOption{}, _q.order...),
 		inters:        append([]Interceptor{}, _q.inters...),
-		predicates:    append([]predicate.APIKey{}, _q.predicates...),
+		predicates:    append([]predicate.ApiKey{}, _q.predicates...),
 		withUser:      _q.withUser.Clone(),
 		withGroup:     _q.withGroup.Clone(),
 		withUsageLogs: _q.withUsageLogs.Clone(),
@@ -336,7 +334,7 @@ func (_q *APIKeyQuery) Clone() *APIKeyQuery {
 
 // WithUser tells the query-builder to eager-load the nodes that are connected to
 // the "user" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *APIKeyQuery) WithUser(opts ...func(*UserQuery)) *APIKeyQuery {
+func (_q *ApiKeyQuery) WithUser(opts ...func(*UserQuery)) *ApiKeyQuery {
 	query := (&UserClient{config: _q.config}).Query()
 	for _, opt := range opts {
 		opt(query)
@@ -347,7 +345,7 @@ func (_q *APIKeyQuery) WithUser(opts ...func(*UserQuery)) *APIKeyQuery {
 
 // WithGroup tells the query-builder to eager-load the nodes that are connected to
 // the "group" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *APIKeyQuery) WithGroup(opts ...func(*GroupQuery)) *APIKeyQuery {
+func (_q *ApiKeyQuery) WithGroup(opts ...func(*GroupQuery)) *ApiKeyQuery {
 	query := (&GroupClient{config: _q.config}).Query()
 	for _, opt := range opts {
 		opt(query)
@@ -358,7 +356,7 @@ func (_q *APIKeyQuery) WithGroup(opts ...func(*GroupQuery)) *APIKeyQuery {
 
 // WithUsageLogs tells the query-builder to eager-load the nodes that are connected to
 // the "usage_logs" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *APIKeyQuery) WithUsageLogs(opts ...func(*UsageLogQuery)) *APIKeyQuery {
+func (_q *ApiKeyQuery) WithUsageLogs(opts ...func(*UsageLogQuery)) *ApiKeyQuery {
 	query := (&UsageLogClient{config: _q.config}).Query()
 	for _, opt := range opts {
 		opt(query)
@@ -377,13 +375,13 @@ func (_q *APIKeyQuery) WithUsageLogs(opts ...func(*UsageLogQuery)) *APIKeyQuery
 //		Count int `json:"count,omitempty"`
 //	}
 //
-//	client.APIKey.Query().
+//	client.ApiKey.Query().
 //		GroupBy(apikey.FieldCreatedAt).
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
-func (_q *APIKeyQuery) GroupBy(field string, fields ...string) *APIKeyGroupBy {
+func (_q *ApiKeyQuery) GroupBy(field string, fields ...string) *ApiKeyGroupBy {
 	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &APIKeyGroupBy{build: _q}
+	grbuild := &ApiKeyGroupBy{build: _q}
 	grbuild.flds = &_q.ctx.Fields
 	grbuild.label = apikey.Label
 	grbuild.scan = grbuild.Scan
@@ -399,23 +397,23 @@ func (_q *APIKeyQuery) GroupBy(field string, fields ...string) *APIKeyGroupBy {
 //		CreatedAt time.Time `json:"created_at,omitempty"`
 //	}
 //
-//	client.APIKey.Query().
+//	client.ApiKey.Query().
 //		Select(apikey.FieldCreatedAt).
 //		Scan(ctx, &v)
-func (_q *APIKeyQuery) Select(fields ...string) *APIKeySelect {
+func (_q *ApiKeyQuery) Select(fields ...string) *ApiKeySelect {
 	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &APIKeySelect{APIKeyQuery: _q}
+	sbuild := &ApiKeySelect{ApiKeyQuery: _q}
 	sbuild.label = apikey.Label
 	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
 	return sbuild
 }
 
-// Aggregate returns a APIKeySelect configured with the given aggregations.
-func (_q *APIKeyQuery) Aggregate(fns ...AggregateFunc) *APIKeySelect {
+// Aggregate returns a ApiKeySelect configured with the given aggregations.
+func (_q *ApiKeyQuery) Aggregate(fns ...AggregateFunc) *ApiKeySelect {
 	return _q.Select().Aggregate(fns...)
 }
 
-func (_q *APIKeyQuery) prepareQuery(ctx context.Context) error {
+func (_q *ApiKeyQuery) prepareQuery(ctx context.Context) error {
 	for _, inter := range _q.inters {
 		if inter == nil {
 			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
@@ -441,9 +439,9 @@ func (_q *APIKeyQuery) prepareQuery(ctx context.Context) error {
 	return nil
 }
 
-func (_q *APIKeyQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*APIKey, error) {
+func (_q *ApiKeyQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ApiKey, error) {
 	var (
-		nodes       = []*APIKey{}
+		nodes       = []*ApiKey{}
 		_spec       = _q.querySpec()
 		loadedTypes = [3]bool{
 			_q.withUser != nil,
@@ -452,17 +450,14 @@ func (_q *APIKeyQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*APIKe
 		}
 	)
 	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*APIKey).scanValues(nil, columns)
+		return (*ApiKey).scanValues(nil, columns)
 	}
 	_spec.Assign = func(columns []string, values []any) error {
-		node := &APIKey{config: _q.config}
+		node := &ApiKey{config: _q.config}
 		nodes = append(nodes, node)
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -474,29 +469,29 @@ func (_q *APIKeyQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*APIKe
 	}
 	if query := _q.withUser; query != nil {
 		if err := _q.loadUser(ctx, query, nodes, nil,
-			func(n *APIKey, e *User) { n.Edges.User = e }); err != nil {
+			func(n *ApiKey, e *User) { n.Edges.User = e }); err != nil {
 			return nil, err
 		}
 	}
 	if query := _q.withGroup; query != nil {
 		if err := _q.loadGroup(ctx, query, nodes, nil,
-			func(n *APIKey, e *Group) { n.Edges.Group = e }); err != nil {
+			func(n *ApiKey, e *Group) { n.Edges.Group = e }); err != nil {
 			return nil, err
 		}
 	}
 	if query := _q.withUsageLogs; query != nil {
 		if err := _q.loadUsageLogs(ctx, query, nodes,
-			func(n *APIKey) { n.Edges.UsageLogs = []*UsageLog{} },
-			func(n *APIKey, e *UsageLog) { n.Edges.UsageLogs = append(n.Edges.UsageLogs, e) }); err != nil {
+			func(n *ApiKey) { n.Edges.UsageLogs = []*UsageLog{} },
+			func(n *ApiKey, e *UsageLog) { n.Edges.UsageLogs = append(n.Edges.UsageLogs, e) }); err != nil {
 			return nil, err
 		}
 	}
 	return nodes, nil
 }
 
-func (_q *APIKeyQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*APIKey, init func(*APIKey), assign func(*APIKey, *User)) error {
+func (_q *ApiKeyQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*ApiKey, init func(*ApiKey), assign func(*ApiKey, *User)) error {
 	ids := make([]int64, 0, len(nodes))
-	nodeids := make(map[int64][]*APIKey)
+	nodeids := make(map[int64][]*ApiKey)
 	for i := range nodes {
 		fk := nodes[i].UserID
 		if _, ok := nodeids[fk]; !ok {
@@ -523,9 +518,9 @@ func (_q *APIKeyQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*
 	}
 	return nil
 }
-func (_q *APIKeyQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*APIKey, init func(*APIKey), assign func(*APIKey, *Group)) error {
+func (_q *ApiKeyQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*ApiKey, init func(*ApiKey), assign func(*ApiKey, *Group)) error {
 	ids := make([]int64, 0, len(nodes))
-	nodeids := make(map[int64][]*APIKey)
+	nodeids := make(map[int64][]*ApiKey)
 	for i := range nodes {
 		if nodes[i].GroupID == nil {
 			continue
@@ -555,9 +550,9 @@ func (_q *APIKeyQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes [
 	}
 	return nil
 }
-func (_q *APIKeyQuery) loadUsageLogs(ctx context.Context, query *UsageLogQuery, nodes []*APIKey, init func(*APIKey), assign func(*APIKey, *UsageLog)) error {
+func (_q *ApiKeyQuery) loadUsageLogs(ctx context.Context, query *UsageLogQuery, nodes []*ApiKey, init func(*ApiKey), assign func(*ApiKey, *UsageLog)) error {
 	fks := make([]driver.Value, 0, len(nodes))
-	nodeids := make(map[int64]*APIKey)
+	nodeids := make(map[int64]*ApiKey)
 	for i := range nodes {
 		fks = append(fks, nodes[i].ID)
 		nodeids[nodes[i].ID] = nodes[i]
@@ -586,11 +581,8 @@ func (_q *APIKeyQuery) loadUsageLogs(ctx context.Context, query *UsageLogQuery,
 	return nil
 }
 
-func (_q *APIKeyQuery) sqlCount(ctx context.Context) (int, error) {
+func (_q *ApiKeyQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	_spec.Node.Columns = _q.ctx.Fields
 	if len(_q.ctx.Fields) > 0 {
 		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
@@ -598,7 +590,7 @@ func (_q *APIKeyQuery) sqlCount(ctx context.Context) (int, error) {
 	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
 }
 
-func (_q *APIKeyQuery) querySpec() *sqlgraph.QuerySpec {
+func (_q *ApiKeyQuery) querySpec() *sqlgraph.QuerySpec {
 	_spec := sqlgraph.NewQuerySpec(apikey.Table, apikey.Columns, sqlgraph.NewFieldSpec(apikey.FieldID, field.TypeInt64))
 	_spec.From = _q.sql
 	if unique := _q.ctx.Unique; unique != nil {
@@ -644,7 +636,7 @@ func (_q *APIKeyQuery) querySpec() *sqlgraph.QuerySpec {
 	return _spec
 }
 
-func (_q *APIKeyQuery) sqlQuery(ctx context.Context) *sql.Selector {
+func (_q *ApiKeyQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	builder := sql.Dialect(_q.driver.Dialect())
 	t1 := builder.Table(apikey.Table)
 	columns := _q.ctx.Fields
@@ -659,9 +651,6 @@ func (_q *APIKeyQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if _q.ctx.Unique != nil && *_q.ctx.Unique {
 		selector.Distinct()
 	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
 	for _, p := range _q.predicates {
 		p(selector)
 	}
@@ -679,54 +668,28 @@ func (_q *APIKeyQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *APIKeyQuery) ForUpdate(opts ...sql.LockOption) *APIKeyQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *APIKeyQuery) ForShare(opts ...sql.LockOption) *APIKeyQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// APIKeyGroupBy is the group-by builder for APIKey entities.
-type APIKeyGroupBy struct {
+// ApiKeyGroupBy is the group-by builder for ApiKey entities.
+type ApiKeyGroupBy struct {
 	selector
-	build *APIKeyQuery
+	build *ApiKeyQuery
 }
 
 // Aggregate adds the given aggregation functions to the group-by query.
-func (_g *APIKeyGroupBy) Aggregate(fns ...AggregateFunc) *APIKeyGroupBy {
+func (_g *ApiKeyGroupBy) Aggregate(fns ...AggregateFunc) *ApiKeyGroupBy {
 	_g.fns = append(_g.fns, fns...)
 	return _g
 }
 
 // Scan applies the selector query and scans the result into the given value.
-func (_g *APIKeyGroupBy) Scan(ctx context.Context, v any) error {
+func (_g *ApiKeyGroupBy) Scan(ctx context.Context, v any) error {
 	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
 	if err := _g.build.prepareQuery(ctx); err != nil {
 		return err
 	}
-	return scanWithInterceptors[*APIKeyQuery, *APIKeyGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+	return scanWithInterceptors[*ApiKeyQuery, *ApiKeyGroupBy](ctx, _g.build, _g, _g.build.inters, v)
 }
 
-func (_g *APIKeyGroupBy) sqlScan(ctx context.Context, root *APIKeyQuery, v any) error {
+func (_g *ApiKeyGroupBy) sqlScan(ctx context.Context, root *ApiKeyQuery, v any) error {
 	selector := root.sqlQuery(ctx).Select()
 	aggregation := make([]string, 0, len(_g.fns))
 	for _, fn := range _g.fns {
@@ -753,28 +716,28 @@ func (_g *APIKeyGroupBy) sqlScan(ctx context.Context, root *APIKeyQuery, v any)
 	return sql.ScanSlice(rows, v)
 }
 
-// APIKeySelect is the builder for selecting fields of APIKey entities.
-type APIKeySelect struct {
-	*APIKeyQuery
+// ApiKeySelect is the builder for selecting fields of ApiKey entities.
+type ApiKeySelect struct {
+	*ApiKeyQuery
 	selector
 }
 
 // Aggregate adds the given aggregation functions to the selector query.
-func (_s *APIKeySelect) Aggregate(fns ...AggregateFunc) *APIKeySelect {
+func (_s *ApiKeySelect) Aggregate(fns ...AggregateFunc) *ApiKeySelect {
 	_s.fns = append(_s.fns, fns...)
 	return _s
 }
 
 // Scan applies the selector query and scans the result into the given value.
-func (_s *APIKeySelect) Scan(ctx context.Context, v any) error {
+func (_s *ApiKeySelect) Scan(ctx context.Context, v any) error {
 	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
 	if err := _s.prepareQuery(ctx); err != nil {
 		return err
 	}
-	return scanWithInterceptors[*APIKeyQuery, *APIKeySelect](ctx, _s.APIKeyQuery, _s, _s.inters, v)
+	return scanWithInterceptors[*ApiKeyQuery, *ApiKeySelect](ctx, _s.ApiKeyQuery, _s, _s.inters, v)
 }
 
-func (_s *APIKeySelect) sqlScan(ctx context.Context, root *APIKeyQuery, v any) error {
+func (_s *ApiKeySelect) sqlScan(ctx context.Context, root *ApiKeyQuery, v any) error {
 	selector := root.sqlQuery(ctx)
 	aggregation := make([]string, 0, len(_s.fns))
 	for _, fn := range _s.fns {

backend/ent/ent.go

@@ -14,24 +14,14 @@ import (
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"github.com/Wei-Shaw/sub2api/ent/account"
 	"github.com/Wei-Shaw/sub2api/ent/accountgroup"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
-	"github.com/Wei-Shaw/sub2api/ent/errorpassthroughrule"
 	"github.com/Wei-Shaw/sub2api/ent/group"
-	"github.com/Wei-Shaw/sub2api/ent/idempotencyrecord"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
 	"github.com/Wei-Shaw/sub2api/ent/proxy"
 	"github.com/Wei-Shaw/sub2api/ent/redeemcode"
-	"github.com/Wei-Shaw/sub2api/ent/securitysecret"
 	"github.com/Wei-Shaw/sub2api/ent/setting"
-	"github.com/Wei-Shaw/sub2api/ent/usagecleanuptask"
 	"github.com/Wei-Shaw/sub2api/ent/usagelog"
 	"github.com/Wei-Shaw/sub2api/ent/user"
 	"github.com/Wei-Shaw/sub2api/ent/userallowedgroup"
-	"github.com/Wei-Shaw/sub2api/ent/userattributedefinition"
-	"github.com/Wei-Shaw/sub2api/ent/userattributevalue"
 	"github.com/Wei-Shaw/sub2api/ent/usersubscription"
 )
 
@@ -93,27 +83,17 @@ var (
 func checkColumn(t, c string) error {
 	initCheck.Do(func() {
 		columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
-			apikey.Table:                  apikey.ValidColumn,
-			account.Table:                 account.ValidColumn,
-			accountgroup.Table:            accountgroup.ValidColumn,
-			announcement.Table:            announcement.ValidColumn,
-			announcementread.Table:        announcementread.ValidColumn,
-			errorpassthroughrule.Table:    errorpassthroughrule.ValidColumn,
-			group.Table:                   group.ValidColumn,
-			idempotencyrecord.Table:       idempotencyrecord.ValidColumn,
-			promocode.Table:               promocode.ValidColumn,
-			promocodeusage.Table:          promocodeusage.ValidColumn,
-			proxy.Table:                   proxy.ValidColumn,
-			redeemcode.Table:              redeemcode.ValidColumn,
-			securitysecret.Table:          securitysecret.ValidColumn,
-			setting.Table:                 setting.ValidColumn,
-			usagecleanuptask.Table:        usagecleanuptask.ValidColumn,
-			usagelog.Table:                usagelog.ValidColumn,
-			user.Table:                    user.ValidColumn,
-			userallowedgroup.Table:        userallowedgroup.ValidColumn,
-			userattributedefinition.Table: userattributedefinition.ValidColumn,
-			userattributevalue.Table:      userattributevalue.ValidColumn,
-			usersubscription.Table:        usersubscription.ValidColumn,
+			account.Table:          account.ValidColumn,
+			accountgroup.Table:     accountgroup.ValidColumn,
+			apikey.Table:           apikey.ValidColumn,
+			group.Table:            group.ValidColumn,
+			proxy.Table:            proxy.ValidColumn,
+			redeemcode.Table:       redeemcode.ValidColumn,
+			setting.Table:          setting.ValidColumn,
+			usagelog.Table:         usagelog.ValidColumn,
+			user.Table:             user.ValidColumn,
+			userallowedgroup.Table: userallowedgroup.ValidColumn,
+			usersubscription.Table: usersubscription.ValidColumn,
 		})
 	})
 	return columnCheck(t, c)

backend/ent/errorpassthroughrule.go

@@ -1,280 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/errorpassthroughrule"
-)
-
-// ErrorPassthroughRule is the model entity for the ErrorPassthroughRule schema.
-type ErrorPassthroughRule struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int64 `json:"id,omitempty"`
-	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt time.Time `json:"updated_at,omitempty"`
-	// Name holds the value of the "name" field.
-	Name string `json:"name,omitempty"`
-	// Enabled holds the value of the "enabled" field.
-	Enabled bool `json:"enabled,omitempty"`
-	// Priority holds the value of the "priority" field.
-	Priority int `json:"priority,omitempty"`
-	// ErrorCodes holds the value of the "error_codes" field.
-	ErrorCodes []int `json:"error_codes,omitempty"`
-	// Keywords holds the value of the "keywords" field.
-	Keywords []string `json:"keywords,omitempty"`
-	// MatchMode holds the value of the "match_mode" field.
-	MatchMode string `json:"match_mode,omitempty"`
-	// Platforms holds the value of the "platforms" field.
-	Platforms []string `json:"platforms,omitempty"`
-	// PassthroughCode holds the value of the "passthrough_code" field.
-	PassthroughCode bool `json:"passthrough_code,omitempty"`
-	// ResponseCode holds the value of the "response_code" field.
-	ResponseCode *int `json:"response_code,omitempty"`
-	// PassthroughBody holds the value of the "passthrough_body" field.
-	PassthroughBody bool `json:"passthrough_body,omitempty"`
-	// CustomMessage holds the value of the "custom_message" field.
-	CustomMessage *string `json:"custom_message,omitempty"`
-	// SkipMonitoring holds the value of the "skip_monitoring" field.
-	SkipMonitoring bool `json:"skip_monitoring,omitempty"`
-	// Description holds the value of the "description" field.
-	Description  *string `json:"description,omitempty"`
-	selectValues sql.SelectValues
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*ErrorPassthroughRule) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case errorpassthroughrule.FieldErrorCodes, errorpassthroughrule.FieldKeywords, errorpassthroughrule.FieldPlatforms:
-			values[i] = new([]byte)
-		case errorpassthroughrule.FieldEnabled, errorpassthroughrule.FieldPassthroughCode, errorpassthroughrule.FieldPassthroughBody, errorpassthroughrule.FieldSkipMonitoring:
-			values[i] = new(sql.NullBool)
-		case errorpassthroughrule.FieldID, errorpassthroughrule.FieldPriority, errorpassthroughrule.FieldResponseCode:
-			values[i] = new(sql.NullInt64)
-		case errorpassthroughrule.FieldName, errorpassthroughrule.FieldMatchMode, errorpassthroughrule.FieldCustomMessage, errorpassthroughrule.FieldDescription:
-			values[i] = new(sql.NullString)
-		case errorpassthroughrule.FieldCreatedAt, errorpassthroughrule.FieldUpdatedAt:
-			values[i] = new(sql.NullTime)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the ErrorPassthroughRule fields.
-func (_m *ErrorPassthroughRule) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case errorpassthroughrule.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			_m.ID = int64(value.Int64)
-		case errorpassthroughrule.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field created_at", values[i])
-			} else if value.Valid {
-				_m.CreatedAt = value.Time
-			}
-		case errorpassthroughrule.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
-			} else if value.Valid {
-				_m.UpdatedAt = value.Time
-			}
-		case errorpassthroughrule.FieldName:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field name", values[i])
-			} else if value.Valid {
-				_m.Name = value.String
-			}
-		case errorpassthroughrule.FieldEnabled:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field enabled", values[i])
-			} else if value.Valid {
-				_m.Enabled = value.Bool
-			}
-		case errorpassthroughrule.FieldPriority:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field priority", values[i])
-			} else if value.Valid {
-				_m.Priority = int(value.Int64)
-			}
-		case errorpassthroughrule.FieldErrorCodes:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field error_codes", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.ErrorCodes); err != nil {
-					return fmt.Errorf("unmarshal field error_codes: %w", err)
-				}
-			}
-		case errorpassthroughrule.FieldKeywords:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field keywords", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.Keywords); err != nil {
-					return fmt.Errorf("unmarshal field keywords: %w", err)
-				}
-			}
-		case errorpassthroughrule.FieldMatchMode:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field match_mode", values[i])
-			} else if value.Valid {
-				_m.MatchMode = value.String
-			}
-		case errorpassthroughrule.FieldPlatforms:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field platforms", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.Platforms); err != nil {
-					return fmt.Errorf("unmarshal field platforms: %w", err)
-				}
-			}
-		case errorpassthroughrule.FieldPassthroughCode:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field passthrough_code", values[i])
-			} else if value.Valid {
-				_m.PassthroughCode = value.Bool
-			}
-		case errorpassthroughrule.FieldResponseCode:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field response_code", values[i])
-			} else if value.Valid {
-				_m.ResponseCode = new(int)
-				*_m.ResponseCode = int(value.Int64)
-			}
-		case errorpassthroughrule.FieldPassthroughBody:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field passthrough_body", values[i])
-			} else if value.Valid {
-				_m.PassthroughBody = value.Bool
-			}
-		case errorpassthroughrule.FieldCustomMessage:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field custom_message", values[i])
-			} else if value.Valid {
-				_m.CustomMessage = new(string)
-				*_m.CustomMessage = value.String
-			}
-		case errorpassthroughrule.FieldSkipMonitoring:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field skip_monitoring", values[i])
-			} else if value.Valid {
-				_m.SkipMonitoring = value.Bool
-			}
-		case errorpassthroughrule.FieldDescription:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field description", values[i])
-			} else if value.Valid {
-				_m.Description = new(string)
-				*_m.Description = value.String
-			}
-		default:
-			_m.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the ErrorPassthroughRule.
-// This includes values selected through modifiers, order, etc.
-func (_m *ErrorPassthroughRule) Value(name string) (ent.Value, error) {
-	return _m.selectValues.Get(name)
-}
-
-// Update returns a builder for updating this ErrorPassthroughRule.
-// Note that you need to call ErrorPassthroughRule.Unwrap() before calling this method if this ErrorPassthroughRule
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *ErrorPassthroughRule) Update() *ErrorPassthroughRuleUpdateOne {
-	return NewErrorPassthroughRuleClient(_m.config).UpdateOne(_m)
-}
-
-// Unwrap unwraps the ErrorPassthroughRule entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (_m *ErrorPassthroughRule) Unwrap() *ErrorPassthroughRule {
-	_tx, ok := _m.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: ErrorPassthroughRule is not a transactional entity")
-	}
-	_m.config.driver = _tx.drv
-	return _m
-}
-
-// String implements the fmt.Stringer.
-func (_m *ErrorPassthroughRule) String() string {
-	var builder strings.Builder
-	builder.WriteString("ErrorPassthroughRule(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
-	builder.WriteString("created_at=")
-	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("updated_at=")
-	builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("name=")
-	builder.WriteString(_m.Name)
-	builder.WriteString(", ")
-	builder.WriteString("enabled=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Enabled))
-	builder.WriteString(", ")
-	builder.WriteString("priority=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Priority))
-	builder.WriteString(", ")
-	builder.WriteString("error_codes=")
-	builder.WriteString(fmt.Sprintf("%v", _m.ErrorCodes))
-	builder.WriteString(", ")
-	builder.WriteString("keywords=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Keywords))
-	builder.WriteString(", ")
-	builder.WriteString("match_mode=")
-	builder.WriteString(_m.MatchMode)
-	builder.WriteString(", ")
-	builder.WriteString("platforms=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Platforms))
-	builder.WriteString(", ")
-	builder.WriteString("passthrough_code=")
-	builder.WriteString(fmt.Sprintf("%v", _m.PassthroughCode))
-	builder.WriteString(", ")
-	if v := _m.ResponseCode; v != nil {
-		builder.WriteString("response_code=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("passthrough_body=")
-	builder.WriteString(fmt.Sprintf("%v", _m.PassthroughBody))
-	builder.WriteString(", ")
-	if v := _m.CustomMessage; v != nil {
-		builder.WriteString("custom_message=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
-	builder.WriteString("skip_monitoring=")
-	builder.WriteString(fmt.Sprintf("%v", _m.SkipMonitoring))
-	builder.WriteString(", ")
-	if v := _m.Description; v != nil {
-		builder.WriteString("description=")
-		builder.WriteString(*v)
-	}
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// ErrorPassthroughRules is a parsable slice of ErrorPassthroughRule.
-type ErrorPassthroughRules []*ErrorPassthroughRule

backend/ent/errorpassthroughrule/errorpassthroughrule.go

@@ -1,171 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package errorpassthroughrule
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-)
-
-const (
-	// Label holds the string label denoting the errorpassthroughrule type in the database.
-	Label = "error_passthrough_rule"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldCreatedAt holds the string denoting the created_at field in the database.
-	FieldCreatedAt = "created_at"
-	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
-	FieldUpdatedAt = "updated_at"
-	// FieldName holds the string denoting the name field in the database.
-	FieldName = "name"
-	// FieldEnabled holds the string denoting the enabled field in the database.
-	FieldEnabled = "enabled"
-	// FieldPriority holds the string denoting the priority field in the database.
-	FieldPriority = "priority"
-	// FieldErrorCodes holds the string denoting the error_codes field in the database.
-	FieldErrorCodes = "error_codes"
-	// FieldKeywords holds the string denoting the keywords field in the database.
-	FieldKeywords = "keywords"
-	// FieldMatchMode holds the string denoting the match_mode field in the database.
-	FieldMatchMode = "match_mode"
-	// FieldPlatforms holds the string denoting the platforms field in the database.
-	FieldPlatforms = "platforms"
-	// FieldPassthroughCode holds the string denoting the passthrough_code field in the database.
-	FieldPassthroughCode = "passthrough_code"
-	// FieldResponseCode holds the string denoting the response_code field in the database.
-	FieldResponseCode = "response_code"
-	// FieldPassthroughBody holds the string denoting the passthrough_body field in the database.
-	FieldPassthroughBody = "passthrough_body"
-	// FieldCustomMessage holds the string denoting the custom_message field in the database.
-	FieldCustomMessage = "custom_message"
-	// FieldSkipMonitoring holds the string denoting the skip_monitoring field in the database.
-	FieldSkipMonitoring = "skip_monitoring"
-	// FieldDescription holds the string denoting the description field in the database.
-	FieldDescription = "description"
-	// Table holds the table name of the errorpassthroughrule in the database.
-	Table = "error_passthrough_rules"
-)
-
-// Columns holds all SQL columns for errorpassthroughrule fields.
-var Columns = []string{
-	FieldID,
-	FieldCreatedAt,
-	FieldUpdatedAt,
-	FieldName,
-	FieldEnabled,
-	FieldPriority,
-	FieldErrorCodes,
-	FieldKeywords,
-	FieldMatchMode,
-	FieldPlatforms,
-	FieldPassthroughCode,
-	FieldResponseCode,
-	FieldPassthroughBody,
-	FieldCustomMessage,
-	FieldSkipMonitoring,
-	FieldDescription,
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() time.Time
-	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() time.Time
-	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() time.Time
-	// NameValidator is a validator for the "name" field. It is called by the builders before save.
-	NameValidator func(string) error
-	// DefaultEnabled holds the default value on creation for the "enabled" field.
-	DefaultEnabled bool
-	// DefaultPriority holds the default value on creation for the "priority" field.
-	DefaultPriority int
-	// DefaultMatchMode holds the default value on creation for the "match_mode" field.
-	DefaultMatchMode string
-	// MatchModeValidator is a validator for the "match_mode" field. It is called by the builders before save.
-	MatchModeValidator func(string) error
-	// DefaultPassthroughCode holds the default value on creation for the "passthrough_code" field.
-	DefaultPassthroughCode bool
-	// DefaultPassthroughBody holds the default value on creation for the "passthrough_body" field.
-	DefaultPassthroughBody bool
-	// DefaultSkipMonitoring holds the default value on creation for the "skip_monitoring" field.
-	DefaultSkipMonitoring bool
-)
-
-// OrderOption defines the ordering options for the ErrorPassthroughRule queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByCreatedAt orders the results by the created_at field.
-func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
-}
-
-// ByUpdatedAt orders the results by the updated_at field.
-func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
-}
-
-// ByName orders the results by the name field.
-func ByName(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldName, opts...).ToFunc()
-}
-
-// ByEnabled orders the results by the enabled field.
-func ByEnabled(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldEnabled, opts...).ToFunc()
-}
-
-// ByPriority orders the results by the priority field.
-func ByPriority(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldPriority, opts...).ToFunc()
-}
-
-// ByMatchMode orders the results by the match_mode field.
-func ByMatchMode(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldMatchMode, opts...).ToFunc()
-}
-
-// ByPassthroughCode orders the results by the passthrough_code field.
-func ByPassthroughCode(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldPassthroughCode, opts...).ToFunc()
-}
-
-// ByResponseCode orders the results by the response_code field.
-func ByResponseCode(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldResponseCode, opts...).ToFunc()
-}
-
-// ByPassthroughBody orders the results by the passthrough_body field.
-func ByPassthroughBody(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldPassthroughBody, opts...).ToFunc()
-}
-
-// ByCustomMessage orders the results by the custom_message field.
-func ByCustomMessage(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCustomMessage, opts...).ToFunc()
-}
-
-// BySkipMonitoring orders the results by the skip_monitoring field.
-func BySkipMonitoring(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSkipMonitoring, opts...).ToFunc()
-}
-
-// ByDescription orders the results by the description field.
-func ByDescription(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldDescription, opts...).ToFunc()
-}

backend/ent/errorpassthroughrule/where.go

@@ -1,650 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package errorpassthroughrule
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldID, id))
-}
-
-// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
-func Name(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldName, v))
-}
-
-// Enabled applies equality check predicate on the "enabled" field. It's identical to EnabledEQ.
-func Enabled(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldEnabled, v))
-}
-
-// Priority applies equality check predicate on the "priority" field. It's identical to PriorityEQ.
-func Priority(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldPriority, v))
-}
-
-// MatchMode applies equality check predicate on the "match_mode" field. It's identical to MatchModeEQ.
-func MatchMode(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldMatchMode, v))
-}
-
-// PassthroughCode applies equality check predicate on the "passthrough_code" field. It's identical to PassthroughCodeEQ.
-func PassthroughCode(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldPassthroughCode, v))
-}
-
-// ResponseCode applies equality check predicate on the "response_code" field. It's identical to ResponseCodeEQ.
-func ResponseCode(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldResponseCode, v))
-}
-
-// PassthroughBody applies equality check predicate on the "passthrough_body" field. It's identical to PassthroughBodyEQ.
-func PassthroughBody(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldPassthroughBody, v))
-}
-
-// CustomMessage applies equality check predicate on the "custom_message" field. It's identical to CustomMessageEQ.
-func CustomMessage(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldCustomMessage, v))
-}
-
-// SkipMonitoring applies equality check predicate on the "skip_monitoring" field. It's identical to SkipMonitoringEQ.
-func SkipMonitoring(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldSkipMonitoring, v))
-}
-
-// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
-func Description(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldDescription, v))
-}
-
-// CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldCreatedAt, v))
-}
-
-// CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldCreatedAt, v))
-}
-
-// CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldCreatedAt, v))
-}
-
-// CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldCreatedAt, v))
-}
-
-// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v time.Time) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldUpdatedAt, v))
-}
-
-// NameEQ applies the EQ predicate on the "name" field.
-func NameEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldName, v))
-}
-
-// NameNEQ applies the NEQ predicate on the "name" field.
-func NameNEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldName, v))
-}
-
-// NameIn applies the In predicate on the "name" field.
-func NameIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldName, vs...))
-}
-
-// NameNotIn applies the NotIn predicate on the "name" field.
-func NameNotIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldName, vs...))
-}
-
-// NameGT applies the GT predicate on the "name" field.
-func NameGT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldName, v))
-}
-
-// NameGTE applies the GTE predicate on the "name" field.
-func NameGTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldName, v))
-}
-
-// NameLT applies the LT predicate on the "name" field.
-func NameLT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldName, v))
-}
-
-// NameLTE applies the LTE predicate on the "name" field.
-func NameLTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldName, v))
-}
-
-// NameContains applies the Contains predicate on the "name" field.
-func NameContains(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContains(FieldName, v))
-}
-
-// NameHasPrefix applies the HasPrefix predicate on the "name" field.
-func NameHasPrefix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasPrefix(FieldName, v))
-}
-
-// NameHasSuffix applies the HasSuffix predicate on the "name" field.
-func NameHasSuffix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasSuffix(FieldName, v))
-}
-
-// NameEqualFold applies the EqualFold predicate on the "name" field.
-func NameEqualFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEqualFold(FieldName, v))
-}
-
-// NameContainsFold applies the ContainsFold predicate on the "name" field.
-func NameContainsFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContainsFold(FieldName, v))
-}
-
-// EnabledEQ applies the EQ predicate on the "enabled" field.
-func EnabledEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldEnabled, v))
-}
-
-// EnabledNEQ applies the NEQ predicate on the "enabled" field.
-func EnabledNEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldEnabled, v))
-}
-
-// PriorityEQ applies the EQ predicate on the "priority" field.
-func PriorityEQ(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldPriority, v))
-}
-
-// PriorityNEQ applies the NEQ predicate on the "priority" field.
-func PriorityNEQ(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldPriority, v))
-}
-
-// PriorityIn applies the In predicate on the "priority" field.
-func PriorityIn(vs ...int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldPriority, vs...))
-}
-
-// PriorityNotIn applies the NotIn predicate on the "priority" field.
-func PriorityNotIn(vs ...int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldPriority, vs...))
-}
-
-// PriorityGT applies the GT predicate on the "priority" field.
-func PriorityGT(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldPriority, v))
-}
-
-// PriorityGTE applies the GTE predicate on the "priority" field.
-func PriorityGTE(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldPriority, v))
-}
-
-// PriorityLT applies the LT predicate on the "priority" field.
-func PriorityLT(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldPriority, v))
-}
-
-// PriorityLTE applies the LTE predicate on the "priority" field.
-func PriorityLTE(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldPriority, v))
-}
-
-// ErrorCodesIsNil applies the IsNil predicate on the "error_codes" field.
-func ErrorCodesIsNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIsNull(FieldErrorCodes))
-}
-
-// ErrorCodesNotNil applies the NotNil predicate on the "error_codes" field.
-func ErrorCodesNotNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotNull(FieldErrorCodes))
-}
-
-// KeywordsIsNil applies the IsNil predicate on the "keywords" field.
-func KeywordsIsNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIsNull(FieldKeywords))
-}
-
-// KeywordsNotNil applies the NotNil predicate on the "keywords" field.
-func KeywordsNotNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotNull(FieldKeywords))
-}
-
-// MatchModeEQ applies the EQ predicate on the "match_mode" field.
-func MatchModeEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldMatchMode, v))
-}
-
-// MatchModeNEQ applies the NEQ predicate on the "match_mode" field.
-func MatchModeNEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldMatchMode, v))
-}
-
-// MatchModeIn applies the In predicate on the "match_mode" field.
-func MatchModeIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldMatchMode, vs...))
-}
-
-// MatchModeNotIn applies the NotIn predicate on the "match_mode" field.
-func MatchModeNotIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldMatchMode, vs...))
-}
-
-// MatchModeGT applies the GT predicate on the "match_mode" field.
-func MatchModeGT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldMatchMode, v))
-}
-
-// MatchModeGTE applies the GTE predicate on the "match_mode" field.
-func MatchModeGTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldMatchMode, v))
-}
-
-// MatchModeLT applies the LT predicate on the "match_mode" field.
-func MatchModeLT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldMatchMode, v))
-}
-
-// MatchModeLTE applies the LTE predicate on the "match_mode" field.
-func MatchModeLTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldMatchMode, v))
-}
-
-// MatchModeContains applies the Contains predicate on the "match_mode" field.
-func MatchModeContains(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContains(FieldMatchMode, v))
-}
-
-// MatchModeHasPrefix applies the HasPrefix predicate on the "match_mode" field.
-func MatchModeHasPrefix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasPrefix(FieldMatchMode, v))
-}
-
-// MatchModeHasSuffix applies the HasSuffix predicate on the "match_mode" field.
-func MatchModeHasSuffix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasSuffix(FieldMatchMode, v))
-}
-
-// MatchModeEqualFold applies the EqualFold predicate on the "match_mode" field.
-func MatchModeEqualFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEqualFold(FieldMatchMode, v))
-}
-
-// MatchModeContainsFold applies the ContainsFold predicate on the "match_mode" field.
-func MatchModeContainsFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContainsFold(FieldMatchMode, v))
-}
-
-// PlatformsIsNil applies the IsNil predicate on the "platforms" field.
-func PlatformsIsNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIsNull(FieldPlatforms))
-}
-
-// PlatformsNotNil applies the NotNil predicate on the "platforms" field.
-func PlatformsNotNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotNull(FieldPlatforms))
-}
-
-// PassthroughCodeEQ applies the EQ predicate on the "passthrough_code" field.
-func PassthroughCodeEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldPassthroughCode, v))
-}
-
-// PassthroughCodeNEQ applies the NEQ predicate on the "passthrough_code" field.
-func PassthroughCodeNEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldPassthroughCode, v))
-}
-
-// ResponseCodeEQ applies the EQ predicate on the "response_code" field.
-func ResponseCodeEQ(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldResponseCode, v))
-}
-
-// ResponseCodeNEQ applies the NEQ predicate on the "response_code" field.
-func ResponseCodeNEQ(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldResponseCode, v))
-}
-
-// ResponseCodeIn applies the In predicate on the "response_code" field.
-func ResponseCodeIn(vs ...int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldResponseCode, vs...))
-}
-
-// ResponseCodeNotIn applies the NotIn predicate on the "response_code" field.
-func ResponseCodeNotIn(vs ...int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldResponseCode, vs...))
-}
-
-// ResponseCodeGT applies the GT predicate on the "response_code" field.
-func ResponseCodeGT(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldResponseCode, v))
-}
-
-// ResponseCodeGTE applies the GTE predicate on the "response_code" field.
-func ResponseCodeGTE(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldResponseCode, v))
-}
-
-// ResponseCodeLT applies the LT predicate on the "response_code" field.
-func ResponseCodeLT(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldResponseCode, v))
-}
-
-// ResponseCodeLTE applies the LTE predicate on the "response_code" field.
-func ResponseCodeLTE(v int) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldResponseCode, v))
-}
-
-// ResponseCodeIsNil applies the IsNil predicate on the "response_code" field.
-func ResponseCodeIsNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIsNull(FieldResponseCode))
-}
-
-// ResponseCodeNotNil applies the NotNil predicate on the "response_code" field.
-func ResponseCodeNotNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotNull(FieldResponseCode))
-}
-
-// PassthroughBodyEQ applies the EQ predicate on the "passthrough_body" field.
-func PassthroughBodyEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldPassthroughBody, v))
-}
-
-// PassthroughBodyNEQ applies the NEQ predicate on the "passthrough_body" field.
-func PassthroughBodyNEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldPassthroughBody, v))
-}
-
-// CustomMessageEQ applies the EQ predicate on the "custom_message" field.
-func CustomMessageEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldCustomMessage, v))
-}
-
-// CustomMessageNEQ applies the NEQ predicate on the "custom_message" field.
-func CustomMessageNEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldCustomMessage, v))
-}
-
-// CustomMessageIn applies the In predicate on the "custom_message" field.
-func CustomMessageIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldCustomMessage, vs...))
-}
-
-// CustomMessageNotIn applies the NotIn predicate on the "custom_message" field.
-func CustomMessageNotIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldCustomMessage, vs...))
-}
-
-// CustomMessageGT applies the GT predicate on the "custom_message" field.
-func CustomMessageGT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldCustomMessage, v))
-}
-
-// CustomMessageGTE applies the GTE predicate on the "custom_message" field.
-func CustomMessageGTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldCustomMessage, v))
-}
-
-// CustomMessageLT applies the LT predicate on the "custom_message" field.
-func CustomMessageLT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldCustomMessage, v))
-}
-
-// CustomMessageLTE applies the LTE predicate on the "custom_message" field.
-func CustomMessageLTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldCustomMessage, v))
-}
-
-// CustomMessageContains applies the Contains predicate on the "custom_message" field.
-func CustomMessageContains(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContains(FieldCustomMessage, v))
-}
-
-// CustomMessageHasPrefix applies the HasPrefix predicate on the "custom_message" field.
-func CustomMessageHasPrefix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasPrefix(FieldCustomMessage, v))
-}
-
-// CustomMessageHasSuffix applies the HasSuffix predicate on the "custom_message" field.
-func CustomMessageHasSuffix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasSuffix(FieldCustomMessage, v))
-}
-
-// CustomMessageIsNil applies the IsNil predicate on the "custom_message" field.
-func CustomMessageIsNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIsNull(FieldCustomMessage))
-}
-
-// CustomMessageNotNil applies the NotNil predicate on the "custom_message" field.
-func CustomMessageNotNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotNull(FieldCustomMessage))
-}
-
-// CustomMessageEqualFold applies the EqualFold predicate on the "custom_message" field.
-func CustomMessageEqualFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEqualFold(FieldCustomMessage, v))
-}
-
-// CustomMessageContainsFold applies the ContainsFold predicate on the "custom_message" field.
-func CustomMessageContainsFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContainsFold(FieldCustomMessage, v))
-}
-
-// SkipMonitoringEQ applies the EQ predicate on the "skip_monitoring" field.
-func SkipMonitoringEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldSkipMonitoring, v))
-}
-
-// SkipMonitoringNEQ applies the NEQ predicate on the "skip_monitoring" field.
-func SkipMonitoringNEQ(v bool) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldSkipMonitoring, v))
-}
-
-// DescriptionEQ applies the EQ predicate on the "description" field.
-func DescriptionEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEQ(FieldDescription, v))
-}
-
-// DescriptionNEQ applies the NEQ predicate on the "description" field.
-func DescriptionNEQ(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNEQ(FieldDescription, v))
-}
-
-// DescriptionIn applies the In predicate on the "description" field.
-func DescriptionIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIn(FieldDescription, vs...))
-}
-
-// DescriptionNotIn applies the NotIn predicate on the "description" field.
-func DescriptionNotIn(vs ...string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotIn(FieldDescription, vs...))
-}
-
-// DescriptionGT applies the GT predicate on the "description" field.
-func DescriptionGT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGT(FieldDescription, v))
-}
-
-// DescriptionGTE applies the GTE predicate on the "description" field.
-func DescriptionGTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldGTE(FieldDescription, v))
-}
-
-// DescriptionLT applies the LT predicate on the "description" field.
-func DescriptionLT(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLT(FieldDescription, v))
-}
-
-// DescriptionLTE applies the LTE predicate on the "description" field.
-func DescriptionLTE(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldLTE(FieldDescription, v))
-}
-
-// DescriptionContains applies the Contains predicate on the "description" field.
-func DescriptionContains(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContains(FieldDescription, v))
-}
-
-// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
-func DescriptionHasPrefix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasPrefix(FieldDescription, v))
-}
-
-// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
-func DescriptionHasSuffix(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldHasSuffix(FieldDescription, v))
-}
-
-// DescriptionIsNil applies the IsNil predicate on the "description" field.
-func DescriptionIsNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldIsNull(FieldDescription))
-}
-
-// DescriptionNotNil applies the NotNil predicate on the "description" field.
-func DescriptionNotNil() predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldNotNull(FieldDescription))
-}
-
-// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
-func DescriptionEqualFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldEqualFold(FieldDescription, v))
-}
-
-// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
-func DescriptionContainsFold(v string) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.FieldContainsFold(FieldDescription, v))
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.ErrorPassthroughRule) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.ErrorPassthroughRule) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.ErrorPassthroughRule) predicate.ErrorPassthroughRule {
-	return predicate.ErrorPassthroughRule(sql.NotPredicates(p))
-}

backend/ent/errorpassthroughrule_delete.go

@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/errorpassthroughrule"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ErrorPassthroughRuleDelete is the builder for deleting a ErrorPassthroughRule entity.
-type ErrorPassthroughRuleDelete struct {
-	config
-	hooks    []Hook
-	mutation *ErrorPassthroughRuleMutation
-}
-
-// Where appends a list predicates to the ErrorPassthroughRuleDelete builder.
-func (_d *ErrorPassthroughRuleDelete) Where(ps ...predicate.ErrorPassthroughRule) *ErrorPassthroughRuleDelete {
-	_d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *ErrorPassthroughRuleDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *ErrorPassthroughRuleDelete) ExecX(ctx context.Context) int {
-	n, err := _d.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (_d *ErrorPassthroughRuleDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(errorpassthroughrule.Table, sqlgraph.NewFieldSpec(errorpassthroughrule.FieldID, field.TypeInt64))
-	if ps := _d.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	_d.mutation.done = true
-	return affected, err
-}
-
-// ErrorPassthroughRuleDeleteOne is the builder for deleting a single ErrorPassthroughRule entity.
-type ErrorPassthroughRuleDeleteOne struct {
-	_d *ErrorPassthroughRuleDelete
-}
-
-// Where appends a list predicates to the ErrorPassthroughRuleDelete builder.
-func (_d *ErrorPassthroughRuleDeleteOne) Where(ps ...predicate.ErrorPassthroughRule) *ErrorPassthroughRuleDeleteOne {
-	_d._d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query.
-func (_d *ErrorPassthroughRuleDeleteOne) Exec(ctx context.Context) error {
-	n, err := _d._d.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{errorpassthroughrule.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *ErrorPassthroughRuleDeleteOne) ExecX(ctx context.Context) {
-	if err := _d.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/errorpassthroughrule_query.go

@@ -1,564 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"fmt"
-	"math"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/errorpassthroughrule"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ErrorPassthroughRuleQuery is the builder for querying ErrorPassthroughRule entities.
-type ErrorPassthroughRuleQuery struct {
-	config
-	ctx        *QueryContext
-	order      []errorpassthroughrule.OrderOption
-	inters     []Interceptor
-	predicates []predicate.ErrorPassthroughRule
-	modifiers  []func(*sql.Selector)
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the ErrorPassthroughRuleQuery builder.
-func (_q *ErrorPassthroughRuleQuery) Where(ps ...predicate.ErrorPassthroughRule) *ErrorPassthroughRuleQuery {
-	_q.predicates = append(_q.predicates, ps...)
-	return _q
-}
-
-// Limit the number of records to be returned by this query.
-func (_q *ErrorPassthroughRuleQuery) Limit(limit int) *ErrorPassthroughRuleQuery {
-	_q.ctx.Limit = &limit
-	return _q
-}
-
-// Offset to start from.
-func (_q *ErrorPassthroughRuleQuery) Offset(offset int) *ErrorPassthroughRuleQuery {
-	_q.ctx.Offset = &offset
-	return _q
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (_q *ErrorPassthroughRuleQuery) Unique(unique bool) *ErrorPassthroughRuleQuery {
-	_q.ctx.Unique = &unique
-	return _q
-}
-
-// Order specifies how the records should be ordered.
-func (_q *ErrorPassthroughRuleQuery) Order(o ...errorpassthroughrule.OrderOption) *ErrorPassthroughRuleQuery {
-	_q.order = append(_q.order, o...)
-	return _q
-}
-
-// First returns the first ErrorPassthroughRule entity from the query.
-// Returns a *NotFoundError when no ErrorPassthroughRule was found.
-func (_q *ErrorPassthroughRuleQuery) First(ctx context.Context) (*ErrorPassthroughRule, error) {
-	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{errorpassthroughrule.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) FirstX(ctx context.Context) *ErrorPassthroughRule {
-	node, err := _q.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first ErrorPassthroughRule ID from the query.
-// Returns a *NotFoundError when no ErrorPassthroughRule ID was found.
-func (_q *ErrorPassthroughRuleQuery) FirstID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{errorpassthroughrule.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) FirstIDX(ctx context.Context) int64 {
-	id, err := _q.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single ErrorPassthroughRule entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one ErrorPassthroughRule entity is found.
-// Returns a *NotFoundError when no ErrorPassthroughRule entities are found.
-func (_q *ErrorPassthroughRuleQuery) Only(ctx context.Context) (*ErrorPassthroughRule, error) {
-	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{errorpassthroughrule.Label}
-	default:
-		return nil, &NotSingularError{errorpassthroughrule.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) OnlyX(ctx context.Context) *ErrorPassthroughRule {
-	node, err := _q.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only ErrorPassthroughRule ID in the query.
-// Returns a *NotSingularError when more than one ErrorPassthroughRule ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (_q *ErrorPassthroughRuleQuery) OnlyID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{errorpassthroughrule.Label}
-	default:
-		err = &NotSingularError{errorpassthroughrule.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) OnlyIDX(ctx context.Context) int64 {
-	id, err := _q.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of ErrorPassthroughRules.
-func (_q *ErrorPassthroughRuleQuery) All(ctx context.Context) ([]*ErrorPassthroughRule, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*ErrorPassthroughRule, *ErrorPassthroughRuleQuery]()
-	return withInterceptors[[]*ErrorPassthroughRule](ctx, _q, qr, _q.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) AllX(ctx context.Context) []*ErrorPassthroughRule {
-	nodes, err := _q.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of ErrorPassthroughRule IDs.
-func (_q *ErrorPassthroughRuleQuery) IDs(ctx context.Context) (ids []int64, err error) {
-	if _q.ctx.Unique == nil && _q.path != nil {
-		_q.Unique(true)
-	}
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
-	if err = _q.Select(errorpassthroughrule.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) IDsX(ctx context.Context) []int64 {
-	ids, err := _q.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (_q *ErrorPassthroughRuleQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, _q, querierCount[*ErrorPassthroughRuleQuery](), _q.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) CountX(ctx context.Context) int {
-	count, err := _q.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (_q *ErrorPassthroughRuleQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
-	switch _, err := _q.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (_q *ErrorPassthroughRuleQuery) ExistX(ctx context.Context) bool {
-	exist, err := _q.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the ErrorPassthroughRuleQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (_q *ErrorPassthroughRuleQuery) Clone() *ErrorPassthroughRuleQuery {
-	if _q == nil {
-		return nil
-	}
-	return &ErrorPassthroughRuleQuery{
-		config:     _q.config,
-		ctx:        _q.ctx.Clone(),
-		order:      append([]errorpassthroughrule.OrderOption{}, _q.order...),
-		inters:     append([]Interceptor{}, _q.inters...),
-		predicates: append([]predicate.ErrorPassthroughRule{}, _q.predicates...),
-		// clone intermediate query.
-		sql:  _q.sql.Clone(),
-		path: _q.path,
-	}
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		CreatedAt time.Time `json:"created_at,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.ErrorPassthroughRule.Query().
-//		GroupBy(errorpassthroughrule.FieldCreatedAt).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (_q *ErrorPassthroughRuleQuery) GroupBy(field string, fields ...string) *ErrorPassthroughRuleGroupBy {
-	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &ErrorPassthroughRuleGroupBy{build: _q}
-	grbuild.flds = &_q.ctx.Fields
-	grbuild.label = errorpassthroughrule.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		CreatedAt time.Time `json:"created_at,omitempty"`
-//	}
-//
-//	client.ErrorPassthroughRule.Query().
-//		Select(errorpassthroughrule.FieldCreatedAt).
-//		Scan(ctx, &v)
-func (_q *ErrorPassthroughRuleQuery) Select(fields ...string) *ErrorPassthroughRuleSelect {
-	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &ErrorPassthroughRuleSelect{ErrorPassthroughRuleQuery: _q}
-	sbuild.label = errorpassthroughrule.Label
-	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a ErrorPassthroughRuleSelect configured with the given aggregations.
-func (_q *ErrorPassthroughRuleQuery) Aggregate(fns ...AggregateFunc) *ErrorPassthroughRuleSelect {
-	return _q.Select().Aggregate(fns...)
-}
-
-func (_q *ErrorPassthroughRuleQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range _q.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, _q); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range _q.ctx.Fields {
-		if !errorpassthroughrule.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if _q.path != nil {
-		prev, err := _q.path(ctx)
-		if err != nil {
-			return err
-		}
-		_q.sql = prev
-	}
-	return nil
-}
-
-func (_q *ErrorPassthroughRuleQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ErrorPassthroughRule, error) {
-	var (
-		nodes = []*ErrorPassthroughRule{}
-		_spec = _q.querySpec()
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*ErrorPassthroughRule).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &ErrorPassthroughRule{config: _q.config}
-		nodes = append(nodes, node)
-		return node.assignValues(columns, values)
-	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	return nodes, nil
-}
-
-func (_q *ErrorPassthroughRuleQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	_spec.Node.Columns = _q.ctx.Fields
-	if len(_q.ctx.Fields) > 0 {
-		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
-}
-
-func (_q *ErrorPassthroughRuleQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(errorpassthroughrule.Table, errorpassthroughrule.Columns, sqlgraph.NewFieldSpec(errorpassthroughrule.FieldID, field.TypeInt64))
-	_spec.From = _q.sql
-	if unique := _q.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if _q.path != nil {
-		_spec.Unique = true
-	}
-	if fields := _q.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, errorpassthroughrule.FieldID)
-		for i := range fields {
-			if fields[i] != errorpassthroughrule.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-	}
-	if ps := _q.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := _q.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (_q *ErrorPassthroughRuleQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(_q.driver.Dialect())
-	t1 := builder.Table(errorpassthroughrule.Table)
-	columns := _q.ctx.Fields
-	if len(columns) == 0 {
-		columns = errorpassthroughrule.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if _q.sql != nil {
-		selector = _q.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if _q.ctx.Unique != nil && *_q.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
-	for _, p := range _q.predicates {
-		p(selector)
-	}
-	for _, p := range _q.order {
-		p(selector)
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *ErrorPassthroughRuleQuery) ForUpdate(opts ...sql.LockOption) *ErrorPassthroughRuleQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *ErrorPassthroughRuleQuery) ForShare(opts ...sql.LockOption) *ErrorPassthroughRuleQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// ErrorPassthroughRuleGroupBy is the group-by builder for ErrorPassthroughRule entities.
-type ErrorPassthroughRuleGroupBy struct {
-	selector
-	build *ErrorPassthroughRuleQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (_g *ErrorPassthroughRuleGroupBy) Aggregate(fns ...AggregateFunc) *ErrorPassthroughRuleGroupBy {
-	_g.fns = append(_g.fns, fns...)
-	return _g
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_g *ErrorPassthroughRuleGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
-	if err := _g.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*ErrorPassthroughRuleQuery, *ErrorPassthroughRuleGroupBy](ctx, _g.build, _g, _g.build.inters, v)
-}
-
-func (_g *ErrorPassthroughRuleGroupBy) sqlScan(ctx context.Context, root *ErrorPassthroughRuleQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(_g.fns))
-	for _, fn := range _g.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
-		for _, f := range *_g.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*_g.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// ErrorPassthroughRuleSelect is the builder for selecting fields of ErrorPassthroughRule entities.
-type ErrorPassthroughRuleSelect struct {
-	*ErrorPassthroughRuleQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (_s *ErrorPassthroughRuleSelect) Aggregate(fns ...AggregateFunc) *ErrorPassthroughRuleSelect {
-	_s.fns = append(_s.fns, fns...)
-	return _s
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_s *ErrorPassthroughRuleSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
-	if err := _s.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*ErrorPassthroughRuleQuery, *ErrorPassthroughRuleSelect](ctx, _s.ErrorPassthroughRuleQuery, _s, _s.inters, v)
-}
-
-func (_s *ErrorPassthroughRuleSelect) sqlScan(ctx context.Context, root *ErrorPassthroughRuleQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(_s.fns))
-	for _, fn := range _s.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*_s.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}

backend/ent/errorpassthroughrule_update.go

@@ -1,857 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/dialect/sql/sqljson"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/errorpassthroughrule"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ErrorPassthroughRuleUpdate is the builder for updating ErrorPassthroughRule entities.
-type ErrorPassthroughRuleUpdate struct {
-	config
-	hooks    []Hook
-	mutation *ErrorPassthroughRuleMutation
-}
-
-// Where appends a list predicates to the ErrorPassthroughRuleUpdate builder.
-func (_u *ErrorPassthroughRuleUpdate) Where(ps ...predicate.ErrorPassthroughRule) *ErrorPassthroughRuleUpdate {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *ErrorPassthroughRuleUpdate) SetUpdatedAt(v time.Time) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// SetName sets the "name" field.
-func (_u *ErrorPassthroughRuleUpdate) SetName(v string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetName(v)
-	return _u
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillableName(v *string) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetName(*v)
-	}
-	return _u
-}
-
-// SetEnabled sets the "enabled" field.
-func (_u *ErrorPassthroughRuleUpdate) SetEnabled(v bool) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetEnabled(v)
-	return _u
-}
-
-// SetNillableEnabled sets the "enabled" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillableEnabled(v *bool) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetEnabled(*v)
-	}
-	return _u
-}
-
-// SetPriority sets the "priority" field.
-func (_u *ErrorPassthroughRuleUpdate) SetPriority(v int) *ErrorPassthroughRuleUpdate {
-	_u.mutation.ResetPriority()
-	_u.mutation.SetPriority(v)
-	return _u
-}
-
-// SetNillablePriority sets the "priority" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillablePriority(v *int) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetPriority(*v)
-	}
-	return _u
-}
-
-// AddPriority adds value to the "priority" field.
-func (_u *ErrorPassthroughRuleUpdate) AddPriority(v int) *ErrorPassthroughRuleUpdate {
-	_u.mutation.AddPriority(v)
-	return _u
-}
-
-// SetErrorCodes sets the "error_codes" field.
-func (_u *ErrorPassthroughRuleUpdate) SetErrorCodes(v []int) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetErrorCodes(v)
-	return _u
-}
-
-// AppendErrorCodes appends value to the "error_codes" field.
-func (_u *ErrorPassthroughRuleUpdate) AppendErrorCodes(v []int) *ErrorPassthroughRuleUpdate {
-	_u.mutation.AppendErrorCodes(v)
-	return _u
-}
-
-// ClearErrorCodes clears the value of the "error_codes" field.
-func (_u *ErrorPassthroughRuleUpdate) ClearErrorCodes() *ErrorPassthroughRuleUpdate {
-	_u.mutation.ClearErrorCodes()
-	return _u
-}
-
-// SetKeywords sets the "keywords" field.
-func (_u *ErrorPassthroughRuleUpdate) SetKeywords(v []string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetKeywords(v)
-	return _u
-}
-
-// AppendKeywords appends value to the "keywords" field.
-func (_u *ErrorPassthroughRuleUpdate) AppendKeywords(v []string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.AppendKeywords(v)
-	return _u
-}
-
-// ClearKeywords clears the value of the "keywords" field.
-func (_u *ErrorPassthroughRuleUpdate) ClearKeywords() *ErrorPassthroughRuleUpdate {
-	_u.mutation.ClearKeywords()
-	return _u
-}
-
-// SetMatchMode sets the "match_mode" field.
-func (_u *ErrorPassthroughRuleUpdate) SetMatchMode(v string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetMatchMode(v)
-	return _u
-}
-
-// SetNillableMatchMode sets the "match_mode" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillableMatchMode(v *string) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetMatchMode(*v)
-	}
-	return _u
-}
-
-// SetPlatforms sets the "platforms" field.
-func (_u *ErrorPassthroughRuleUpdate) SetPlatforms(v []string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetPlatforms(v)
-	return _u
-}
-
-// AppendPlatforms appends value to the "platforms" field.
-func (_u *ErrorPassthroughRuleUpdate) AppendPlatforms(v []string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.AppendPlatforms(v)
-	return _u
-}
-
-// ClearPlatforms clears the value of the "platforms" field.
-func (_u *ErrorPassthroughRuleUpdate) ClearPlatforms() *ErrorPassthroughRuleUpdate {
-	_u.mutation.ClearPlatforms()
-	return _u
-}
-
-// SetPassthroughCode sets the "passthrough_code" field.
-func (_u *ErrorPassthroughRuleUpdate) SetPassthroughCode(v bool) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetPassthroughCode(v)
-	return _u
-}
-
-// SetNillablePassthroughCode sets the "passthrough_code" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillablePassthroughCode(v *bool) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetPassthroughCode(*v)
-	}
-	return _u
-}
-
-// SetResponseCode sets the "response_code" field.
-func (_u *ErrorPassthroughRuleUpdate) SetResponseCode(v int) *ErrorPassthroughRuleUpdate {
-	_u.mutation.ResetResponseCode()
-	_u.mutation.SetResponseCode(v)
-	return _u
-}
-
-// SetNillableResponseCode sets the "response_code" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillableResponseCode(v *int) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetResponseCode(*v)
-	}
-	return _u
-}
-
-// AddResponseCode adds value to the "response_code" field.
-func (_u *ErrorPassthroughRuleUpdate) AddResponseCode(v int) *ErrorPassthroughRuleUpdate {
-	_u.mutation.AddResponseCode(v)
-	return _u
-}
-
-// ClearResponseCode clears the value of the "response_code" field.
-func (_u *ErrorPassthroughRuleUpdate) ClearResponseCode() *ErrorPassthroughRuleUpdate {
-	_u.mutation.ClearResponseCode()
-	return _u
-}
-
-// SetPassthroughBody sets the "passthrough_body" field.
-func (_u *ErrorPassthroughRuleUpdate) SetPassthroughBody(v bool) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetPassthroughBody(v)
-	return _u
-}
-
-// SetNillablePassthroughBody sets the "passthrough_body" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillablePassthroughBody(v *bool) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetPassthroughBody(*v)
-	}
-	return _u
-}
-
-// SetCustomMessage sets the "custom_message" field.
-func (_u *ErrorPassthroughRuleUpdate) SetCustomMessage(v string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetCustomMessage(v)
-	return _u
-}
-
-// SetNillableCustomMessage sets the "custom_message" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillableCustomMessage(v *string) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetCustomMessage(*v)
-	}
-	return _u
-}
-
-// ClearCustomMessage clears the value of the "custom_message" field.
-func (_u *ErrorPassthroughRuleUpdate) ClearCustomMessage() *ErrorPassthroughRuleUpdate {
-	_u.mutation.ClearCustomMessage()
-	return _u
-}
-
-// SetSkipMonitoring sets the "skip_monitoring" field.
-func (_u *ErrorPassthroughRuleUpdate) SetSkipMonitoring(v bool) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetSkipMonitoring(v)
-	return _u
-}
-
-// SetNillableSkipMonitoring sets the "skip_monitoring" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillableSkipMonitoring(v *bool) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetSkipMonitoring(*v)
-	}
-	return _u
-}
-
-// SetDescription sets the "description" field.
-func (_u *ErrorPassthroughRuleUpdate) SetDescription(v string) *ErrorPassthroughRuleUpdate {
-	_u.mutation.SetDescription(v)
-	return _u
-}
-
-// SetNillableDescription sets the "description" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdate) SetNillableDescription(v *string) *ErrorPassthroughRuleUpdate {
-	if v != nil {
-		_u.SetDescription(*v)
-	}
-	return _u
-}
-
-// ClearDescription clears the value of the "description" field.
-func (_u *ErrorPassthroughRuleUpdate) ClearDescription() *ErrorPassthroughRuleUpdate {
-	_u.mutation.ClearDescription()
-	return _u
-}
-
-// Mutation returns the ErrorPassthroughRuleMutation object of the builder.
-func (_u *ErrorPassthroughRuleUpdate) Mutation() *ErrorPassthroughRuleMutation {
-	return _u.mutation
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *ErrorPassthroughRuleUpdate) Save(ctx context.Context) (int, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *ErrorPassthroughRuleUpdate) SaveX(ctx context.Context) int {
-	affected, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (_u *ErrorPassthroughRuleUpdate) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *ErrorPassthroughRuleUpdate) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *ErrorPassthroughRuleUpdate) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := errorpassthroughrule.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *ErrorPassthroughRuleUpdate) check() error {
-	if v, ok := _u.mutation.Name(); ok {
-		if err := errorpassthroughrule.NameValidator(v); err != nil {
-			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "ErrorPassthroughRule.name": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.MatchMode(); ok {
-		if err := errorpassthroughrule.MatchModeValidator(v); err != nil {
-			return &ValidationError{Name: "match_mode", err: fmt.Errorf(`ent: validator failed for field "ErrorPassthroughRule.match_mode": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *ErrorPassthroughRuleUpdate) sqlSave(ctx context.Context) (_node int, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(errorpassthroughrule.Table, errorpassthroughrule.Columns, sqlgraph.NewFieldSpec(errorpassthroughrule.FieldID, field.TypeInt64))
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(errorpassthroughrule.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := _u.mutation.Name(); ok {
-		_spec.SetField(errorpassthroughrule.FieldName, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Enabled(); ok {
-		_spec.SetField(errorpassthroughrule.FieldEnabled, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.Priority(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPriority, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedPriority(); ok {
-		_spec.AddField(errorpassthroughrule.FieldPriority, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.ErrorCodes(); ok {
-		_spec.SetField(errorpassthroughrule.FieldErrorCodes, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedErrorCodes(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, errorpassthroughrule.FieldErrorCodes, value)
-		})
-	}
-	if _u.mutation.ErrorCodesCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldErrorCodes, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.Keywords(); ok {
-		_spec.SetField(errorpassthroughrule.FieldKeywords, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedKeywords(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, errorpassthroughrule.FieldKeywords, value)
-		})
-	}
-	if _u.mutation.KeywordsCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldKeywords, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.MatchMode(); ok {
-		_spec.SetField(errorpassthroughrule.FieldMatchMode, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Platforms(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPlatforms, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedPlatforms(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, errorpassthroughrule.FieldPlatforms, value)
-		})
-	}
-	if _u.mutation.PlatformsCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldPlatforms, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.PassthroughCode(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPassthroughCode, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.ResponseCode(); ok {
-		_spec.SetField(errorpassthroughrule.FieldResponseCode, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedResponseCode(); ok {
-		_spec.AddField(errorpassthroughrule.FieldResponseCode, field.TypeInt, value)
-	}
-	if _u.mutation.ResponseCodeCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldResponseCode, field.TypeInt)
-	}
-	if value, ok := _u.mutation.PassthroughBody(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPassthroughBody, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.CustomMessage(); ok {
-		_spec.SetField(errorpassthroughrule.FieldCustomMessage, field.TypeString, value)
-	}
-	if _u.mutation.CustomMessageCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldCustomMessage, field.TypeString)
-	}
-	if value, ok := _u.mutation.SkipMonitoring(); ok {
-		_spec.SetField(errorpassthroughrule.FieldSkipMonitoring, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.Description(); ok {
-		_spec.SetField(errorpassthroughrule.FieldDescription, field.TypeString, value)
-	}
-	if _u.mutation.DescriptionCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldDescription, field.TypeString)
-	}
-	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{errorpassthroughrule.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}
-
-// ErrorPassthroughRuleUpdateOne is the builder for updating a single ErrorPassthroughRule entity.
-type ErrorPassthroughRuleUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *ErrorPassthroughRuleMutation
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetUpdatedAt(v time.Time) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// SetName sets the "name" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetName(v string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetName(v)
-	return _u
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillableName(v *string) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetName(*v)
-	}
-	return _u
-}
-
-// SetEnabled sets the "enabled" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetEnabled(v bool) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetEnabled(v)
-	return _u
-}
-
-// SetNillableEnabled sets the "enabled" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillableEnabled(v *bool) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetEnabled(*v)
-	}
-	return _u
-}
-
-// SetPriority sets the "priority" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetPriority(v int) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ResetPriority()
-	_u.mutation.SetPriority(v)
-	return _u
-}
-
-// SetNillablePriority sets the "priority" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillablePriority(v *int) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetPriority(*v)
-	}
-	return _u
-}
-
-// AddPriority adds value to the "priority" field.
-func (_u *ErrorPassthroughRuleUpdateOne) AddPriority(v int) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.AddPriority(v)
-	return _u
-}
-
-// SetErrorCodes sets the "error_codes" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetErrorCodes(v []int) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetErrorCodes(v)
-	return _u
-}
-
-// AppendErrorCodes appends value to the "error_codes" field.
-func (_u *ErrorPassthroughRuleUpdateOne) AppendErrorCodes(v []int) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.AppendErrorCodes(v)
-	return _u
-}
-
-// ClearErrorCodes clears the value of the "error_codes" field.
-func (_u *ErrorPassthroughRuleUpdateOne) ClearErrorCodes() *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ClearErrorCodes()
-	return _u
-}
-
-// SetKeywords sets the "keywords" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetKeywords(v []string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetKeywords(v)
-	return _u
-}
-
-// AppendKeywords appends value to the "keywords" field.
-func (_u *ErrorPassthroughRuleUpdateOne) AppendKeywords(v []string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.AppendKeywords(v)
-	return _u
-}
-
-// ClearKeywords clears the value of the "keywords" field.
-func (_u *ErrorPassthroughRuleUpdateOne) ClearKeywords() *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ClearKeywords()
-	return _u
-}
-
-// SetMatchMode sets the "match_mode" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetMatchMode(v string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetMatchMode(v)
-	return _u
-}
-
-// SetNillableMatchMode sets the "match_mode" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillableMatchMode(v *string) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetMatchMode(*v)
-	}
-	return _u
-}
-
-// SetPlatforms sets the "platforms" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetPlatforms(v []string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetPlatforms(v)
-	return _u
-}
-
-// AppendPlatforms appends value to the "platforms" field.
-func (_u *ErrorPassthroughRuleUpdateOne) AppendPlatforms(v []string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.AppendPlatforms(v)
-	return _u
-}
-
-// ClearPlatforms clears the value of the "platforms" field.
-func (_u *ErrorPassthroughRuleUpdateOne) ClearPlatforms() *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ClearPlatforms()
-	return _u
-}
-
-// SetPassthroughCode sets the "passthrough_code" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetPassthroughCode(v bool) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetPassthroughCode(v)
-	return _u
-}
-
-// SetNillablePassthroughCode sets the "passthrough_code" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillablePassthroughCode(v *bool) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetPassthroughCode(*v)
-	}
-	return _u
-}
-
-// SetResponseCode sets the "response_code" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetResponseCode(v int) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ResetResponseCode()
-	_u.mutation.SetResponseCode(v)
-	return _u
-}
-
-// SetNillableResponseCode sets the "response_code" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillableResponseCode(v *int) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetResponseCode(*v)
-	}
-	return _u
-}
-
-// AddResponseCode adds value to the "response_code" field.
-func (_u *ErrorPassthroughRuleUpdateOne) AddResponseCode(v int) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.AddResponseCode(v)
-	return _u
-}
-
-// ClearResponseCode clears the value of the "response_code" field.
-func (_u *ErrorPassthroughRuleUpdateOne) ClearResponseCode() *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ClearResponseCode()
-	return _u
-}
-
-// SetPassthroughBody sets the "passthrough_body" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetPassthroughBody(v bool) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetPassthroughBody(v)
-	return _u
-}
-
-// SetNillablePassthroughBody sets the "passthrough_body" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillablePassthroughBody(v *bool) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetPassthroughBody(*v)
-	}
-	return _u
-}
-
-// SetCustomMessage sets the "custom_message" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetCustomMessage(v string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetCustomMessage(v)
-	return _u
-}
-
-// SetNillableCustomMessage sets the "custom_message" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillableCustomMessage(v *string) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetCustomMessage(*v)
-	}
-	return _u
-}
-
-// ClearCustomMessage clears the value of the "custom_message" field.
-func (_u *ErrorPassthroughRuleUpdateOne) ClearCustomMessage() *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ClearCustomMessage()
-	return _u
-}
-
-// SetSkipMonitoring sets the "skip_monitoring" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetSkipMonitoring(v bool) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetSkipMonitoring(v)
-	return _u
-}
-
-// SetNillableSkipMonitoring sets the "skip_monitoring" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillableSkipMonitoring(v *bool) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetSkipMonitoring(*v)
-	}
-	return _u
-}
-
-// SetDescription sets the "description" field.
-func (_u *ErrorPassthroughRuleUpdateOne) SetDescription(v string) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.SetDescription(v)
-	return _u
-}
-
-// SetNillableDescription sets the "description" field if the given value is not nil.
-func (_u *ErrorPassthroughRuleUpdateOne) SetNillableDescription(v *string) *ErrorPassthroughRuleUpdateOne {
-	if v != nil {
-		_u.SetDescription(*v)
-	}
-	return _u
-}
-
-// ClearDescription clears the value of the "description" field.
-func (_u *ErrorPassthroughRuleUpdateOne) ClearDescription() *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.ClearDescription()
-	return _u
-}
-
-// Mutation returns the ErrorPassthroughRuleMutation object of the builder.
-func (_u *ErrorPassthroughRuleUpdateOne) Mutation() *ErrorPassthroughRuleMutation {
-	return _u.mutation
-}
-
-// Where appends a list predicates to the ErrorPassthroughRuleUpdate builder.
-func (_u *ErrorPassthroughRuleUpdateOne) Where(ps ...predicate.ErrorPassthroughRule) *ErrorPassthroughRuleUpdateOne {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (_u *ErrorPassthroughRuleUpdateOne) Select(field string, fields ...string) *ErrorPassthroughRuleUpdateOne {
-	_u.fields = append([]string{field}, fields...)
-	return _u
-}
-
-// Save executes the query and returns the updated ErrorPassthroughRule entity.
-func (_u *ErrorPassthroughRuleUpdateOne) Save(ctx context.Context) (*ErrorPassthroughRule, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *ErrorPassthroughRuleUpdateOne) SaveX(ctx context.Context) *ErrorPassthroughRule {
-	node, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (_u *ErrorPassthroughRuleUpdateOne) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *ErrorPassthroughRuleUpdateOne) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *ErrorPassthroughRuleUpdateOne) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := errorpassthroughrule.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *ErrorPassthroughRuleUpdateOne) check() error {
-	if v, ok := _u.mutation.Name(); ok {
-		if err := errorpassthroughrule.NameValidator(v); err != nil {
-			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "ErrorPassthroughRule.name": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.MatchMode(); ok {
-		if err := errorpassthroughrule.MatchModeValidator(v); err != nil {
-			return &ValidationError{Name: "match_mode", err: fmt.Errorf(`ent: validator failed for field "ErrorPassthroughRule.match_mode": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *ErrorPassthroughRuleUpdateOne) sqlSave(ctx context.Context) (_node *ErrorPassthroughRule, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(errorpassthroughrule.Table, errorpassthroughrule.Columns, sqlgraph.NewFieldSpec(errorpassthroughrule.FieldID, field.TypeInt64))
-	id, ok := _u.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ErrorPassthroughRule.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := _u.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, errorpassthroughrule.FieldID)
-		for _, f := range fields {
-			if !errorpassthroughrule.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != errorpassthroughrule.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(errorpassthroughrule.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := _u.mutation.Name(); ok {
-		_spec.SetField(errorpassthroughrule.FieldName, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Enabled(); ok {
-		_spec.SetField(errorpassthroughrule.FieldEnabled, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.Priority(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPriority, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedPriority(); ok {
-		_spec.AddField(errorpassthroughrule.FieldPriority, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.ErrorCodes(); ok {
-		_spec.SetField(errorpassthroughrule.FieldErrorCodes, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedErrorCodes(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, errorpassthroughrule.FieldErrorCodes, value)
-		})
-	}
-	if _u.mutation.ErrorCodesCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldErrorCodes, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.Keywords(); ok {
-		_spec.SetField(errorpassthroughrule.FieldKeywords, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedKeywords(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, errorpassthroughrule.FieldKeywords, value)
-		})
-	}
-	if _u.mutation.KeywordsCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldKeywords, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.MatchMode(); ok {
-		_spec.SetField(errorpassthroughrule.FieldMatchMode, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Platforms(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPlatforms, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedPlatforms(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, errorpassthroughrule.FieldPlatforms, value)
-		})
-	}
-	if _u.mutation.PlatformsCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldPlatforms, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.PassthroughCode(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPassthroughCode, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.ResponseCode(); ok {
-		_spec.SetField(errorpassthroughrule.FieldResponseCode, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedResponseCode(); ok {
-		_spec.AddField(errorpassthroughrule.FieldResponseCode, field.TypeInt, value)
-	}
-	if _u.mutation.ResponseCodeCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldResponseCode, field.TypeInt)
-	}
-	if value, ok := _u.mutation.PassthroughBody(); ok {
-		_spec.SetField(errorpassthroughrule.FieldPassthroughBody, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.CustomMessage(); ok {
-		_spec.SetField(errorpassthroughrule.FieldCustomMessage, field.TypeString, value)
-	}
-	if _u.mutation.CustomMessageCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldCustomMessage, field.TypeString)
-	}
-	if value, ok := _u.mutation.SkipMonitoring(); ok {
-		_spec.SetField(errorpassthroughrule.FieldSkipMonitoring, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.Description(); ok {
-		_spec.SetField(errorpassthroughrule.FieldDescription, field.TypeString, value)
-	}
-	if _u.mutation.DescriptionCleared() {
-		_spec.ClearField(errorpassthroughrule.FieldDescription, field.TypeString)
-	}
-	_node = &ErrorPassthroughRule{config: _u.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{errorpassthroughrule.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}

backend/ent/generate.go

@@ -1,6 +1,4 @@
-// Package ent provides the generated ORM code for database entities.
 package ent
 
 // 启用 sql/execquery 以生成 ExecContext/QueryContext 的透传接口，便于事务内执行原生 SQL。
-// 启用 sql/lock 以支持 FOR UPDATE 行锁。
-//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/upsert,intercept,sql/execquery,sql/lock --idtype int64 ./schema
+//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/upsert,intercept,sql/execquery --idtype int64 ./schema

backend/ent/group.go

@@ -3,7 +3,6 @@
 package ent
 
 import (
-	"encoding/json"
 	"fmt"
 	"strings"
 	"time"
@@ -46,42 +45,6 @@ type Group struct {
 	MonthlyLimitUsd *float64 `json:"monthly_limit_usd,omitempty"`
 	// DefaultValidityDays holds the value of the "default_validity_days" field.
 	DefaultValidityDays int `json:"default_validity_days,omitempty"`
-	// ImagePrice1k holds the value of the "image_price_1k" field.
-	ImagePrice1k *float64 `json:"image_price_1k,omitempty"`
-	// ImagePrice2k holds the value of the "image_price_2k" field.
-	ImagePrice2k *float64 `json:"image_price_2k,omitempty"`
-	// ImagePrice4k holds the value of the "image_price_4k" field.
-	ImagePrice4k *float64 `json:"image_price_4k,omitempty"`
-	// SoraImagePrice360 holds the value of the "sora_image_price_360" field.
-	SoraImagePrice360 *float64 `json:"sora_image_price_360,omitempty"`
-	// SoraImagePrice540 holds the value of the "sora_image_price_540" field.
-	SoraImagePrice540 *float64 `json:"sora_image_price_540,omitempty"`
-	// SoraVideoPricePerRequest holds the value of the "sora_video_price_per_request" field.
-	SoraVideoPricePerRequest *float64 `json:"sora_video_price_per_request,omitempty"`
-	// SoraVideoPricePerRequestHd holds the value of the "sora_video_price_per_request_hd" field.
-	SoraVideoPricePerRequestHd *float64 `json:"sora_video_price_per_request_hd,omitempty"`
-	// SoraStorageQuotaBytes holds the value of the "sora_storage_quota_bytes" field.
-	SoraStorageQuotaBytes int64 `json:"sora_storage_quota_bytes,omitempty"`
-	// 是否仅允许 Claude Code 客户端
-	ClaudeCodeOnly bool `json:"claude_code_only,omitempty"`
-	// 非 Claude Code 请求降级使用的分组 ID
-	FallbackGroupID *int64 `json:"fallback_group_id,omitempty"`
-	// 无效请求兜底使用的分组 ID
-	FallbackGroupIDOnInvalidRequest *int64 `json:"fallback_group_id_on_invalid_request,omitempty"`
-	// 模型路由配置：模型模式 -> 优先账号ID列表
-	ModelRouting map[string][]int64 `json:"model_routing,omitempty"`
-	// 是否启用模型路由配置
-	ModelRoutingEnabled bool `json:"model_routing_enabled,omitempty"`
-	// 是否注入 MCP XML 调用协议提示词（仅 antigravity 平台）
-	McpXMLInject bool `json:"mcp_xml_inject,omitempty"`
-	// 支持的模型系列：claude, gemini_text, gemini_image
-	SupportedModelScopes []string `json:"supported_model_scopes,omitempty"`
-	// 分组显示排序，数值越小越靠前
-	SortOrder int `json:"sort_order,omitempty"`
-	// 是否允许 /v1/messages 调度到此 OpenAI 分组
-	AllowMessagesDispatch bool `json:"allow_messages_dispatch,omitempty"`
-	// 默认映射模型 ID，当账号级映射找不到时使用此值
-	DefaultMappedModel string `json:"default_mapped_model,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
 	// The values are being populated by the GroupQuery when eager-loading is set.
 	Edges        GroupEdges `json:"edges"`
@@ -91,7 +54,7 @@ type Group struct {
 // GroupEdges holds the relations/edges for other nodes in the graph.
 type GroupEdges struct {
 	// APIKeys holds the value of the api_keys edge.
-	APIKeys []*APIKey `json:"api_keys,omitempty"`
+	APIKeys []*ApiKey `json:"api_keys,omitempty"`
 	// RedeemCodes holds the value of the redeem_codes edge.
 	RedeemCodes []*RedeemCode `json:"redeem_codes,omitempty"`
 	// Subscriptions holds the value of the subscriptions edge.
@@ -113,7 +76,7 @@ type GroupEdges struct {
 
 // APIKeysOrErr returns the APIKeys value or an error if the edge
 // was not loaded in eager-loading.
-func (e GroupEdges) APIKeysOrErr() ([]*APIKey, error) {
+func (e GroupEdges) APIKeysOrErr() ([]*ApiKey, error) {
 	if e.loadedTypes[0] {
 		return e.APIKeys, nil
 	}
@@ -188,15 +151,13 @@ func (*Group) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case group.FieldModelRouting, group.FieldSupportedModelScopes:
-			values[i] = new([]byte)
-		case group.FieldIsExclusive, group.FieldClaudeCodeOnly, group.FieldModelRoutingEnabled, group.FieldMcpXMLInject, group.FieldAllowMessagesDispatch:
+		case group.FieldIsExclusive:
 			values[i] = new(sql.NullBool)
-		case group.FieldRateMultiplier, group.FieldDailyLimitUsd, group.FieldWeeklyLimitUsd, group.FieldMonthlyLimitUsd, group.FieldImagePrice1k, group.FieldImagePrice2k, group.FieldImagePrice4k, group.FieldSoraImagePrice360, group.FieldSoraImagePrice540, group.FieldSoraVideoPricePerRequest, group.FieldSoraVideoPricePerRequestHd:
+		case group.FieldRateMultiplier, group.FieldDailyLimitUsd, group.FieldWeeklyLimitUsd, group.FieldMonthlyLimitUsd:
 			values[i] = new(sql.NullFloat64)
-		case group.FieldID, group.FieldDefaultValidityDays, group.FieldSoraStorageQuotaBytes, group.FieldFallbackGroupID, group.FieldFallbackGroupIDOnInvalidRequest, group.FieldSortOrder:
+		case group.FieldID, group.FieldDefaultValidityDays:
 			values[i] = new(sql.NullInt64)
-		case group.FieldName, group.FieldDescription, group.FieldStatus, group.FieldPlatform, group.FieldSubscriptionType, group.FieldDefaultMappedModel:
+		case group.FieldName, group.FieldDescription, group.FieldStatus, group.FieldPlatform, group.FieldSubscriptionType:
 			values[i] = new(sql.NullString)
 		case group.FieldCreatedAt, group.FieldUpdatedAt, group.FieldDeletedAt:
 			values[i] = new(sql.NullTime)
@@ -310,127 +271,6 @@ func (_m *Group) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.DefaultValidityDays = int(value.Int64)
 			}
-		case group.FieldImagePrice1k:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field image_price_1k", values[i])
-			} else if value.Valid {
-				_m.ImagePrice1k = new(float64)
-				*_m.ImagePrice1k = value.Float64
-			}
-		case group.FieldImagePrice2k:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field image_price_2k", values[i])
-			} else if value.Valid {
-				_m.ImagePrice2k = new(float64)
-				*_m.ImagePrice2k = value.Float64
-			}
-		case group.FieldImagePrice4k:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field image_price_4k", values[i])
-			} else if value.Valid {
-				_m.ImagePrice4k = new(float64)
-				*_m.ImagePrice4k = value.Float64
-			}
-		case group.FieldSoraImagePrice360:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field sora_image_price_360", values[i])
-			} else if value.Valid {
-				_m.SoraImagePrice360 = new(float64)
-				*_m.SoraImagePrice360 = value.Float64
-			}
-		case group.FieldSoraImagePrice540:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field sora_image_price_540", values[i])
-			} else if value.Valid {
-				_m.SoraImagePrice540 = new(float64)
-				*_m.SoraImagePrice540 = value.Float64
-			}
-		case group.FieldSoraVideoPricePerRequest:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field sora_video_price_per_request", values[i])
-			} else if value.Valid {
-				_m.SoraVideoPricePerRequest = new(float64)
-				*_m.SoraVideoPricePerRequest = value.Float64
-			}
-		case group.FieldSoraVideoPricePerRequestHd:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field sora_video_price_per_request_hd", values[i])
-			} else if value.Valid {
-				_m.SoraVideoPricePerRequestHd = new(float64)
-				*_m.SoraVideoPricePerRequestHd = value.Float64
-			}
-		case group.FieldSoraStorageQuotaBytes:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field sora_storage_quota_bytes", values[i])
-			} else if value.Valid {
-				_m.SoraStorageQuotaBytes = value.Int64
-			}
-		case group.FieldClaudeCodeOnly:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field claude_code_only", values[i])
-			} else if value.Valid {
-				_m.ClaudeCodeOnly = value.Bool
-			}
-		case group.FieldFallbackGroupID:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field fallback_group_id", values[i])
-			} else if value.Valid {
-				_m.FallbackGroupID = new(int64)
-				*_m.FallbackGroupID = value.Int64
-			}
-		case group.FieldFallbackGroupIDOnInvalidRequest:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field fallback_group_id_on_invalid_request", values[i])
-			} else if value.Valid {
-				_m.FallbackGroupIDOnInvalidRequest = new(int64)
-				*_m.FallbackGroupIDOnInvalidRequest = value.Int64
-			}
-		case group.FieldModelRouting:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field model_routing", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.ModelRouting); err != nil {
-					return fmt.Errorf("unmarshal field model_routing: %w", err)
-				}
-			}
-		case group.FieldModelRoutingEnabled:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field model_routing_enabled", values[i])
-			} else if value.Valid {
-				_m.ModelRoutingEnabled = value.Bool
-			}
-		case group.FieldMcpXMLInject:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field mcp_xml_inject", values[i])
-			} else if value.Valid {
-				_m.McpXMLInject = value.Bool
-			}
-		case group.FieldSupportedModelScopes:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field supported_model_scopes", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.SupportedModelScopes); err != nil {
-					return fmt.Errorf("unmarshal field supported_model_scopes: %w", err)
-				}
-			}
-		case group.FieldSortOrder:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field sort_order", values[i])
-			} else if value.Valid {
-				_m.SortOrder = int(value.Int64)
-			}
-		case group.FieldAllowMessagesDispatch:
-			if value, ok := values[i].(*sql.NullBool); !ok {
-				return fmt.Errorf("unexpected type %T for field allow_messages_dispatch", values[i])
-			} else if value.Valid {
-				_m.AllowMessagesDispatch = value.Bool
-			}
-		case group.FieldDefaultMappedModel:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field default_mapped_model", values[i])
-			} else if value.Valid {
-				_m.DefaultMappedModel = value.String
-			}
 		default:
 			_m.selectValues.Set(columns[i], values[i])
 		}
@@ -445,7 +285,7 @@ func (_m *Group) Value(name string) (ent.Value, error) {
 }
 
 // QueryAPIKeys queries the "api_keys" edge of the Group entity.
-func (_m *Group) QueryAPIKeys() *APIKeyQuery {
+func (_m *Group) QueryAPIKeys() *ApiKeyQuery {
 	return NewGroupClient(_m.config).QueryAPIKeys(_m)
 }
 
@@ -558,78 +398,6 @@ func (_m *Group) String() string {
 	builder.WriteString(", ")
 	builder.WriteString("default_validity_days=")
 	builder.WriteString(fmt.Sprintf("%v", _m.DefaultValidityDays))
-	builder.WriteString(", ")
-	if v := _m.ImagePrice1k; v != nil {
-		builder.WriteString("image_price_1k=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.ImagePrice2k; v != nil {
-		builder.WriteString("image_price_2k=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.ImagePrice4k; v != nil {
-		builder.WriteString("image_price_4k=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.SoraImagePrice360; v != nil {
-		builder.WriteString("sora_image_price_360=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.SoraImagePrice540; v != nil {
-		builder.WriteString("sora_image_price_540=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.SoraVideoPricePerRequest; v != nil {
-		builder.WriteString("sora_video_price_per_request=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.SoraVideoPricePerRequestHd; v != nil {
-		builder.WriteString("sora_video_price_per_request_hd=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("sora_storage_quota_bytes=")
-	builder.WriteString(fmt.Sprintf("%v", _m.SoraStorageQuotaBytes))
-	builder.WriteString(", ")
-	builder.WriteString("claude_code_only=")
-	builder.WriteString(fmt.Sprintf("%v", _m.ClaudeCodeOnly))
-	builder.WriteString(", ")
-	if v := _m.FallbackGroupID; v != nil {
-		builder.WriteString("fallback_group_id=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.FallbackGroupIDOnInvalidRequest; v != nil {
-		builder.WriteString("fallback_group_id_on_invalid_request=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("model_routing=")
-	builder.WriteString(fmt.Sprintf("%v", _m.ModelRouting))
-	builder.WriteString(", ")
-	builder.WriteString("model_routing_enabled=")
-	builder.WriteString(fmt.Sprintf("%v", _m.ModelRoutingEnabled))
-	builder.WriteString(", ")
-	builder.WriteString("mcp_xml_inject=")
-	builder.WriteString(fmt.Sprintf("%v", _m.McpXMLInject))
-	builder.WriteString(", ")
-	builder.WriteString("supported_model_scopes=")
-	builder.WriteString(fmt.Sprintf("%v", _m.SupportedModelScopes))
-	builder.WriteString(", ")
-	builder.WriteString("sort_order=")
-	builder.WriteString(fmt.Sprintf("%v", _m.SortOrder))
-	builder.WriteString(", ")
-	builder.WriteString("allow_messages_dispatch=")
-	builder.WriteString(fmt.Sprintf("%v", _m.AllowMessagesDispatch))
-	builder.WriteString(", ")
-	builder.WriteString("default_mapped_model=")
-	builder.WriteString(_m.DefaultMappedModel)
 	builder.WriteByte(')')
 	return builder.String()
 }

backend/ent/group/group.go

@@ -43,42 +43,6 @@ const (
 	FieldMonthlyLimitUsd = "monthly_limit_usd"
 	// FieldDefaultValidityDays holds the string denoting the default_validity_days field in the database.
 	FieldDefaultValidityDays = "default_validity_days"
-	// FieldImagePrice1k holds the string denoting the image_price_1k field in the database.
-	FieldImagePrice1k = "image_price_1k"
-	// FieldImagePrice2k holds the string denoting the image_price_2k field in the database.
-	FieldImagePrice2k = "image_price_2k"
-	// FieldImagePrice4k holds the string denoting the image_price_4k field in the database.
-	FieldImagePrice4k = "image_price_4k"
-	// FieldSoraImagePrice360 holds the string denoting the sora_image_price_360 field in the database.
-	FieldSoraImagePrice360 = "sora_image_price_360"
-	// FieldSoraImagePrice540 holds the string denoting the sora_image_price_540 field in the database.
-	FieldSoraImagePrice540 = "sora_image_price_540"
-	// FieldSoraVideoPricePerRequest holds the string denoting the sora_video_price_per_request field in the database.
-	FieldSoraVideoPricePerRequest = "sora_video_price_per_request"
-	// FieldSoraVideoPricePerRequestHd holds the string denoting the sora_video_price_per_request_hd field in the database.
-	FieldSoraVideoPricePerRequestHd = "sora_video_price_per_request_hd"
-	// FieldSoraStorageQuotaBytes holds the string denoting the sora_storage_quota_bytes field in the database.
-	FieldSoraStorageQuotaBytes = "sora_storage_quota_bytes"
-	// FieldClaudeCodeOnly holds the string denoting the claude_code_only field in the database.
-	FieldClaudeCodeOnly = "claude_code_only"
-	// FieldFallbackGroupID holds the string denoting the fallback_group_id field in the database.
-	FieldFallbackGroupID = "fallback_group_id"
-	// FieldFallbackGroupIDOnInvalidRequest holds the string denoting the fallback_group_id_on_invalid_request field in the database.
-	FieldFallbackGroupIDOnInvalidRequest = "fallback_group_id_on_invalid_request"
-	// FieldModelRouting holds the string denoting the model_routing field in the database.
-	FieldModelRouting = "model_routing"
-	// FieldModelRoutingEnabled holds the string denoting the model_routing_enabled field in the database.
-	FieldModelRoutingEnabled = "model_routing_enabled"
-	// FieldMcpXMLInject holds the string denoting the mcp_xml_inject field in the database.
-	FieldMcpXMLInject = "mcp_xml_inject"
-	// FieldSupportedModelScopes holds the string denoting the supported_model_scopes field in the database.
-	FieldSupportedModelScopes = "supported_model_scopes"
-	// FieldSortOrder holds the string denoting the sort_order field in the database.
-	FieldSortOrder = "sort_order"
-	// FieldAllowMessagesDispatch holds the string denoting the allow_messages_dispatch field in the database.
-	FieldAllowMessagesDispatch = "allow_messages_dispatch"
-	// FieldDefaultMappedModel holds the string denoting the default_mapped_model field in the database.
-	FieldDefaultMappedModel = "default_mapped_model"
 	// EdgeAPIKeys holds the string denoting the api_keys edge name in mutations.
 	EdgeAPIKeys = "api_keys"
 	// EdgeRedeemCodes holds the string denoting the redeem_codes edge name in mutations.
@@ -99,7 +63,7 @@ const (
 	Table = "groups"
 	// APIKeysTable is the table that holds the api_keys relation/edge.
 	APIKeysTable = "api_keys"
-	// APIKeysInverseTable is the table name for the APIKey entity.
+	// APIKeysInverseTable is the table name for the ApiKey entity.
 	// It exists in this package in order to avoid circular dependency with the "apikey" package.
 	APIKeysInverseTable = "api_keys"
 	// APIKeysColumn is the table column denoting the api_keys relation/edge.
@@ -168,24 +132,6 @@ var Columns = []string{
 	FieldWeeklyLimitUsd,
 	FieldMonthlyLimitUsd,
 	FieldDefaultValidityDays,
-	FieldImagePrice1k,
-	FieldImagePrice2k,
-	FieldImagePrice4k,
-	FieldSoraImagePrice360,
-	FieldSoraImagePrice540,
-	FieldSoraVideoPricePerRequest,
-	FieldSoraVideoPricePerRequestHd,
-	FieldSoraStorageQuotaBytes,
-	FieldClaudeCodeOnly,
-	FieldFallbackGroupID,
-	FieldFallbackGroupIDOnInvalidRequest,
-	FieldModelRouting,
-	FieldModelRoutingEnabled,
-	FieldMcpXMLInject,
-	FieldSupportedModelScopes,
-	FieldSortOrder,
-	FieldAllowMessagesDispatch,
-	FieldDefaultMappedModel,
 }
 
 var (
@@ -241,24 +187,6 @@ var (
 	SubscriptionTypeValidator func(string) error
 	// DefaultDefaultValidityDays holds the default value on creation for the "default_validity_days" field.
 	DefaultDefaultValidityDays int
-	// DefaultSoraStorageQuotaBytes holds the default value on creation for the "sora_storage_quota_bytes" field.
-	DefaultSoraStorageQuotaBytes int64
-	// DefaultClaudeCodeOnly holds the default value on creation for the "claude_code_only" field.
-	DefaultClaudeCodeOnly bool
-	// DefaultModelRoutingEnabled holds the default value on creation for the "model_routing_enabled" field.
-	DefaultModelRoutingEnabled bool
-	// DefaultMcpXMLInject holds the default value on creation for the "mcp_xml_inject" field.
-	DefaultMcpXMLInject bool
-	// DefaultSupportedModelScopes holds the default value on creation for the "supported_model_scopes" field.
-	DefaultSupportedModelScopes []string
-	// DefaultSortOrder holds the default value on creation for the "sort_order" field.
-	DefaultSortOrder int
-	// DefaultAllowMessagesDispatch holds the default value on creation for the "allow_messages_dispatch" field.
-	DefaultAllowMessagesDispatch bool
-	// DefaultDefaultMappedModel holds the default value on creation for the "default_mapped_model" field.
-	DefaultDefaultMappedModel string
-	// DefaultMappedModelValidator is a validator for the "default_mapped_model" field. It is called by the builders before save.
-	DefaultMappedModelValidator func(string) error
 )
 
 // OrderOption defines the ordering options for the Group queries.
@@ -339,86 +267,6 @@ func ByDefaultValidityDays(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldDefaultValidityDays, opts...).ToFunc()
 }
 
-// ByImagePrice1k orders the results by the image_price_1k field.
-func ByImagePrice1k(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldImagePrice1k, opts...).ToFunc()
-}
-
-// ByImagePrice2k orders the results by the image_price_2k field.
-func ByImagePrice2k(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldImagePrice2k, opts...).ToFunc()
-}
-
-// ByImagePrice4k orders the results by the image_price_4k field.
-func ByImagePrice4k(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldImagePrice4k, opts...).ToFunc()
-}
-
-// BySoraImagePrice360 orders the results by the sora_image_price_360 field.
-func BySoraImagePrice360(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSoraImagePrice360, opts...).ToFunc()
-}
-
-// BySoraImagePrice540 orders the results by the sora_image_price_540 field.
-func BySoraImagePrice540(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSoraImagePrice540, opts...).ToFunc()
-}
-
-// BySoraVideoPricePerRequest orders the results by the sora_video_price_per_request field.
-func BySoraVideoPricePerRequest(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSoraVideoPricePerRequest, opts...).ToFunc()
-}
-
-// BySoraVideoPricePerRequestHd orders the results by the sora_video_price_per_request_hd field.
-func BySoraVideoPricePerRequestHd(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSoraVideoPricePerRequestHd, opts...).ToFunc()
-}
-
-// BySoraStorageQuotaBytes orders the results by the sora_storage_quota_bytes field.
-func BySoraStorageQuotaBytes(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSoraStorageQuotaBytes, opts...).ToFunc()
-}
-
-// ByClaudeCodeOnly orders the results by the claude_code_only field.
-func ByClaudeCodeOnly(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldClaudeCodeOnly, opts...).ToFunc()
-}
-
-// ByFallbackGroupID orders the results by the fallback_group_id field.
-func ByFallbackGroupID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldFallbackGroupID, opts...).ToFunc()
-}
-
-// ByFallbackGroupIDOnInvalidRequest orders the results by the fallback_group_id_on_invalid_request field.
-func ByFallbackGroupIDOnInvalidRequest(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldFallbackGroupIDOnInvalidRequest, opts...).ToFunc()
-}
-
-// ByModelRoutingEnabled orders the results by the model_routing_enabled field.
-func ByModelRoutingEnabled(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldModelRoutingEnabled, opts...).ToFunc()
-}
-
-// ByMcpXMLInject orders the results by the mcp_xml_inject field.
-func ByMcpXMLInject(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldMcpXMLInject, opts...).ToFunc()
-}
-
-// BySortOrder orders the results by the sort_order field.
-func BySortOrder(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldSortOrder, opts...).ToFunc()
-}
-
-// ByAllowMessagesDispatch orders the results by the allow_messages_dispatch field.
-func ByAllowMessagesDispatch(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldAllowMessagesDispatch, opts...).ToFunc()
-}
-
-// ByDefaultMappedModel orders the results by the default_mapped_model field.
-func ByDefaultMappedModel(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldDefaultMappedModel, opts...).ToFunc()
-}
-
 // ByAPIKeysCount orders the results by api_keys count.
 func ByAPIKeysCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {

backend/ent/group/where.go

@@ -125,86 +125,6 @@ func DefaultValidityDays(v int) predicate.Group {
 	return predicate.Group(sql.FieldEQ(FieldDefaultValidityDays, v))
 }
 
-// ImagePrice1k applies equality check predicate on the "image_price_1k" field. It's identical to ImagePrice1kEQ.
-func ImagePrice1k(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldImagePrice1k, v))
-}
-
-// ImagePrice2k applies equality check predicate on the "image_price_2k" field. It's identical to ImagePrice2kEQ.
-func ImagePrice2k(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldImagePrice2k, v))
-}
-
-// ImagePrice4k applies equality check predicate on the "image_price_4k" field. It's identical to ImagePrice4kEQ.
-func ImagePrice4k(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldImagePrice4k, v))
-}
-
-// SoraImagePrice360 applies equality check predicate on the "sora_image_price_360" field. It's identical to SoraImagePrice360EQ.
-func SoraImagePrice360(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraImagePrice360, v))
-}
-
-// SoraImagePrice540 applies equality check predicate on the "sora_image_price_540" field. It's identical to SoraImagePrice540EQ.
-func SoraImagePrice540(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraImagePrice540, v))
-}
-
-// SoraVideoPricePerRequest applies equality check predicate on the "sora_video_price_per_request" field. It's identical to SoraVideoPricePerRequestEQ.
-func SoraVideoPricePerRequest(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraVideoPricePerRequest, v))
-}
-
-// SoraVideoPricePerRequestHd applies equality check predicate on the "sora_video_price_per_request_hd" field. It's identical to SoraVideoPricePerRequestHdEQ.
-func SoraVideoPricePerRequestHd(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraVideoPricePerRequestHd, v))
-}
-
-// SoraStorageQuotaBytes applies equality check predicate on the "sora_storage_quota_bytes" field. It's identical to SoraStorageQuotaBytesEQ.
-func SoraStorageQuotaBytes(v int64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraStorageQuotaBytes, v))
-}
-
-// ClaudeCodeOnly applies equality check predicate on the "claude_code_only" field. It's identical to ClaudeCodeOnlyEQ.
-func ClaudeCodeOnly(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldClaudeCodeOnly, v))
-}
-
-// FallbackGroupID applies equality check predicate on the "fallback_group_id" field. It's identical to FallbackGroupIDEQ.
-func FallbackGroupID(v int64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldFallbackGroupID, v))
-}
-
-// FallbackGroupIDOnInvalidRequest applies equality check predicate on the "fallback_group_id_on_invalid_request" field. It's identical to FallbackGroupIDOnInvalidRequestEQ.
-func FallbackGroupIDOnInvalidRequest(v int64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldFallbackGroupIDOnInvalidRequest, v))
-}
-
-// ModelRoutingEnabled applies equality check predicate on the "model_routing_enabled" field. It's identical to ModelRoutingEnabledEQ.
-func ModelRoutingEnabled(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldModelRoutingEnabled, v))
-}
-
-// McpXMLInject applies equality check predicate on the "mcp_xml_inject" field. It's identical to McpXMLInjectEQ.
-func McpXMLInject(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldMcpXMLInject, v))
-}
-
-// SortOrder applies equality check predicate on the "sort_order" field. It's identical to SortOrderEQ.
-func SortOrder(v int) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSortOrder, v))
-}
-
-// AllowMessagesDispatch applies equality check predicate on the "allow_messages_dispatch" field. It's identical to AllowMessagesDispatchEQ.
-func AllowMessagesDispatch(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldAllowMessagesDispatch, v))
-}
-
-// DefaultMappedModel applies equality check predicate on the "default_mapped_model" field. It's identical to DefaultMappedModelEQ.
-func DefaultMappedModel(v string) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldDefaultMappedModel, v))
-}
-
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v time.Time) predicate.Group {
 	return predicate.Group(sql.FieldEQ(FieldCreatedAt, v))
@@ -910,651 +830,6 @@ func DefaultValidityDaysLTE(v int) predicate.Group {
 	return predicate.Group(sql.FieldLTE(FieldDefaultValidityDays, v))
 }
 
-// ImagePrice1kEQ applies the EQ predicate on the "image_price_1k" field.
-func ImagePrice1kEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldImagePrice1k, v))
-}
-
-// ImagePrice1kNEQ applies the NEQ predicate on the "image_price_1k" field.
-func ImagePrice1kNEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldImagePrice1k, v))
-}
-
-// ImagePrice1kIn applies the In predicate on the "image_price_1k" field.
-func ImagePrice1kIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldImagePrice1k, vs...))
-}
-
-// ImagePrice1kNotIn applies the NotIn predicate on the "image_price_1k" field.
-func ImagePrice1kNotIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldImagePrice1k, vs...))
-}
-
-// ImagePrice1kGT applies the GT predicate on the "image_price_1k" field.
-func ImagePrice1kGT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldImagePrice1k, v))
-}
-
-// ImagePrice1kGTE applies the GTE predicate on the "image_price_1k" field.
-func ImagePrice1kGTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldImagePrice1k, v))
-}
-
-// ImagePrice1kLT applies the LT predicate on the "image_price_1k" field.
-func ImagePrice1kLT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldImagePrice1k, v))
-}
-
-// ImagePrice1kLTE applies the LTE predicate on the "image_price_1k" field.
-func ImagePrice1kLTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldImagePrice1k, v))
-}
-
-// ImagePrice1kIsNil applies the IsNil predicate on the "image_price_1k" field.
-func ImagePrice1kIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldImagePrice1k))
-}
-
-// ImagePrice1kNotNil applies the NotNil predicate on the "image_price_1k" field.
-func ImagePrice1kNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldImagePrice1k))
-}
-
-// ImagePrice2kEQ applies the EQ predicate on the "image_price_2k" field.
-func ImagePrice2kEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldImagePrice2k, v))
-}
-
-// ImagePrice2kNEQ applies the NEQ predicate on the "image_price_2k" field.
-func ImagePrice2kNEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldImagePrice2k, v))
-}
-
-// ImagePrice2kIn applies the In predicate on the "image_price_2k" field.
-func ImagePrice2kIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldImagePrice2k, vs...))
-}
-
-// ImagePrice2kNotIn applies the NotIn predicate on the "image_price_2k" field.
-func ImagePrice2kNotIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldImagePrice2k, vs...))
-}
-
-// ImagePrice2kGT applies the GT predicate on the "image_price_2k" field.
-func ImagePrice2kGT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldImagePrice2k, v))
-}
-
-// ImagePrice2kGTE applies the GTE predicate on the "image_price_2k" field.
-func ImagePrice2kGTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldImagePrice2k, v))
-}
-
-// ImagePrice2kLT applies the LT predicate on the "image_price_2k" field.
-func ImagePrice2kLT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldImagePrice2k, v))
-}
-
-// ImagePrice2kLTE applies the LTE predicate on the "image_price_2k" field.
-func ImagePrice2kLTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldImagePrice2k, v))
-}
-
-// ImagePrice2kIsNil applies the IsNil predicate on the "image_price_2k" field.
-func ImagePrice2kIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldImagePrice2k))
-}
-
-// ImagePrice2kNotNil applies the NotNil predicate on the "image_price_2k" field.
-func ImagePrice2kNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldImagePrice2k))
-}
-
-// ImagePrice4kEQ applies the EQ predicate on the "image_price_4k" field.
-func ImagePrice4kEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldImagePrice4k, v))
-}
-
-// ImagePrice4kNEQ applies the NEQ predicate on the "image_price_4k" field.
-func ImagePrice4kNEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldImagePrice4k, v))
-}
-
-// ImagePrice4kIn applies the In predicate on the "image_price_4k" field.
-func ImagePrice4kIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldImagePrice4k, vs...))
-}
-
-// ImagePrice4kNotIn applies the NotIn predicate on the "image_price_4k" field.
-func ImagePrice4kNotIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldImagePrice4k, vs...))
-}
-
-// ImagePrice4kGT applies the GT predicate on the "image_price_4k" field.
-func ImagePrice4kGT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldImagePrice4k, v))
-}
-
-// ImagePrice4kGTE applies the GTE predicate on the "image_price_4k" field.
-func ImagePrice4kGTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldImagePrice4k, v))
-}
-
-// ImagePrice4kLT applies the LT predicate on the "image_price_4k" field.
-func ImagePrice4kLT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldImagePrice4k, v))
-}
-
-// ImagePrice4kLTE applies the LTE predicate on the "image_price_4k" field.
-func ImagePrice4kLTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldImagePrice4k, v))
-}
-
-// ImagePrice4kIsNil applies the IsNil predicate on the "image_price_4k" field.
-func ImagePrice4kIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldImagePrice4k))
-}
-
-// ImagePrice4kNotNil applies the NotNil predicate on the "image_price_4k" field.
-func ImagePrice4kNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldImagePrice4k))
-}
-
-// SoraImagePrice360EQ applies the EQ predicate on the "sora_image_price_360" field.
-func SoraImagePrice360EQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraImagePrice360, v))
-}
-
-// SoraImagePrice360NEQ applies the NEQ predicate on the "sora_image_price_360" field.
-func SoraImagePrice360NEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldSoraImagePrice360, v))
-}
-
-// SoraImagePrice360In applies the In predicate on the "sora_image_price_360" field.
-func SoraImagePrice360In(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldSoraImagePrice360, vs...))
-}
-
-// SoraImagePrice360NotIn applies the NotIn predicate on the "sora_image_price_360" field.
-func SoraImagePrice360NotIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldSoraImagePrice360, vs...))
-}
-
-// SoraImagePrice360GT applies the GT predicate on the "sora_image_price_360" field.
-func SoraImagePrice360GT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldSoraImagePrice360, v))
-}
-
-// SoraImagePrice360GTE applies the GTE predicate on the "sora_image_price_360" field.
-func SoraImagePrice360GTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldSoraImagePrice360, v))
-}
-
-// SoraImagePrice360LT applies the LT predicate on the "sora_image_price_360" field.
-func SoraImagePrice360LT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldSoraImagePrice360, v))
-}
-
-// SoraImagePrice360LTE applies the LTE predicate on the "sora_image_price_360" field.
-func SoraImagePrice360LTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldSoraImagePrice360, v))
-}
-
-// SoraImagePrice360IsNil applies the IsNil predicate on the "sora_image_price_360" field.
-func SoraImagePrice360IsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldSoraImagePrice360))
-}
-
-// SoraImagePrice360NotNil applies the NotNil predicate on the "sora_image_price_360" field.
-func SoraImagePrice360NotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldSoraImagePrice360))
-}
-
-// SoraImagePrice540EQ applies the EQ predicate on the "sora_image_price_540" field.
-func SoraImagePrice540EQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraImagePrice540, v))
-}
-
-// SoraImagePrice540NEQ applies the NEQ predicate on the "sora_image_price_540" field.
-func SoraImagePrice540NEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldSoraImagePrice540, v))
-}
-
-// SoraImagePrice540In applies the In predicate on the "sora_image_price_540" field.
-func SoraImagePrice540In(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldSoraImagePrice540, vs...))
-}
-
-// SoraImagePrice540NotIn applies the NotIn predicate on the "sora_image_price_540" field.
-func SoraImagePrice540NotIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldSoraImagePrice540, vs...))
-}
-
-// SoraImagePrice540GT applies the GT predicate on the "sora_image_price_540" field.
-func SoraImagePrice540GT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldSoraImagePrice540, v))
-}
-
-// SoraImagePrice540GTE applies the GTE predicate on the "sora_image_price_540" field.
-func SoraImagePrice540GTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldSoraImagePrice540, v))
-}
-
-// SoraImagePrice540LT applies the LT predicate on the "sora_image_price_540" field.
-func SoraImagePrice540LT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldSoraImagePrice540, v))
-}
-
-// SoraImagePrice540LTE applies the LTE predicate on the "sora_image_price_540" field.
-func SoraImagePrice540LTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldSoraImagePrice540, v))
-}
-
-// SoraImagePrice540IsNil applies the IsNil predicate on the "sora_image_price_540" field.
-func SoraImagePrice540IsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldSoraImagePrice540))
-}
-
-// SoraImagePrice540NotNil applies the NotNil predicate on the "sora_image_price_540" field.
-func SoraImagePrice540NotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldSoraImagePrice540))
-}
-
-// SoraVideoPricePerRequestEQ applies the EQ predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraVideoPricePerRequest, v))
-}
-
-// SoraVideoPricePerRequestNEQ applies the NEQ predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestNEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldSoraVideoPricePerRequest, v))
-}
-
-// SoraVideoPricePerRequestIn applies the In predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldSoraVideoPricePerRequest, vs...))
-}
-
-// SoraVideoPricePerRequestNotIn applies the NotIn predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestNotIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldSoraVideoPricePerRequest, vs...))
-}
-
-// SoraVideoPricePerRequestGT applies the GT predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestGT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldSoraVideoPricePerRequest, v))
-}
-
-// SoraVideoPricePerRequestGTE applies the GTE predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestGTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldSoraVideoPricePerRequest, v))
-}
-
-// SoraVideoPricePerRequestLT applies the LT predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestLT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldSoraVideoPricePerRequest, v))
-}
-
-// SoraVideoPricePerRequestLTE applies the LTE predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestLTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldSoraVideoPricePerRequest, v))
-}
-
-// SoraVideoPricePerRequestIsNil applies the IsNil predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldSoraVideoPricePerRequest))
-}
-
-// SoraVideoPricePerRequestNotNil applies the NotNil predicate on the "sora_video_price_per_request" field.
-func SoraVideoPricePerRequestNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldSoraVideoPricePerRequest))
-}
-
-// SoraVideoPricePerRequestHdEQ applies the EQ predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraVideoPricePerRequestHd, v))
-}
-
-// SoraVideoPricePerRequestHdNEQ applies the NEQ predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdNEQ(v float64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldSoraVideoPricePerRequestHd, v))
-}
-
-// SoraVideoPricePerRequestHdIn applies the In predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldSoraVideoPricePerRequestHd, vs...))
-}
-
-// SoraVideoPricePerRequestHdNotIn applies the NotIn predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdNotIn(vs ...float64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldSoraVideoPricePerRequestHd, vs...))
-}
-
-// SoraVideoPricePerRequestHdGT applies the GT predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdGT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldSoraVideoPricePerRequestHd, v))
-}
-
-// SoraVideoPricePerRequestHdGTE applies the GTE predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdGTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldSoraVideoPricePerRequestHd, v))
-}
-
-// SoraVideoPricePerRequestHdLT applies the LT predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdLT(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldSoraVideoPricePerRequestHd, v))
-}
-
-// SoraVideoPricePerRequestHdLTE applies the LTE predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdLTE(v float64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldSoraVideoPricePerRequestHd, v))
-}
-
-// SoraVideoPricePerRequestHdIsNil applies the IsNil predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldSoraVideoPricePerRequestHd))
-}
-
-// SoraVideoPricePerRequestHdNotNil applies the NotNil predicate on the "sora_video_price_per_request_hd" field.
-func SoraVideoPricePerRequestHdNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldSoraVideoPricePerRequestHd))
-}
-
-// SoraStorageQuotaBytesEQ applies the EQ predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesEQ(v int64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSoraStorageQuotaBytes, v))
-}
-
-// SoraStorageQuotaBytesNEQ applies the NEQ predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesNEQ(v int64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldSoraStorageQuotaBytes, v))
-}
-
-// SoraStorageQuotaBytesIn applies the In predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesIn(vs ...int64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldSoraStorageQuotaBytes, vs...))
-}
-
-// SoraStorageQuotaBytesNotIn applies the NotIn predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesNotIn(vs ...int64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldSoraStorageQuotaBytes, vs...))
-}
-
-// SoraStorageQuotaBytesGT applies the GT predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesGT(v int64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldSoraStorageQuotaBytes, v))
-}
-
-// SoraStorageQuotaBytesGTE applies the GTE predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesGTE(v int64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldSoraStorageQuotaBytes, v))
-}
-
-// SoraStorageQuotaBytesLT applies the LT predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesLT(v int64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldSoraStorageQuotaBytes, v))
-}
-
-// SoraStorageQuotaBytesLTE applies the LTE predicate on the "sora_storage_quota_bytes" field.
-func SoraStorageQuotaBytesLTE(v int64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldSoraStorageQuotaBytes, v))
-}
-
-// ClaudeCodeOnlyEQ applies the EQ predicate on the "claude_code_only" field.
-func ClaudeCodeOnlyEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldClaudeCodeOnly, v))
-}
-
-// ClaudeCodeOnlyNEQ applies the NEQ predicate on the "claude_code_only" field.
-func ClaudeCodeOnlyNEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldClaudeCodeOnly, v))
-}
-
-// FallbackGroupIDEQ applies the EQ predicate on the "fallback_group_id" field.
-func FallbackGroupIDEQ(v int64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldFallbackGroupID, v))
-}
-
-// FallbackGroupIDNEQ applies the NEQ predicate on the "fallback_group_id" field.
-func FallbackGroupIDNEQ(v int64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldFallbackGroupID, v))
-}
-
-// FallbackGroupIDIn applies the In predicate on the "fallback_group_id" field.
-func FallbackGroupIDIn(vs ...int64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldFallbackGroupID, vs...))
-}
-
-// FallbackGroupIDNotIn applies the NotIn predicate on the "fallback_group_id" field.
-func FallbackGroupIDNotIn(vs ...int64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldFallbackGroupID, vs...))
-}
-
-// FallbackGroupIDGT applies the GT predicate on the "fallback_group_id" field.
-func FallbackGroupIDGT(v int64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldFallbackGroupID, v))
-}
-
-// FallbackGroupIDGTE applies the GTE predicate on the "fallback_group_id" field.
-func FallbackGroupIDGTE(v int64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldFallbackGroupID, v))
-}
-
-// FallbackGroupIDLT applies the LT predicate on the "fallback_group_id" field.
-func FallbackGroupIDLT(v int64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldFallbackGroupID, v))
-}
-
-// FallbackGroupIDLTE applies the LTE predicate on the "fallback_group_id" field.
-func FallbackGroupIDLTE(v int64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldFallbackGroupID, v))
-}
-
-// FallbackGroupIDIsNil applies the IsNil predicate on the "fallback_group_id" field.
-func FallbackGroupIDIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldFallbackGroupID))
-}
-
-// FallbackGroupIDNotNil applies the NotNil predicate on the "fallback_group_id" field.
-func FallbackGroupIDNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldFallbackGroupID))
-}
-
-// FallbackGroupIDOnInvalidRequestEQ applies the EQ predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestEQ(v int64) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldFallbackGroupIDOnInvalidRequest, v))
-}
-
-// FallbackGroupIDOnInvalidRequestNEQ applies the NEQ predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestNEQ(v int64) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldFallbackGroupIDOnInvalidRequest, v))
-}
-
-// FallbackGroupIDOnInvalidRequestIn applies the In predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestIn(vs ...int64) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldFallbackGroupIDOnInvalidRequest, vs...))
-}
-
-// FallbackGroupIDOnInvalidRequestNotIn applies the NotIn predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestNotIn(vs ...int64) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldFallbackGroupIDOnInvalidRequest, vs...))
-}
-
-// FallbackGroupIDOnInvalidRequestGT applies the GT predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestGT(v int64) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldFallbackGroupIDOnInvalidRequest, v))
-}
-
-// FallbackGroupIDOnInvalidRequestGTE applies the GTE predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestGTE(v int64) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldFallbackGroupIDOnInvalidRequest, v))
-}
-
-// FallbackGroupIDOnInvalidRequestLT applies the LT predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestLT(v int64) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldFallbackGroupIDOnInvalidRequest, v))
-}
-
-// FallbackGroupIDOnInvalidRequestLTE applies the LTE predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestLTE(v int64) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldFallbackGroupIDOnInvalidRequest, v))
-}
-
-// FallbackGroupIDOnInvalidRequestIsNil applies the IsNil predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldFallbackGroupIDOnInvalidRequest))
-}
-
-// FallbackGroupIDOnInvalidRequestNotNil applies the NotNil predicate on the "fallback_group_id_on_invalid_request" field.
-func FallbackGroupIDOnInvalidRequestNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldFallbackGroupIDOnInvalidRequest))
-}
-
-// ModelRoutingIsNil applies the IsNil predicate on the "model_routing" field.
-func ModelRoutingIsNil() predicate.Group {
-	return predicate.Group(sql.FieldIsNull(FieldModelRouting))
-}
-
-// ModelRoutingNotNil applies the NotNil predicate on the "model_routing" field.
-func ModelRoutingNotNil() predicate.Group {
-	return predicate.Group(sql.FieldNotNull(FieldModelRouting))
-}
-
-// ModelRoutingEnabledEQ applies the EQ predicate on the "model_routing_enabled" field.
-func ModelRoutingEnabledEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldModelRoutingEnabled, v))
-}
-
-// ModelRoutingEnabledNEQ applies the NEQ predicate on the "model_routing_enabled" field.
-func ModelRoutingEnabledNEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldModelRoutingEnabled, v))
-}
-
-// McpXMLInjectEQ applies the EQ predicate on the "mcp_xml_inject" field.
-func McpXMLInjectEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldMcpXMLInject, v))
-}
-
-// McpXMLInjectNEQ applies the NEQ predicate on the "mcp_xml_inject" field.
-func McpXMLInjectNEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldMcpXMLInject, v))
-}
-
-// SortOrderEQ applies the EQ predicate on the "sort_order" field.
-func SortOrderEQ(v int) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldSortOrder, v))
-}
-
-// SortOrderNEQ applies the NEQ predicate on the "sort_order" field.
-func SortOrderNEQ(v int) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldSortOrder, v))
-}
-
-// SortOrderIn applies the In predicate on the "sort_order" field.
-func SortOrderIn(vs ...int) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldSortOrder, vs...))
-}
-
-// SortOrderNotIn applies the NotIn predicate on the "sort_order" field.
-func SortOrderNotIn(vs ...int) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldSortOrder, vs...))
-}
-
-// SortOrderGT applies the GT predicate on the "sort_order" field.
-func SortOrderGT(v int) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldSortOrder, v))
-}
-
-// SortOrderGTE applies the GTE predicate on the "sort_order" field.
-func SortOrderGTE(v int) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldSortOrder, v))
-}
-
-// SortOrderLT applies the LT predicate on the "sort_order" field.
-func SortOrderLT(v int) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldSortOrder, v))
-}
-
-// SortOrderLTE applies the LTE predicate on the "sort_order" field.
-func SortOrderLTE(v int) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldSortOrder, v))
-}
-
-// AllowMessagesDispatchEQ applies the EQ predicate on the "allow_messages_dispatch" field.
-func AllowMessagesDispatchEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldAllowMessagesDispatch, v))
-}
-
-// AllowMessagesDispatchNEQ applies the NEQ predicate on the "allow_messages_dispatch" field.
-func AllowMessagesDispatchNEQ(v bool) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldAllowMessagesDispatch, v))
-}
-
-// DefaultMappedModelEQ applies the EQ predicate on the "default_mapped_model" field.
-func DefaultMappedModelEQ(v string) predicate.Group {
-	return predicate.Group(sql.FieldEQ(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelNEQ applies the NEQ predicate on the "default_mapped_model" field.
-func DefaultMappedModelNEQ(v string) predicate.Group {
-	return predicate.Group(sql.FieldNEQ(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelIn applies the In predicate on the "default_mapped_model" field.
-func DefaultMappedModelIn(vs ...string) predicate.Group {
-	return predicate.Group(sql.FieldIn(FieldDefaultMappedModel, vs...))
-}
-
-// DefaultMappedModelNotIn applies the NotIn predicate on the "default_mapped_model" field.
-func DefaultMappedModelNotIn(vs ...string) predicate.Group {
-	return predicate.Group(sql.FieldNotIn(FieldDefaultMappedModel, vs...))
-}
-
-// DefaultMappedModelGT applies the GT predicate on the "default_mapped_model" field.
-func DefaultMappedModelGT(v string) predicate.Group {
-	return predicate.Group(sql.FieldGT(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelGTE applies the GTE predicate on the "default_mapped_model" field.
-func DefaultMappedModelGTE(v string) predicate.Group {
-	return predicate.Group(sql.FieldGTE(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelLT applies the LT predicate on the "default_mapped_model" field.
-func DefaultMappedModelLT(v string) predicate.Group {
-	return predicate.Group(sql.FieldLT(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelLTE applies the LTE predicate on the "default_mapped_model" field.
-func DefaultMappedModelLTE(v string) predicate.Group {
-	return predicate.Group(sql.FieldLTE(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelContains applies the Contains predicate on the "default_mapped_model" field.
-func DefaultMappedModelContains(v string) predicate.Group {
-	return predicate.Group(sql.FieldContains(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelHasPrefix applies the HasPrefix predicate on the "default_mapped_model" field.
-func DefaultMappedModelHasPrefix(v string) predicate.Group {
-	return predicate.Group(sql.FieldHasPrefix(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelHasSuffix applies the HasSuffix predicate on the "default_mapped_model" field.
-func DefaultMappedModelHasSuffix(v string) predicate.Group {
-	return predicate.Group(sql.FieldHasSuffix(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelEqualFold applies the EqualFold predicate on the "default_mapped_model" field.
-func DefaultMappedModelEqualFold(v string) predicate.Group {
-	return predicate.Group(sql.FieldEqualFold(FieldDefaultMappedModel, v))
-}
-
-// DefaultMappedModelContainsFold applies the ContainsFold predicate on the "default_mapped_model" field.
-func DefaultMappedModelContainsFold(v string) predicate.Group {
-	return predicate.Group(sql.FieldContainsFold(FieldDefaultMappedModel, v))
-}
-
 // HasAPIKeys applies the HasEdge predicate on the "api_keys" edge.
 func HasAPIKeys() predicate.Group {
 	return predicate.Group(func(s *sql.Selector) {
@@ -1567,7 +842,7 @@ func HasAPIKeys() predicate.Group {
 }
 
 // HasAPIKeysWith applies the HasEdge predicate on the "api_keys" edge with a given conditions (other predicates).
-func HasAPIKeysWith(preds ...predicate.APIKey) predicate.Group {
+func HasAPIKeysWith(preds ...predicate.ApiKey) predicate.Group {
 	return predicate.Group(func(s *sql.Selector) {
 		step := newAPIKeysStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {

backend/ent/group_query.go

@@ -9,7 +9,6 @@ import (
 	"math"
 
 	"entgo.io/ent"
-	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -32,7 +31,7 @@ type GroupQuery struct {
 	order                 []group.OrderOption
 	inters                []Interceptor
 	predicates            []predicate.Group
-	withAPIKeys           *APIKeyQuery
+	withAPIKeys           *ApiKeyQuery
 	withRedeemCodes       *RedeemCodeQuery
 	withSubscriptions     *UserSubscriptionQuery
 	withUsageLogs         *UsageLogQuery
@@ -40,7 +39,6 @@ type GroupQuery struct {
 	withAllowedUsers      *UserQuery
 	withAccountGroups     *AccountGroupQuery
 	withUserAllowedGroups *UserAllowedGroupQuery
-	modifiers             []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -78,8 +76,8 @@ func (_q *GroupQuery) Order(o ...group.OrderOption) *GroupQuery {
 }
 
 // QueryAPIKeys chains the current query on the "api_keys" edge.
-func (_q *GroupQuery) QueryAPIKeys() *APIKeyQuery {
-	query := (&APIKeyClient{config: _q.config}).Query()
+func (_q *GroupQuery) QueryAPIKeys() *ApiKeyQuery {
+	query := (&ApiKeyClient{config: _q.config}).Query()
 	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
 		if err := _q.prepareQuery(ctx); err != nil {
 			return nil, err
@@ -461,8 +459,8 @@ func (_q *GroupQuery) Clone() *GroupQuery {
 
 // WithAPIKeys tells the query-builder to eager-load the nodes that are connected to
 // the "api_keys" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *GroupQuery) WithAPIKeys(opts ...func(*APIKeyQuery)) *GroupQuery {
-	query := (&APIKeyClient{config: _q.config}).Query()
+func (_q *GroupQuery) WithAPIKeys(opts ...func(*ApiKeyQuery)) *GroupQuery {
+	query := (&ApiKeyClient{config: _q.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -645,9 +643,6 @@ func (_q *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group,
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -659,8 +654,8 @@ func (_q *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group,
 	}
 	if query := _q.withAPIKeys; query != nil {
 		if err := _q.loadAPIKeys(ctx, query, nodes,
-			func(n *Group) { n.Edges.APIKeys = []*APIKey{} },
-			func(n *Group, e *APIKey) { n.Edges.APIKeys = append(n.Edges.APIKeys, e) }); err != nil {
+			func(n *Group) { n.Edges.APIKeys = []*ApiKey{} },
+			func(n *Group, e *ApiKey) { n.Edges.APIKeys = append(n.Edges.APIKeys, e) }); err != nil {
 			return nil, err
 		}
 	}
@@ -716,7 +711,7 @@ func (_q *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group,
 	return nodes, nil
 }
 
-func (_q *GroupQuery) loadAPIKeys(ctx context.Context, query *APIKeyQuery, nodes []*Group, init func(*Group), assign func(*Group, *APIKey)) error {
+func (_q *GroupQuery) loadAPIKeys(ctx context.Context, query *ApiKeyQuery, nodes []*Group, init func(*Group), assign func(*Group, *ApiKey)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[int64]*Group)
 	for i := range nodes {
@@ -729,7 +724,7 @@ func (_q *GroupQuery) loadAPIKeys(ctx context.Context, query *APIKeyQuery, nodes
 	if len(query.ctx.Fields) > 0 {
 		query.ctx.AppendFieldOnce(apikey.FieldGroupID)
 	}
-	query.Where(predicate.APIKey(func(s *sql.Selector) {
+	query.Where(predicate.ApiKey(func(s *sql.Selector) {
 		s.Where(sql.InValues(s.C(group.APIKeysColumn), fks...))
 	}))
 	neighbors, err := query.All(ctx)
@@ -1030,9 +1025,6 @@ func (_q *GroupQuery) loadUserAllowedGroups(ctx context.Context, query *UserAllo
 
 func (_q *GroupQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	_spec.Node.Columns = _q.ctx.Fields
 	if len(_q.ctx.Fields) > 0 {
 		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
@@ -1095,9 +1087,6 @@ func (_q *GroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if _q.ctx.Unique != nil && *_q.ctx.Unique {
 		selector.Distinct()
 	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
 	for _, p := range _q.predicates {
 		p(selector)
 	}
@@ -1115,32 +1104,6 @@ func (_q *GroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *GroupQuery) ForUpdate(opts ...sql.LockOption) *GroupQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *GroupQuery) ForShare(opts ...sql.LockOption) *GroupQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // GroupGroupBy is the group-by builder for Group entities.
 type GroupGroupBy struct {
 	selector

backend/ent/hook/hook.go

@@ -9,18 +9,6 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent"
 )
 
-// The APIKeyFunc type is an adapter to allow the use of ordinary
-// function as APIKey mutator.
-type APIKeyFunc func(context.Context, *ent.APIKeyMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f APIKeyFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.APIKeyMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.APIKeyMutation", m)
-}
-
 // The AccountFunc type is an adapter to allow the use of ordinary
 // function as Account mutator.
 type AccountFunc func(context.Context, *ent.AccountMutation) (ent.Value, error)
@@ -45,40 +33,16 @@ func (f AccountGroupFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AccountGroupMutation", m)
 }
 
-// The AnnouncementFunc type is an adapter to allow the use of ordinary
-// function as Announcement mutator.
-type AnnouncementFunc func(context.Context, *ent.AnnouncementMutation) (ent.Value, error)
+// The ApiKeyFunc type is an adapter to allow the use of ordinary
+// function as ApiKey mutator.
+type ApiKeyFunc func(context.Context, *ent.ApiKeyMutation) (ent.Value, error)
 
 // Mutate calls f(ctx, m).
-func (f AnnouncementFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.AnnouncementMutation); ok {
+func (f ApiKeyFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.ApiKeyMutation); ok {
 		return f(ctx, mv)
 	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AnnouncementMutation", m)
-}
-
-// The AnnouncementReadFunc type is an adapter to allow the use of ordinary
-// function as AnnouncementRead mutator.
-type AnnouncementReadFunc func(context.Context, *ent.AnnouncementReadMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f AnnouncementReadFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.AnnouncementReadMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AnnouncementReadMutation", m)
-}
-
-// The ErrorPassthroughRuleFunc type is an adapter to allow the use of ordinary
-// function as ErrorPassthroughRule mutator.
-type ErrorPassthroughRuleFunc func(context.Context, *ent.ErrorPassthroughRuleMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f ErrorPassthroughRuleFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.ErrorPassthroughRuleMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ErrorPassthroughRuleMutation", m)
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ApiKeyMutation", m)
 }
 
 // The GroupFunc type is an adapter to allow the use of ordinary
@@ -93,42 +57,6 @@ func (f GroupFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.GroupMutation", m)
 }
 
-// The IdempotencyRecordFunc type is an adapter to allow the use of ordinary
-// function as IdempotencyRecord mutator.
-type IdempotencyRecordFunc func(context.Context, *ent.IdempotencyRecordMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f IdempotencyRecordFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.IdempotencyRecordMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.IdempotencyRecordMutation", m)
-}
-
-// The PromoCodeFunc type is an adapter to allow the use of ordinary
-// function as PromoCode mutator.
-type PromoCodeFunc func(context.Context, *ent.PromoCodeMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f PromoCodeFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.PromoCodeMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.PromoCodeMutation", m)
-}
-
-// The PromoCodeUsageFunc type is an adapter to allow the use of ordinary
-// function as PromoCodeUsage mutator.
-type PromoCodeUsageFunc func(context.Context, *ent.PromoCodeUsageMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f PromoCodeUsageFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.PromoCodeUsageMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.PromoCodeUsageMutation", m)
-}
-
 // The ProxyFunc type is an adapter to allow the use of ordinary
 // function as Proxy mutator.
 type ProxyFunc func(context.Context, *ent.ProxyMutation) (ent.Value, error)
@@ -153,18 +81,6 @@ func (f RedeemCodeFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value,
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.RedeemCodeMutation", m)
 }
 
-// The SecuritySecretFunc type is an adapter to allow the use of ordinary
-// function as SecuritySecret mutator.
-type SecuritySecretFunc func(context.Context, *ent.SecuritySecretMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f SecuritySecretFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.SecuritySecretMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SecuritySecretMutation", m)
-}
-
 // The SettingFunc type is an adapter to allow the use of ordinary
 // function as Setting mutator.
 type SettingFunc func(context.Context, *ent.SettingMutation) (ent.Value, error)
@@ -177,18 +93,6 @@ func (f SettingFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, err
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SettingMutation", m)
 }
 
-// The UsageCleanupTaskFunc type is an adapter to allow the use of ordinary
-// function as UsageCleanupTask mutator.
-type UsageCleanupTaskFunc func(context.Context, *ent.UsageCleanupTaskMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f UsageCleanupTaskFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.UsageCleanupTaskMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UsageCleanupTaskMutation", m)
-}
-
 // The UsageLogFunc type is an adapter to allow the use of ordinary
 // function as UsageLog mutator.
 type UsageLogFunc func(context.Context, *ent.UsageLogMutation) (ent.Value, error)
@@ -225,30 +129,6 @@ func (f UserAllowedGroupFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.V
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserAllowedGroupMutation", m)
 }
 
-// The UserAttributeDefinitionFunc type is an adapter to allow the use of ordinary
-// function as UserAttributeDefinition mutator.
-type UserAttributeDefinitionFunc func(context.Context, *ent.UserAttributeDefinitionMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f UserAttributeDefinitionFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.UserAttributeDefinitionMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserAttributeDefinitionMutation", m)
-}
-
-// The UserAttributeValueFunc type is an adapter to allow the use of ordinary
-// function as UserAttributeValue mutator.
-type UserAttributeValueFunc func(context.Context, *ent.UserAttributeValueMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f UserAttributeValueFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.UserAttributeValueMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserAttributeValueMutation", m)
-}
-
 // The UserSubscriptionFunc type is an adapter to allow the use of ordinary
 // function as UserSubscription mutator.
 type UserSubscriptionFunc func(context.Context, *ent.UserSubscriptionMutation) (ent.Value, error)

backend/ent/idempotencyrecord.go

@@ -1,228 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/idempotencyrecord"
-)
-
-// IdempotencyRecord is the model entity for the IdempotencyRecord schema.
-type IdempotencyRecord struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int64 `json:"id,omitempty"`
-	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt time.Time `json:"updated_at,omitempty"`
-	// Scope holds the value of the "scope" field.
-	Scope string `json:"scope,omitempty"`
-	// IdempotencyKeyHash holds the value of the "idempotency_key_hash" field.
-	IdempotencyKeyHash string `json:"idempotency_key_hash,omitempty"`
-	// RequestFingerprint holds the value of the "request_fingerprint" field.
-	RequestFingerprint string `json:"request_fingerprint,omitempty"`
-	// Status holds the value of the "status" field.
-	Status string `json:"status,omitempty"`
-	// ResponseStatus holds the value of the "response_status" field.
-	ResponseStatus *int `json:"response_status,omitempty"`
-	// ResponseBody holds the value of the "response_body" field.
-	ResponseBody *string `json:"response_body,omitempty"`
-	// ErrorReason holds the value of the "error_reason" field.
-	ErrorReason *string `json:"error_reason,omitempty"`
-	// LockedUntil holds the value of the "locked_until" field.
-	LockedUntil *time.Time `json:"locked_until,omitempty"`
-	// ExpiresAt holds the value of the "expires_at" field.
-	ExpiresAt    time.Time `json:"expires_at,omitempty"`
-	selectValues sql.SelectValues
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*IdempotencyRecord) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case idempotencyrecord.FieldID, idempotencyrecord.FieldResponseStatus:
-			values[i] = new(sql.NullInt64)
-		case idempotencyrecord.FieldScope, idempotencyrecord.FieldIdempotencyKeyHash, idempotencyrecord.FieldRequestFingerprint, idempotencyrecord.FieldStatus, idempotencyrecord.FieldResponseBody, idempotencyrecord.FieldErrorReason:
-			values[i] = new(sql.NullString)
-		case idempotencyrecord.FieldCreatedAt, idempotencyrecord.FieldUpdatedAt, idempotencyrecord.FieldLockedUntil, idempotencyrecord.FieldExpiresAt:
-			values[i] = new(sql.NullTime)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the IdempotencyRecord fields.
-func (_m *IdempotencyRecord) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case idempotencyrecord.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			_m.ID = int64(value.Int64)
-		case idempotencyrecord.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field created_at", values[i])
-			} else if value.Valid {
-				_m.CreatedAt = value.Time
-			}
-		case idempotencyrecord.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
-			} else if value.Valid {
-				_m.UpdatedAt = value.Time
-			}
-		case idempotencyrecord.FieldScope:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field scope", values[i])
-			} else if value.Valid {
-				_m.Scope = value.String
-			}
-		case idempotencyrecord.FieldIdempotencyKeyHash:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field idempotency_key_hash", values[i])
-			} else if value.Valid {
-				_m.IdempotencyKeyHash = value.String
-			}
-		case idempotencyrecord.FieldRequestFingerprint:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field request_fingerprint", values[i])
-			} else if value.Valid {
-				_m.RequestFingerprint = value.String
-			}
-		case idempotencyrecord.FieldStatus:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field status", values[i])
-			} else if value.Valid {
-				_m.Status = value.String
-			}
-		case idempotencyrecord.FieldResponseStatus:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field response_status", values[i])
-			} else if value.Valid {
-				_m.ResponseStatus = new(int)
-				*_m.ResponseStatus = int(value.Int64)
-			}
-		case idempotencyrecord.FieldResponseBody:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field response_body", values[i])
-			} else if value.Valid {
-				_m.ResponseBody = new(string)
-				*_m.ResponseBody = value.String
-			}
-		case idempotencyrecord.FieldErrorReason:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field error_reason", values[i])
-			} else if value.Valid {
-				_m.ErrorReason = new(string)
-				*_m.ErrorReason = value.String
-			}
-		case idempotencyrecord.FieldLockedUntil:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field locked_until", values[i])
-			} else if value.Valid {
-				_m.LockedUntil = new(time.Time)
-				*_m.LockedUntil = value.Time
-			}
-		case idempotencyrecord.FieldExpiresAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
-			} else if value.Valid {
-				_m.ExpiresAt = value.Time
-			}
-		default:
-			_m.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the IdempotencyRecord.
-// This includes values selected through modifiers, order, etc.
-func (_m *IdempotencyRecord) Value(name string) (ent.Value, error) {
-	return _m.selectValues.Get(name)
-}
-
-// Update returns a builder for updating this IdempotencyRecord.
-// Note that you need to call IdempotencyRecord.Unwrap() before calling this method if this IdempotencyRecord
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *IdempotencyRecord) Update() *IdempotencyRecordUpdateOne {
-	return NewIdempotencyRecordClient(_m.config).UpdateOne(_m)
-}
-
-// Unwrap unwraps the IdempotencyRecord entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (_m *IdempotencyRecord) Unwrap() *IdempotencyRecord {
-	_tx, ok := _m.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: IdempotencyRecord is not a transactional entity")
-	}
-	_m.config.driver = _tx.drv
-	return _m
-}
-
-// String implements the fmt.Stringer.
-func (_m *IdempotencyRecord) String() string {
-	var builder strings.Builder
-	builder.WriteString("IdempotencyRecord(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
-	builder.WriteString("created_at=")
-	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("updated_at=")
-	builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("scope=")
-	builder.WriteString(_m.Scope)
-	builder.WriteString(", ")
-	builder.WriteString("idempotency_key_hash=")
-	builder.WriteString(_m.IdempotencyKeyHash)
-	builder.WriteString(", ")
-	builder.WriteString("request_fingerprint=")
-	builder.WriteString(_m.RequestFingerprint)
-	builder.WriteString(", ")
-	builder.WriteString("status=")
-	builder.WriteString(_m.Status)
-	builder.WriteString(", ")
-	if v := _m.ResponseStatus; v != nil {
-		builder.WriteString("response_status=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.ResponseBody; v != nil {
-		builder.WriteString("response_body=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
-	if v := _m.ErrorReason; v != nil {
-		builder.WriteString("error_reason=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
-	if v := _m.LockedUntil; v != nil {
-		builder.WriteString("locked_until=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	builder.WriteString("expires_at=")
-	builder.WriteString(_m.ExpiresAt.Format(time.ANSIC))
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// IdempotencyRecords is a parsable slice of IdempotencyRecord.
-type IdempotencyRecords []*IdempotencyRecord

backend/ent/idempotencyrecord/idempotencyrecord.go

@@ -1,148 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package idempotencyrecord
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-)
-
-const (
-	// Label holds the string label denoting the idempotencyrecord type in the database.
-	Label = "idempotency_record"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldCreatedAt holds the string denoting the created_at field in the database.
-	FieldCreatedAt = "created_at"
-	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
-	FieldUpdatedAt = "updated_at"
-	// FieldScope holds the string denoting the scope field in the database.
-	FieldScope = "scope"
-	// FieldIdempotencyKeyHash holds the string denoting the idempotency_key_hash field in the database.
-	FieldIdempotencyKeyHash = "idempotency_key_hash"
-	// FieldRequestFingerprint holds the string denoting the request_fingerprint field in the database.
-	FieldRequestFingerprint = "request_fingerprint"
-	// FieldStatus holds the string denoting the status field in the database.
-	FieldStatus = "status"
-	// FieldResponseStatus holds the string denoting the response_status field in the database.
-	FieldResponseStatus = "response_status"
-	// FieldResponseBody holds the string denoting the response_body field in the database.
-	FieldResponseBody = "response_body"
-	// FieldErrorReason holds the string denoting the error_reason field in the database.
-	FieldErrorReason = "error_reason"
-	// FieldLockedUntil holds the string denoting the locked_until field in the database.
-	FieldLockedUntil = "locked_until"
-	// FieldExpiresAt holds the string denoting the expires_at field in the database.
-	FieldExpiresAt = "expires_at"
-	// Table holds the table name of the idempotencyrecord in the database.
-	Table = "idempotency_records"
-)
-
-// Columns holds all SQL columns for idempotencyrecord fields.
-var Columns = []string{
-	FieldID,
-	FieldCreatedAt,
-	FieldUpdatedAt,
-	FieldScope,
-	FieldIdempotencyKeyHash,
-	FieldRequestFingerprint,
-	FieldStatus,
-	FieldResponseStatus,
-	FieldResponseBody,
-	FieldErrorReason,
-	FieldLockedUntil,
-	FieldExpiresAt,
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() time.Time
-	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() time.Time
-	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() time.Time
-	// ScopeValidator is a validator for the "scope" field. It is called by the builders before save.
-	ScopeValidator func(string) error
-	// IdempotencyKeyHashValidator is a validator for the "idempotency_key_hash" field. It is called by the builders before save.
-	IdempotencyKeyHashValidator func(string) error
-	// RequestFingerprintValidator is a validator for the "request_fingerprint" field. It is called by the builders before save.
-	RequestFingerprintValidator func(string) error
-	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	StatusValidator func(string) error
-	// ErrorReasonValidator is a validator for the "error_reason" field. It is called by the builders before save.
-	ErrorReasonValidator func(string) error
-)
-
-// OrderOption defines the ordering options for the IdempotencyRecord queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByCreatedAt orders the results by the created_at field.
-func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
-}
-
-// ByUpdatedAt orders the results by the updated_at field.
-func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
-}
-
-// ByScope orders the results by the scope field.
-func ByScope(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldScope, opts...).ToFunc()
-}
-
-// ByIdempotencyKeyHash orders the results by the idempotency_key_hash field.
-func ByIdempotencyKeyHash(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldIdempotencyKeyHash, opts...).ToFunc()
-}
-
-// ByRequestFingerprint orders the results by the request_fingerprint field.
-func ByRequestFingerprint(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldRequestFingerprint, opts...).ToFunc()
-}
-
-// ByStatus orders the results by the status field.
-func ByStatus(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldStatus, opts...).ToFunc()
-}
-
-// ByResponseStatus orders the results by the response_status field.
-func ByResponseStatus(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldResponseStatus, opts...).ToFunc()
-}
-
-// ByResponseBody orders the results by the response_body field.
-func ByResponseBody(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldResponseBody, opts...).ToFunc()
-}
-
-// ByErrorReason orders the results by the error_reason field.
-func ByErrorReason(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldErrorReason, opts...).ToFunc()
-}
-
-// ByLockedUntil orders the results by the locked_until field.
-func ByLockedUntil(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldLockedUntil, opts...).ToFunc()
-}
-
-// ByExpiresAt orders the results by the expires_at field.
-func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
-}

backend/ent/idempotencyrecord/where.go

@@ -1,755 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package idempotencyrecord
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldID, id))
-}
-
-// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// Scope applies equality check predicate on the "scope" field. It's identical to ScopeEQ.
-func Scope(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldScope, v))
-}
-
-// IdempotencyKeyHash applies equality check predicate on the "idempotency_key_hash" field. It's identical to IdempotencyKeyHashEQ.
-func IdempotencyKeyHash(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldIdempotencyKeyHash, v))
-}
-
-// RequestFingerprint applies equality check predicate on the "request_fingerprint" field. It's identical to RequestFingerprintEQ.
-func RequestFingerprint(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldRequestFingerprint, v))
-}
-
-// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
-func Status(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldStatus, v))
-}
-
-// ResponseStatus applies equality check predicate on the "response_status" field. It's identical to ResponseStatusEQ.
-func ResponseStatus(v int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldResponseStatus, v))
-}
-
-// ResponseBody applies equality check predicate on the "response_body" field. It's identical to ResponseBodyEQ.
-func ResponseBody(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldResponseBody, v))
-}
-
-// ErrorReason applies equality check predicate on the "error_reason" field. It's identical to ErrorReasonEQ.
-func ErrorReason(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldErrorReason, v))
-}
-
-// LockedUntil applies equality check predicate on the "locked_until" field. It's identical to LockedUntilEQ.
-func LockedUntil(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldLockedUntil, v))
-}
-
-// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
-func ExpiresAt(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldExpiresAt, v))
-}
-
-// CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldCreatedAt, v))
-}
-
-// CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldCreatedAt, v))
-}
-
-// CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldCreatedAt, v))
-}
-
-// CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldCreatedAt, v))
-}
-
-// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldUpdatedAt, v))
-}
-
-// ScopeEQ applies the EQ predicate on the "scope" field.
-func ScopeEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldScope, v))
-}
-
-// ScopeNEQ applies the NEQ predicate on the "scope" field.
-func ScopeNEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldScope, v))
-}
-
-// ScopeIn applies the In predicate on the "scope" field.
-func ScopeIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldScope, vs...))
-}
-
-// ScopeNotIn applies the NotIn predicate on the "scope" field.
-func ScopeNotIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldScope, vs...))
-}
-
-// ScopeGT applies the GT predicate on the "scope" field.
-func ScopeGT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldScope, v))
-}
-
-// ScopeGTE applies the GTE predicate on the "scope" field.
-func ScopeGTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldScope, v))
-}
-
-// ScopeLT applies the LT predicate on the "scope" field.
-func ScopeLT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldScope, v))
-}
-
-// ScopeLTE applies the LTE predicate on the "scope" field.
-func ScopeLTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldScope, v))
-}
-
-// ScopeContains applies the Contains predicate on the "scope" field.
-func ScopeContains(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContains(FieldScope, v))
-}
-
-// ScopeHasPrefix applies the HasPrefix predicate on the "scope" field.
-func ScopeHasPrefix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasPrefix(FieldScope, v))
-}
-
-// ScopeHasSuffix applies the HasSuffix predicate on the "scope" field.
-func ScopeHasSuffix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasSuffix(FieldScope, v))
-}
-
-// ScopeEqualFold applies the EqualFold predicate on the "scope" field.
-func ScopeEqualFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEqualFold(FieldScope, v))
-}
-
-// ScopeContainsFold applies the ContainsFold predicate on the "scope" field.
-func ScopeContainsFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContainsFold(FieldScope, v))
-}
-
-// IdempotencyKeyHashEQ applies the EQ predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashNEQ applies the NEQ predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashNEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashIn applies the In predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldIdempotencyKeyHash, vs...))
-}
-
-// IdempotencyKeyHashNotIn applies the NotIn predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashNotIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldIdempotencyKeyHash, vs...))
-}
-
-// IdempotencyKeyHashGT applies the GT predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashGT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashGTE applies the GTE predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashGTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashLT applies the LT predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashLT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashLTE applies the LTE predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashLTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashContains applies the Contains predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashContains(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContains(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashHasPrefix applies the HasPrefix predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashHasPrefix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasPrefix(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashHasSuffix applies the HasSuffix predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashHasSuffix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasSuffix(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashEqualFold applies the EqualFold predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashEqualFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEqualFold(FieldIdempotencyKeyHash, v))
-}
-
-// IdempotencyKeyHashContainsFold applies the ContainsFold predicate on the "idempotency_key_hash" field.
-func IdempotencyKeyHashContainsFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContainsFold(FieldIdempotencyKeyHash, v))
-}
-
-// RequestFingerprintEQ applies the EQ predicate on the "request_fingerprint" field.
-func RequestFingerprintEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintNEQ applies the NEQ predicate on the "request_fingerprint" field.
-func RequestFingerprintNEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintIn applies the In predicate on the "request_fingerprint" field.
-func RequestFingerprintIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldRequestFingerprint, vs...))
-}
-
-// RequestFingerprintNotIn applies the NotIn predicate on the "request_fingerprint" field.
-func RequestFingerprintNotIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldRequestFingerprint, vs...))
-}
-
-// RequestFingerprintGT applies the GT predicate on the "request_fingerprint" field.
-func RequestFingerprintGT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintGTE applies the GTE predicate on the "request_fingerprint" field.
-func RequestFingerprintGTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintLT applies the LT predicate on the "request_fingerprint" field.
-func RequestFingerprintLT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintLTE applies the LTE predicate on the "request_fingerprint" field.
-func RequestFingerprintLTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintContains applies the Contains predicate on the "request_fingerprint" field.
-func RequestFingerprintContains(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContains(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintHasPrefix applies the HasPrefix predicate on the "request_fingerprint" field.
-func RequestFingerprintHasPrefix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasPrefix(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintHasSuffix applies the HasSuffix predicate on the "request_fingerprint" field.
-func RequestFingerprintHasSuffix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasSuffix(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintEqualFold applies the EqualFold predicate on the "request_fingerprint" field.
-func RequestFingerprintEqualFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEqualFold(FieldRequestFingerprint, v))
-}
-
-// RequestFingerprintContainsFold applies the ContainsFold predicate on the "request_fingerprint" field.
-func RequestFingerprintContainsFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContainsFold(FieldRequestFingerprint, v))
-}
-
-// StatusEQ applies the EQ predicate on the "status" field.
-func StatusEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldStatus, v))
-}
-
-// StatusNEQ applies the NEQ predicate on the "status" field.
-func StatusNEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldStatus, v))
-}
-
-// StatusIn applies the In predicate on the "status" field.
-func StatusIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldStatus, vs...))
-}
-
-// StatusNotIn applies the NotIn predicate on the "status" field.
-func StatusNotIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldStatus, vs...))
-}
-
-// StatusGT applies the GT predicate on the "status" field.
-func StatusGT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldStatus, v))
-}
-
-// StatusGTE applies the GTE predicate on the "status" field.
-func StatusGTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldStatus, v))
-}
-
-// StatusLT applies the LT predicate on the "status" field.
-func StatusLT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldStatus, v))
-}
-
-// StatusLTE applies the LTE predicate on the "status" field.
-func StatusLTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldStatus, v))
-}
-
-// StatusContains applies the Contains predicate on the "status" field.
-func StatusContains(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContains(FieldStatus, v))
-}
-
-// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
-func StatusHasPrefix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasPrefix(FieldStatus, v))
-}
-
-// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
-func StatusHasSuffix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasSuffix(FieldStatus, v))
-}
-
-// StatusEqualFold applies the EqualFold predicate on the "status" field.
-func StatusEqualFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEqualFold(FieldStatus, v))
-}
-
-// StatusContainsFold applies the ContainsFold predicate on the "status" field.
-func StatusContainsFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContainsFold(FieldStatus, v))
-}
-
-// ResponseStatusEQ applies the EQ predicate on the "response_status" field.
-func ResponseStatusEQ(v int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldResponseStatus, v))
-}
-
-// ResponseStatusNEQ applies the NEQ predicate on the "response_status" field.
-func ResponseStatusNEQ(v int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldResponseStatus, v))
-}
-
-// ResponseStatusIn applies the In predicate on the "response_status" field.
-func ResponseStatusIn(vs ...int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldResponseStatus, vs...))
-}
-
-// ResponseStatusNotIn applies the NotIn predicate on the "response_status" field.
-func ResponseStatusNotIn(vs ...int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldResponseStatus, vs...))
-}
-
-// ResponseStatusGT applies the GT predicate on the "response_status" field.
-func ResponseStatusGT(v int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldResponseStatus, v))
-}
-
-// ResponseStatusGTE applies the GTE predicate on the "response_status" field.
-func ResponseStatusGTE(v int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldResponseStatus, v))
-}
-
-// ResponseStatusLT applies the LT predicate on the "response_status" field.
-func ResponseStatusLT(v int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldResponseStatus, v))
-}
-
-// ResponseStatusLTE applies the LTE predicate on the "response_status" field.
-func ResponseStatusLTE(v int) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldResponseStatus, v))
-}
-
-// ResponseStatusIsNil applies the IsNil predicate on the "response_status" field.
-func ResponseStatusIsNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIsNull(FieldResponseStatus))
-}
-
-// ResponseStatusNotNil applies the NotNil predicate on the "response_status" field.
-func ResponseStatusNotNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotNull(FieldResponseStatus))
-}
-
-// ResponseBodyEQ applies the EQ predicate on the "response_body" field.
-func ResponseBodyEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldResponseBody, v))
-}
-
-// ResponseBodyNEQ applies the NEQ predicate on the "response_body" field.
-func ResponseBodyNEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldResponseBody, v))
-}
-
-// ResponseBodyIn applies the In predicate on the "response_body" field.
-func ResponseBodyIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldResponseBody, vs...))
-}
-
-// ResponseBodyNotIn applies the NotIn predicate on the "response_body" field.
-func ResponseBodyNotIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldResponseBody, vs...))
-}
-
-// ResponseBodyGT applies the GT predicate on the "response_body" field.
-func ResponseBodyGT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldResponseBody, v))
-}
-
-// ResponseBodyGTE applies the GTE predicate on the "response_body" field.
-func ResponseBodyGTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldResponseBody, v))
-}
-
-// ResponseBodyLT applies the LT predicate on the "response_body" field.
-func ResponseBodyLT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldResponseBody, v))
-}
-
-// ResponseBodyLTE applies the LTE predicate on the "response_body" field.
-func ResponseBodyLTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldResponseBody, v))
-}
-
-// ResponseBodyContains applies the Contains predicate on the "response_body" field.
-func ResponseBodyContains(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContains(FieldResponseBody, v))
-}
-
-// ResponseBodyHasPrefix applies the HasPrefix predicate on the "response_body" field.
-func ResponseBodyHasPrefix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasPrefix(FieldResponseBody, v))
-}
-
-// ResponseBodyHasSuffix applies the HasSuffix predicate on the "response_body" field.
-func ResponseBodyHasSuffix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasSuffix(FieldResponseBody, v))
-}
-
-// ResponseBodyIsNil applies the IsNil predicate on the "response_body" field.
-func ResponseBodyIsNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIsNull(FieldResponseBody))
-}
-
-// ResponseBodyNotNil applies the NotNil predicate on the "response_body" field.
-func ResponseBodyNotNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotNull(FieldResponseBody))
-}
-
-// ResponseBodyEqualFold applies the EqualFold predicate on the "response_body" field.
-func ResponseBodyEqualFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEqualFold(FieldResponseBody, v))
-}
-
-// ResponseBodyContainsFold applies the ContainsFold predicate on the "response_body" field.
-func ResponseBodyContainsFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContainsFold(FieldResponseBody, v))
-}
-
-// ErrorReasonEQ applies the EQ predicate on the "error_reason" field.
-func ErrorReasonEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldErrorReason, v))
-}
-
-// ErrorReasonNEQ applies the NEQ predicate on the "error_reason" field.
-func ErrorReasonNEQ(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldErrorReason, v))
-}
-
-// ErrorReasonIn applies the In predicate on the "error_reason" field.
-func ErrorReasonIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldErrorReason, vs...))
-}
-
-// ErrorReasonNotIn applies the NotIn predicate on the "error_reason" field.
-func ErrorReasonNotIn(vs ...string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldErrorReason, vs...))
-}
-
-// ErrorReasonGT applies the GT predicate on the "error_reason" field.
-func ErrorReasonGT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldErrorReason, v))
-}
-
-// ErrorReasonGTE applies the GTE predicate on the "error_reason" field.
-func ErrorReasonGTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldErrorReason, v))
-}
-
-// ErrorReasonLT applies the LT predicate on the "error_reason" field.
-func ErrorReasonLT(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldErrorReason, v))
-}
-
-// ErrorReasonLTE applies the LTE predicate on the "error_reason" field.
-func ErrorReasonLTE(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldErrorReason, v))
-}
-
-// ErrorReasonContains applies the Contains predicate on the "error_reason" field.
-func ErrorReasonContains(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContains(FieldErrorReason, v))
-}
-
-// ErrorReasonHasPrefix applies the HasPrefix predicate on the "error_reason" field.
-func ErrorReasonHasPrefix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasPrefix(FieldErrorReason, v))
-}
-
-// ErrorReasonHasSuffix applies the HasSuffix predicate on the "error_reason" field.
-func ErrorReasonHasSuffix(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldHasSuffix(FieldErrorReason, v))
-}
-
-// ErrorReasonIsNil applies the IsNil predicate on the "error_reason" field.
-func ErrorReasonIsNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIsNull(FieldErrorReason))
-}
-
-// ErrorReasonNotNil applies the NotNil predicate on the "error_reason" field.
-func ErrorReasonNotNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotNull(FieldErrorReason))
-}
-
-// ErrorReasonEqualFold applies the EqualFold predicate on the "error_reason" field.
-func ErrorReasonEqualFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEqualFold(FieldErrorReason, v))
-}
-
-// ErrorReasonContainsFold applies the ContainsFold predicate on the "error_reason" field.
-func ErrorReasonContainsFold(v string) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldContainsFold(FieldErrorReason, v))
-}
-
-// LockedUntilEQ applies the EQ predicate on the "locked_until" field.
-func LockedUntilEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldLockedUntil, v))
-}
-
-// LockedUntilNEQ applies the NEQ predicate on the "locked_until" field.
-func LockedUntilNEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldLockedUntil, v))
-}
-
-// LockedUntilIn applies the In predicate on the "locked_until" field.
-func LockedUntilIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldLockedUntil, vs...))
-}
-
-// LockedUntilNotIn applies the NotIn predicate on the "locked_until" field.
-func LockedUntilNotIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldLockedUntil, vs...))
-}
-
-// LockedUntilGT applies the GT predicate on the "locked_until" field.
-func LockedUntilGT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldLockedUntil, v))
-}
-
-// LockedUntilGTE applies the GTE predicate on the "locked_until" field.
-func LockedUntilGTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldLockedUntil, v))
-}
-
-// LockedUntilLT applies the LT predicate on the "locked_until" field.
-func LockedUntilLT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldLockedUntil, v))
-}
-
-// LockedUntilLTE applies the LTE predicate on the "locked_until" field.
-func LockedUntilLTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldLockedUntil, v))
-}
-
-// LockedUntilIsNil applies the IsNil predicate on the "locked_until" field.
-func LockedUntilIsNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIsNull(FieldLockedUntil))
-}
-
-// LockedUntilNotNil applies the NotNil predicate on the "locked_until" field.
-func LockedUntilNotNil() predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotNull(FieldLockedUntil))
-}
-
-// ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
-func ExpiresAtEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldEQ(FieldExpiresAt, v))
-}
-
-// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
-func ExpiresAtNEQ(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNEQ(FieldExpiresAt, v))
-}
-
-// ExpiresAtIn applies the In predicate on the "expires_at" field.
-func ExpiresAtIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldIn(FieldExpiresAt, vs...))
-}
-
-// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
-func ExpiresAtNotIn(vs ...time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldNotIn(FieldExpiresAt, vs...))
-}
-
-// ExpiresAtGT applies the GT predicate on the "expires_at" field.
-func ExpiresAtGT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGT(FieldExpiresAt, v))
-}
-
-// ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
-func ExpiresAtGTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldGTE(FieldExpiresAt, v))
-}
-
-// ExpiresAtLT applies the LT predicate on the "expires_at" field.
-func ExpiresAtLT(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLT(FieldExpiresAt, v))
-}
-
-// ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
-func ExpiresAtLTE(v time.Time) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.FieldLTE(FieldExpiresAt, v))
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.IdempotencyRecord) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.IdempotencyRecord) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.IdempotencyRecord) predicate.IdempotencyRecord {
-	return predicate.IdempotencyRecord(sql.NotPredicates(p))
-}

backend/ent/idempotencyrecord_delete.go

@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/idempotencyrecord"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// IdempotencyRecordDelete is the builder for deleting a IdempotencyRecord entity.
-type IdempotencyRecordDelete struct {
-	config
-	hooks    []Hook
-	mutation *IdempotencyRecordMutation
-}
-
-// Where appends a list predicates to the IdempotencyRecordDelete builder.
-func (_d *IdempotencyRecordDelete) Where(ps ...predicate.IdempotencyRecord) *IdempotencyRecordDelete {
-	_d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *IdempotencyRecordDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *IdempotencyRecordDelete) ExecX(ctx context.Context) int {
-	n, err := _d.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (_d *IdempotencyRecordDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(idempotencyrecord.Table, sqlgraph.NewFieldSpec(idempotencyrecord.FieldID, field.TypeInt64))
-	if ps := _d.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	_d.mutation.done = true
-	return affected, err
-}
-
-// IdempotencyRecordDeleteOne is the builder for deleting a single IdempotencyRecord entity.
-type IdempotencyRecordDeleteOne struct {
-	_d *IdempotencyRecordDelete
-}
-
-// Where appends a list predicates to the IdempotencyRecordDelete builder.
-func (_d *IdempotencyRecordDeleteOne) Where(ps ...predicate.IdempotencyRecord) *IdempotencyRecordDeleteOne {
-	_d._d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query.
-func (_d *IdempotencyRecordDeleteOne) Exec(ctx context.Context) error {
-	n, err := _d._d.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{idempotencyrecord.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *IdempotencyRecordDeleteOne) ExecX(ctx context.Context) {
-	if err := _d.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/idempotencyrecord_query.go

@@ -1,564 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"fmt"
-	"math"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/idempotencyrecord"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// IdempotencyRecordQuery is the builder for querying IdempotencyRecord entities.
-type IdempotencyRecordQuery struct {
-	config
-	ctx        *QueryContext
-	order      []idempotencyrecord.OrderOption
-	inters     []Interceptor
-	predicates []predicate.IdempotencyRecord
-	modifiers  []func(*sql.Selector)
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the IdempotencyRecordQuery builder.
-func (_q *IdempotencyRecordQuery) Where(ps ...predicate.IdempotencyRecord) *IdempotencyRecordQuery {
-	_q.predicates = append(_q.predicates, ps...)
-	return _q
-}
-
-// Limit the number of records to be returned by this query.
-func (_q *IdempotencyRecordQuery) Limit(limit int) *IdempotencyRecordQuery {
-	_q.ctx.Limit = &limit
-	return _q
-}
-
-// Offset to start from.
-func (_q *IdempotencyRecordQuery) Offset(offset int) *IdempotencyRecordQuery {
-	_q.ctx.Offset = &offset
-	return _q
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (_q *IdempotencyRecordQuery) Unique(unique bool) *IdempotencyRecordQuery {
-	_q.ctx.Unique = &unique
-	return _q
-}
-
-// Order specifies how the records should be ordered.
-func (_q *IdempotencyRecordQuery) Order(o ...idempotencyrecord.OrderOption) *IdempotencyRecordQuery {
-	_q.order = append(_q.order, o...)
-	return _q
-}
-
-// First returns the first IdempotencyRecord entity from the query.
-// Returns a *NotFoundError when no IdempotencyRecord was found.
-func (_q *IdempotencyRecordQuery) First(ctx context.Context) (*IdempotencyRecord, error) {
-	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{idempotencyrecord.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) FirstX(ctx context.Context) *IdempotencyRecord {
-	node, err := _q.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first IdempotencyRecord ID from the query.
-// Returns a *NotFoundError when no IdempotencyRecord ID was found.
-func (_q *IdempotencyRecordQuery) FirstID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{idempotencyrecord.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) FirstIDX(ctx context.Context) int64 {
-	id, err := _q.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single IdempotencyRecord entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one IdempotencyRecord entity is found.
-// Returns a *NotFoundError when no IdempotencyRecord entities are found.
-func (_q *IdempotencyRecordQuery) Only(ctx context.Context) (*IdempotencyRecord, error) {
-	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{idempotencyrecord.Label}
-	default:
-		return nil, &NotSingularError{idempotencyrecord.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) OnlyX(ctx context.Context) *IdempotencyRecord {
-	node, err := _q.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only IdempotencyRecord ID in the query.
-// Returns a *NotSingularError when more than one IdempotencyRecord ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (_q *IdempotencyRecordQuery) OnlyID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{idempotencyrecord.Label}
-	default:
-		err = &NotSingularError{idempotencyrecord.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) OnlyIDX(ctx context.Context) int64 {
-	id, err := _q.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of IdempotencyRecords.
-func (_q *IdempotencyRecordQuery) All(ctx context.Context) ([]*IdempotencyRecord, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*IdempotencyRecord, *IdempotencyRecordQuery]()
-	return withInterceptors[[]*IdempotencyRecord](ctx, _q, qr, _q.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) AllX(ctx context.Context) []*IdempotencyRecord {
-	nodes, err := _q.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of IdempotencyRecord IDs.
-func (_q *IdempotencyRecordQuery) IDs(ctx context.Context) (ids []int64, err error) {
-	if _q.ctx.Unique == nil && _q.path != nil {
-		_q.Unique(true)
-	}
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
-	if err = _q.Select(idempotencyrecord.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) IDsX(ctx context.Context) []int64 {
-	ids, err := _q.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (_q *IdempotencyRecordQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, _q, querierCount[*IdempotencyRecordQuery](), _q.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) CountX(ctx context.Context) int {
-	count, err := _q.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (_q *IdempotencyRecordQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
-	switch _, err := _q.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (_q *IdempotencyRecordQuery) ExistX(ctx context.Context) bool {
-	exist, err := _q.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the IdempotencyRecordQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (_q *IdempotencyRecordQuery) Clone() *IdempotencyRecordQuery {
-	if _q == nil {
-		return nil
-	}
-	return &IdempotencyRecordQuery{
-		config:     _q.config,
-		ctx:        _q.ctx.Clone(),
-		order:      append([]idempotencyrecord.OrderOption{}, _q.order...),
-		inters:     append([]Interceptor{}, _q.inters...),
-		predicates: append([]predicate.IdempotencyRecord{}, _q.predicates...),
-		// clone intermediate query.
-		sql:  _q.sql.Clone(),
-		path: _q.path,
-	}
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		CreatedAt time.Time `json:"created_at,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.IdempotencyRecord.Query().
-//		GroupBy(idempotencyrecord.FieldCreatedAt).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (_q *IdempotencyRecordQuery) GroupBy(field string, fields ...string) *IdempotencyRecordGroupBy {
-	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &IdempotencyRecordGroupBy{build: _q}
-	grbuild.flds = &_q.ctx.Fields
-	grbuild.label = idempotencyrecord.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		CreatedAt time.Time `json:"created_at,omitempty"`
-//	}
-//
-//	client.IdempotencyRecord.Query().
-//		Select(idempotencyrecord.FieldCreatedAt).
-//		Scan(ctx, &v)
-func (_q *IdempotencyRecordQuery) Select(fields ...string) *IdempotencyRecordSelect {
-	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &IdempotencyRecordSelect{IdempotencyRecordQuery: _q}
-	sbuild.label = idempotencyrecord.Label
-	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a IdempotencyRecordSelect configured with the given aggregations.
-func (_q *IdempotencyRecordQuery) Aggregate(fns ...AggregateFunc) *IdempotencyRecordSelect {
-	return _q.Select().Aggregate(fns...)
-}
-
-func (_q *IdempotencyRecordQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range _q.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, _q); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range _q.ctx.Fields {
-		if !idempotencyrecord.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if _q.path != nil {
-		prev, err := _q.path(ctx)
-		if err != nil {
-			return err
-		}
-		_q.sql = prev
-	}
-	return nil
-}
-
-func (_q *IdempotencyRecordQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*IdempotencyRecord, error) {
-	var (
-		nodes = []*IdempotencyRecord{}
-		_spec = _q.querySpec()
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*IdempotencyRecord).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &IdempotencyRecord{config: _q.config}
-		nodes = append(nodes, node)
-		return node.assignValues(columns, values)
-	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	return nodes, nil
-}
-
-func (_q *IdempotencyRecordQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	_spec.Node.Columns = _q.ctx.Fields
-	if len(_q.ctx.Fields) > 0 {
-		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
-}
-
-func (_q *IdempotencyRecordQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(idempotencyrecord.Table, idempotencyrecord.Columns, sqlgraph.NewFieldSpec(idempotencyrecord.FieldID, field.TypeInt64))
-	_spec.From = _q.sql
-	if unique := _q.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if _q.path != nil {
-		_spec.Unique = true
-	}
-	if fields := _q.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, idempotencyrecord.FieldID)
-		for i := range fields {
-			if fields[i] != idempotencyrecord.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-	}
-	if ps := _q.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := _q.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (_q *IdempotencyRecordQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(_q.driver.Dialect())
-	t1 := builder.Table(idempotencyrecord.Table)
-	columns := _q.ctx.Fields
-	if len(columns) == 0 {
-		columns = idempotencyrecord.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if _q.sql != nil {
-		selector = _q.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if _q.ctx.Unique != nil && *_q.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
-	for _, p := range _q.predicates {
-		p(selector)
-	}
-	for _, p := range _q.order {
-		p(selector)
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *IdempotencyRecordQuery) ForUpdate(opts ...sql.LockOption) *IdempotencyRecordQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *IdempotencyRecordQuery) ForShare(opts ...sql.LockOption) *IdempotencyRecordQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// IdempotencyRecordGroupBy is the group-by builder for IdempotencyRecord entities.
-type IdempotencyRecordGroupBy struct {
-	selector
-	build *IdempotencyRecordQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (_g *IdempotencyRecordGroupBy) Aggregate(fns ...AggregateFunc) *IdempotencyRecordGroupBy {
-	_g.fns = append(_g.fns, fns...)
-	return _g
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_g *IdempotencyRecordGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
-	if err := _g.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*IdempotencyRecordQuery, *IdempotencyRecordGroupBy](ctx, _g.build, _g, _g.build.inters, v)
-}
-
-func (_g *IdempotencyRecordGroupBy) sqlScan(ctx context.Context, root *IdempotencyRecordQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(_g.fns))
-	for _, fn := range _g.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
-		for _, f := range *_g.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*_g.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// IdempotencyRecordSelect is the builder for selecting fields of IdempotencyRecord entities.
-type IdempotencyRecordSelect struct {
-	*IdempotencyRecordQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (_s *IdempotencyRecordSelect) Aggregate(fns ...AggregateFunc) *IdempotencyRecordSelect {
-	_s.fns = append(_s.fns, fns...)
-	return _s
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_s *IdempotencyRecordSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
-	if err := _s.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*IdempotencyRecordQuery, *IdempotencyRecordSelect](ctx, _s.IdempotencyRecordQuery, _s, _s.inters, v)
-}
-
-func (_s *IdempotencyRecordSelect) sqlScan(ctx context.Context, root *IdempotencyRecordQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(_s.fns))
-	for _, fn := range _s.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*_s.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}

backend/ent/idempotencyrecord_update.go

@@ -1,676 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/idempotencyrecord"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// IdempotencyRecordUpdate is the builder for updating IdempotencyRecord entities.
-type IdempotencyRecordUpdate struct {
-	config
-	hooks    []Hook
-	mutation *IdempotencyRecordMutation
-}
-
-// Where appends a list predicates to the IdempotencyRecordUpdate builder.
-func (_u *IdempotencyRecordUpdate) Where(ps ...predicate.IdempotencyRecord) *IdempotencyRecordUpdate {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *IdempotencyRecordUpdate) SetUpdatedAt(v time.Time) *IdempotencyRecordUpdate {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// SetScope sets the "scope" field.
-func (_u *IdempotencyRecordUpdate) SetScope(v string) *IdempotencyRecordUpdate {
-	_u.mutation.SetScope(v)
-	return _u
-}
-
-// SetNillableScope sets the "scope" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableScope(v *string) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetScope(*v)
-	}
-	return _u
-}
-
-// SetIdempotencyKeyHash sets the "idempotency_key_hash" field.
-func (_u *IdempotencyRecordUpdate) SetIdempotencyKeyHash(v string) *IdempotencyRecordUpdate {
-	_u.mutation.SetIdempotencyKeyHash(v)
-	return _u
-}
-
-// SetNillableIdempotencyKeyHash sets the "idempotency_key_hash" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableIdempotencyKeyHash(v *string) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetIdempotencyKeyHash(*v)
-	}
-	return _u
-}
-
-// SetRequestFingerprint sets the "request_fingerprint" field.
-func (_u *IdempotencyRecordUpdate) SetRequestFingerprint(v string) *IdempotencyRecordUpdate {
-	_u.mutation.SetRequestFingerprint(v)
-	return _u
-}
-
-// SetNillableRequestFingerprint sets the "request_fingerprint" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableRequestFingerprint(v *string) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetRequestFingerprint(*v)
-	}
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *IdempotencyRecordUpdate) SetStatus(v string) *IdempotencyRecordUpdate {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableStatus(v *string) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetResponseStatus sets the "response_status" field.
-func (_u *IdempotencyRecordUpdate) SetResponseStatus(v int) *IdempotencyRecordUpdate {
-	_u.mutation.ResetResponseStatus()
-	_u.mutation.SetResponseStatus(v)
-	return _u
-}
-
-// SetNillableResponseStatus sets the "response_status" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableResponseStatus(v *int) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetResponseStatus(*v)
-	}
-	return _u
-}
-
-// AddResponseStatus adds value to the "response_status" field.
-func (_u *IdempotencyRecordUpdate) AddResponseStatus(v int) *IdempotencyRecordUpdate {
-	_u.mutation.AddResponseStatus(v)
-	return _u
-}
-
-// ClearResponseStatus clears the value of the "response_status" field.
-func (_u *IdempotencyRecordUpdate) ClearResponseStatus() *IdempotencyRecordUpdate {
-	_u.mutation.ClearResponseStatus()
-	return _u
-}
-
-// SetResponseBody sets the "response_body" field.
-func (_u *IdempotencyRecordUpdate) SetResponseBody(v string) *IdempotencyRecordUpdate {
-	_u.mutation.SetResponseBody(v)
-	return _u
-}
-
-// SetNillableResponseBody sets the "response_body" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableResponseBody(v *string) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetResponseBody(*v)
-	}
-	return _u
-}
-
-// ClearResponseBody clears the value of the "response_body" field.
-func (_u *IdempotencyRecordUpdate) ClearResponseBody() *IdempotencyRecordUpdate {
-	_u.mutation.ClearResponseBody()
-	return _u
-}
-
-// SetErrorReason sets the "error_reason" field.
-func (_u *IdempotencyRecordUpdate) SetErrorReason(v string) *IdempotencyRecordUpdate {
-	_u.mutation.SetErrorReason(v)
-	return _u
-}
-
-// SetNillableErrorReason sets the "error_reason" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableErrorReason(v *string) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetErrorReason(*v)
-	}
-	return _u
-}
-
-// ClearErrorReason clears the value of the "error_reason" field.
-func (_u *IdempotencyRecordUpdate) ClearErrorReason() *IdempotencyRecordUpdate {
-	_u.mutation.ClearErrorReason()
-	return _u
-}
-
-// SetLockedUntil sets the "locked_until" field.
-func (_u *IdempotencyRecordUpdate) SetLockedUntil(v time.Time) *IdempotencyRecordUpdate {
-	_u.mutation.SetLockedUntil(v)
-	return _u
-}
-
-// SetNillableLockedUntil sets the "locked_until" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableLockedUntil(v *time.Time) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetLockedUntil(*v)
-	}
-	return _u
-}
-
-// ClearLockedUntil clears the value of the "locked_until" field.
-func (_u *IdempotencyRecordUpdate) ClearLockedUntil() *IdempotencyRecordUpdate {
-	_u.mutation.ClearLockedUntil()
-	return _u
-}
-
-// SetExpiresAt sets the "expires_at" field.
-func (_u *IdempotencyRecordUpdate) SetExpiresAt(v time.Time) *IdempotencyRecordUpdate {
-	_u.mutation.SetExpiresAt(v)
-	return _u
-}
-
-// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdate) SetNillableExpiresAt(v *time.Time) *IdempotencyRecordUpdate {
-	if v != nil {
-		_u.SetExpiresAt(*v)
-	}
-	return _u
-}
-
-// Mutation returns the IdempotencyRecordMutation object of the builder.
-func (_u *IdempotencyRecordUpdate) Mutation() *IdempotencyRecordMutation {
-	return _u.mutation
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *IdempotencyRecordUpdate) Save(ctx context.Context) (int, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *IdempotencyRecordUpdate) SaveX(ctx context.Context) int {
-	affected, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (_u *IdempotencyRecordUpdate) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *IdempotencyRecordUpdate) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *IdempotencyRecordUpdate) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := idempotencyrecord.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *IdempotencyRecordUpdate) check() error {
-	if v, ok := _u.mutation.Scope(); ok {
-		if err := idempotencyrecord.ScopeValidator(v); err != nil {
-			return &ValidationError{Name: "scope", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.scope": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.IdempotencyKeyHash(); ok {
-		if err := idempotencyrecord.IdempotencyKeyHashValidator(v); err != nil {
-			return &ValidationError{Name: "idempotency_key_hash", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.idempotency_key_hash": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.RequestFingerprint(); ok {
-		if err := idempotencyrecord.RequestFingerprintValidator(v); err != nil {
-			return &ValidationError{Name: "request_fingerprint", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.request_fingerprint": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Status(); ok {
-		if err := idempotencyrecord.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.status": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.ErrorReason(); ok {
-		if err := idempotencyrecord.ErrorReasonValidator(v); err != nil {
-			return &ValidationError{Name: "error_reason", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.error_reason": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *IdempotencyRecordUpdate) sqlSave(ctx context.Context) (_node int, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(idempotencyrecord.Table, idempotencyrecord.Columns, sqlgraph.NewFieldSpec(idempotencyrecord.FieldID, field.TypeInt64))
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(idempotencyrecord.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := _u.mutation.Scope(); ok {
-		_spec.SetField(idempotencyrecord.FieldScope, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.IdempotencyKeyHash(); ok {
-		_spec.SetField(idempotencyrecord.FieldIdempotencyKeyHash, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.RequestFingerprint(); ok {
-		_spec.SetField(idempotencyrecord.FieldRequestFingerprint, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(idempotencyrecord.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.ResponseStatus(); ok {
-		_spec.SetField(idempotencyrecord.FieldResponseStatus, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedResponseStatus(); ok {
-		_spec.AddField(idempotencyrecord.FieldResponseStatus, field.TypeInt, value)
-	}
-	if _u.mutation.ResponseStatusCleared() {
-		_spec.ClearField(idempotencyrecord.FieldResponseStatus, field.TypeInt)
-	}
-	if value, ok := _u.mutation.ResponseBody(); ok {
-		_spec.SetField(idempotencyrecord.FieldResponseBody, field.TypeString, value)
-	}
-	if _u.mutation.ResponseBodyCleared() {
-		_spec.ClearField(idempotencyrecord.FieldResponseBody, field.TypeString)
-	}
-	if value, ok := _u.mutation.ErrorReason(); ok {
-		_spec.SetField(idempotencyrecord.FieldErrorReason, field.TypeString, value)
-	}
-	if _u.mutation.ErrorReasonCleared() {
-		_spec.ClearField(idempotencyrecord.FieldErrorReason, field.TypeString)
-	}
-	if value, ok := _u.mutation.LockedUntil(); ok {
-		_spec.SetField(idempotencyrecord.FieldLockedUntil, field.TypeTime, value)
-	}
-	if _u.mutation.LockedUntilCleared() {
-		_spec.ClearField(idempotencyrecord.FieldLockedUntil, field.TypeTime)
-	}
-	if value, ok := _u.mutation.ExpiresAt(); ok {
-		_spec.SetField(idempotencyrecord.FieldExpiresAt, field.TypeTime, value)
-	}
-	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{idempotencyrecord.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}
-
-// IdempotencyRecordUpdateOne is the builder for updating a single IdempotencyRecord entity.
-type IdempotencyRecordUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *IdempotencyRecordMutation
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *IdempotencyRecordUpdateOne) SetUpdatedAt(v time.Time) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// SetScope sets the "scope" field.
-func (_u *IdempotencyRecordUpdateOne) SetScope(v string) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetScope(v)
-	return _u
-}
-
-// SetNillableScope sets the "scope" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableScope(v *string) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetScope(*v)
-	}
-	return _u
-}
-
-// SetIdempotencyKeyHash sets the "idempotency_key_hash" field.
-func (_u *IdempotencyRecordUpdateOne) SetIdempotencyKeyHash(v string) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetIdempotencyKeyHash(v)
-	return _u
-}
-
-// SetNillableIdempotencyKeyHash sets the "idempotency_key_hash" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableIdempotencyKeyHash(v *string) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetIdempotencyKeyHash(*v)
-	}
-	return _u
-}
-
-// SetRequestFingerprint sets the "request_fingerprint" field.
-func (_u *IdempotencyRecordUpdateOne) SetRequestFingerprint(v string) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetRequestFingerprint(v)
-	return _u
-}
-
-// SetNillableRequestFingerprint sets the "request_fingerprint" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableRequestFingerprint(v *string) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetRequestFingerprint(*v)
-	}
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *IdempotencyRecordUpdateOne) SetStatus(v string) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableStatus(v *string) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetResponseStatus sets the "response_status" field.
-func (_u *IdempotencyRecordUpdateOne) SetResponseStatus(v int) *IdempotencyRecordUpdateOne {
-	_u.mutation.ResetResponseStatus()
-	_u.mutation.SetResponseStatus(v)
-	return _u
-}
-
-// SetNillableResponseStatus sets the "response_status" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableResponseStatus(v *int) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetResponseStatus(*v)
-	}
-	return _u
-}
-
-// AddResponseStatus adds value to the "response_status" field.
-func (_u *IdempotencyRecordUpdateOne) AddResponseStatus(v int) *IdempotencyRecordUpdateOne {
-	_u.mutation.AddResponseStatus(v)
-	return _u
-}
-
-// ClearResponseStatus clears the value of the "response_status" field.
-func (_u *IdempotencyRecordUpdateOne) ClearResponseStatus() *IdempotencyRecordUpdateOne {
-	_u.mutation.ClearResponseStatus()
-	return _u
-}
-
-// SetResponseBody sets the "response_body" field.
-func (_u *IdempotencyRecordUpdateOne) SetResponseBody(v string) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetResponseBody(v)
-	return _u
-}
-
-// SetNillableResponseBody sets the "response_body" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableResponseBody(v *string) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetResponseBody(*v)
-	}
-	return _u
-}
-
-// ClearResponseBody clears the value of the "response_body" field.
-func (_u *IdempotencyRecordUpdateOne) ClearResponseBody() *IdempotencyRecordUpdateOne {
-	_u.mutation.ClearResponseBody()
-	return _u
-}
-
-// SetErrorReason sets the "error_reason" field.
-func (_u *IdempotencyRecordUpdateOne) SetErrorReason(v string) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetErrorReason(v)
-	return _u
-}
-
-// SetNillableErrorReason sets the "error_reason" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableErrorReason(v *string) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetErrorReason(*v)
-	}
-	return _u
-}
-
-// ClearErrorReason clears the value of the "error_reason" field.
-func (_u *IdempotencyRecordUpdateOne) ClearErrorReason() *IdempotencyRecordUpdateOne {
-	_u.mutation.ClearErrorReason()
-	return _u
-}
-
-// SetLockedUntil sets the "locked_until" field.
-func (_u *IdempotencyRecordUpdateOne) SetLockedUntil(v time.Time) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetLockedUntil(v)
-	return _u
-}
-
-// SetNillableLockedUntil sets the "locked_until" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableLockedUntil(v *time.Time) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetLockedUntil(*v)
-	}
-	return _u
-}
-
-// ClearLockedUntil clears the value of the "locked_until" field.
-func (_u *IdempotencyRecordUpdateOne) ClearLockedUntil() *IdempotencyRecordUpdateOne {
-	_u.mutation.ClearLockedUntil()
-	return _u
-}
-
-// SetExpiresAt sets the "expires_at" field.
-func (_u *IdempotencyRecordUpdateOne) SetExpiresAt(v time.Time) *IdempotencyRecordUpdateOne {
-	_u.mutation.SetExpiresAt(v)
-	return _u
-}
-
-// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (_u *IdempotencyRecordUpdateOne) SetNillableExpiresAt(v *time.Time) *IdempotencyRecordUpdateOne {
-	if v != nil {
-		_u.SetExpiresAt(*v)
-	}
-	return _u
-}
-
-// Mutation returns the IdempotencyRecordMutation object of the builder.
-func (_u *IdempotencyRecordUpdateOne) Mutation() *IdempotencyRecordMutation {
-	return _u.mutation
-}
-
-// Where appends a list predicates to the IdempotencyRecordUpdate builder.
-func (_u *IdempotencyRecordUpdateOne) Where(ps ...predicate.IdempotencyRecord) *IdempotencyRecordUpdateOne {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (_u *IdempotencyRecordUpdateOne) Select(field string, fields ...string) *IdempotencyRecordUpdateOne {
-	_u.fields = append([]string{field}, fields...)
-	return _u
-}
-
-// Save executes the query and returns the updated IdempotencyRecord entity.
-func (_u *IdempotencyRecordUpdateOne) Save(ctx context.Context) (*IdempotencyRecord, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *IdempotencyRecordUpdateOne) SaveX(ctx context.Context) *IdempotencyRecord {
-	node, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (_u *IdempotencyRecordUpdateOne) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *IdempotencyRecordUpdateOne) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *IdempotencyRecordUpdateOne) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := idempotencyrecord.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *IdempotencyRecordUpdateOne) check() error {
-	if v, ok := _u.mutation.Scope(); ok {
-		if err := idempotencyrecord.ScopeValidator(v); err != nil {
-			return &ValidationError{Name: "scope", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.scope": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.IdempotencyKeyHash(); ok {
-		if err := idempotencyrecord.IdempotencyKeyHashValidator(v); err != nil {
-			return &ValidationError{Name: "idempotency_key_hash", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.idempotency_key_hash": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.RequestFingerprint(); ok {
-		if err := idempotencyrecord.RequestFingerprintValidator(v); err != nil {
-			return &ValidationError{Name: "request_fingerprint", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.request_fingerprint": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Status(); ok {
-		if err := idempotencyrecord.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.status": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.ErrorReason(); ok {
-		if err := idempotencyrecord.ErrorReasonValidator(v); err != nil {
-			return &ValidationError{Name: "error_reason", err: fmt.Errorf(`ent: validator failed for field "IdempotencyRecord.error_reason": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *IdempotencyRecordUpdateOne) sqlSave(ctx context.Context) (_node *IdempotencyRecord, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(idempotencyrecord.Table, idempotencyrecord.Columns, sqlgraph.NewFieldSpec(idempotencyrecord.FieldID, field.TypeInt64))
-	id, ok := _u.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "IdempotencyRecord.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := _u.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, idempotencyrecord.FieldID)
-		for _, f := range fields {
-			if !idempotencyrecord.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != idempotencyrecord.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(idempotencyrecord.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := _u.mutation.Scope(); ok {
-		_spec.SetField(idempotencyrecord.FieldScope, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.IdempotencyKeyHash(); ok {
-		_spec.SetField(idempotencyrecord.FieldIdempotencyKeyHash, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.RequestFingerprint(); ok {
-		_spec.SetField(idempotencyrecord.FieldRequestFingerprint, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(idempotencyrecord.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.ResponseStatus(); ok {
-		_spec.SetField(idempotencyrecord.FieldResponseStatus, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedResponseStatus(); ok {
-		_spec.AddField(idempotencyrecord.FieldResponseStatus, field.TypeInt, value)
-	}
-	if _u.mutation.ResponseStatusCleared() {
-		_spec.ClearField(idempotencyrecord.FieldResponseStatus, field.TypeInt)
-	}
-	if value, ok := _u.mutation.ResponseBody(); ok {
-		_spec.SetField(idempotencyrecord.FieldResponseBody, field.TypeString, value)
-	}
-	if _u.mutation.ResponseBodyCleared() {
-		_spec.ClearField(idempotencyrecord.FieldResponseBody, field.TypeString)
-	}
-	if value, ok := _u.mutation.ErrorReason(); ok {
-		_spec.SetField(idempotencyrecord.FieldErrorReason, field.TypeString, value)
-	}
-	if _u.mutation.ErrorReasonCleared() {
-		_spec.ClearField(idempotencyrecord.FieldErrorReason, field.TypeString)
-	}
-	if value, ok := _u.mutation.LockedUntil(); ok {
-		_spec.SetField(idempotencyrecord.FieldLockedUntil, field.TypeTime, value)
-	}
-	if _u.mutation.LockedUntilCleared() {
-		_spec.ClearField(idempotencyrecord.FieldLockedUntil, field.TypeTime)
-	}
-	if value, ok := _u.mutation.ExpiresAt(); ok {
-		_spec.SetField(idempotencyrecord.FieldExpiresAt, field.TypeTime, value)
-	}
-	_node = &IdempotencyRecord{config: _u.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{idempotencyrecord.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}

backend/ent/intercept/intercept.go

@@ -10,25 +10,15 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent"
 	"github.com/Wei-Shaw/sub2api/ent/account"
 	"github.com/Wei-Shaw/sub2api/ent/accountgroup"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
-	"github.com/Wei-Shaw/sub2api/ent/errorpassthroughrule"
 	"github.com/Wei-Shaw/sub2api/ent/group"
-	"github.com/Wei-Shaw/sub2api/ent/idempotencyrecord"
 	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
 	"github.com/Wei-Shaw/sub2api/ent/proxy"
 	"github.com/Wei-Shaw/sub2api/ent/redeemcode"
-	"github.com/Wei-Shaw/sub2api/ent/securitysecret"
 	"github.com/Wei-Shaw/sub2api/ent/setting"
-	"github.com/Wei-Shaw/sub2api/ent/usagecleanuptask"
 	"github.com/Wei-Shaw/sub2api/ent/usagelog"
 	"github.com/Wei-Shaw/sub2api/ent/user"
 	"github.com/Wei-Shaw/sub2api/ent/userallowedgroup"
-	"github.com/Wei-Shaw/sub2api/ent/userattributedefinition"
-	"github.com/Wei-Shaw/sub2api/ent/userattributevalue"
 	"github.com/Wei-Shaw/sub2api/ent/usersubscription"
 )
 
@@ -88,33 +78,6 @@ func (f TraverseFunc) Traverse(ctx context.Context, q ent.Query) error {
 	return f(ctx, query)
 }
 
-// The APIKeyFunc type is an adapter to allow the use of ordinary function as a Querier.
-type APIKeyFunc func(context.Context, *ent.APIKeyQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f APIKeyFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.APIKeyQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.APIKeyQuery", q)
-}
-
-// The TraverseAPIKey type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseAPIKey func(context.Context, *ent.APIKeyQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseAPIKey) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseAPIKey) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.APIKeyQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.APIKeyQuery", q)
-}
-
 // The AccountFunc type is an adapter to allow the use of ordinary function as a Querier.
 type AccountFunc func(context.Context, *ent.AccountQuery) (ent.Value, error)
 
@@ -169,85 +132,31 @@ func (f TraverseAccountGroup) Traverse(ctx context.Context, q ent.Query) error {
 	return fmt.Errorf("unexpected query type %T. expect *ent.AccountGroupQuery", q)
 }
 
-// The AnnouncementFunc type is an adapter to allow the use of ordinary function as a Querier.
-type AnnouncementFunc func(context.Context, *ent.AnnouncementQuery) (ent.Value, error)
+// The ApiKeyFunc type is an adapter to allow the use of ordinary function as a Querier.
+type ApiKeyFunc func(context.Context, *ent.ApiKeyQuery) (ent.Value, error)
 
 // Query calls f(ctx, q).
-func (f AnnouncementFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.AnnouncementQuery); ok {
+func (f ApiKeyFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
+	if q, ok := q.(*ent.ApiKeyQuery); ok {
 		return f(ctx, q)
 	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementQuery", q)
+	return nil, fmt.Errorf("unexpected query type %T. expect *ent.ApiKeyQuery", q)
 }
 
-// The TraverseAnnouncement type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseAnnouncement func(context.Context, *ent.AnnouncementQuery) error
+// The TraverseApiKey type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseApiKey func(context.Context, *ent.ApiKeyQuery) error
 
 // Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseAnnouncement) Intercept(next ent.Querier) ent.Querier {
+func (f TraverseApiKey) Intercept(next ent.Querier) ent.Querier {
 	return next
 }
 
 // Traverse calls f(ctx, q).
-func (f TraverseAnnouncement) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.AnnouncementQuery); ok {
+func (f TraverseApiKey) Traverse(ctx context.Context, q ent.Query) error {
+	if q, ok := q.(*ent.ApiKeyQuery); ok {
 		return f(ctx, q)
 	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementQuery", q)
-}
-
-// The AnnouncementReadFunc type is an adapter to allow the use of ordinary function as a Querier.
-type AnnouncementReadFunc func(context.Context, *ent.AnnouncementReadQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f AnnouncementReadFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.AnnouncementReadQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementReadQuery", q)
-}
-
-// The TraverseAnnouncementRead type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseAnnouncementRead func(context.Context, *ent.AnnouncementReadQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseAnnouncementRead) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseAnnouncementRead) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.AnnouncementReadQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.AnnouncementReadQuery", q)
-}
-
-// The ErrorPassthroughRuleFunc type is an adapter to allow the use of ordinary function as a Querier.
-type ErrorPassthroughRuleFunc func(context.Context, *ent.ErrorPassthroughRuleQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f ErrorPassthroughRuleFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.ErrorPassthroughRuleQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.ErrorPassthroughRuleQuery", q)
-}
-
-// The TraverseErrorPassthroughRule type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseErrorPassthroughRule func(context.Context, *ent.ErrorPassthroughRuleQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseErrorPassthroughRule) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseErrorPassthroughRule) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.ErrorPassthroughRuleQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.ErrorPassthroughRuleQuery", q)
+	return fmt.Errorf("unexpected query type %T. expect *ent.ApiKeyQuery", q)
 }
 
 // The GroupFunc type is an adapter to allow the use of ordinary function as a Querier.
@@ -277,87 +186,6 @@ func (f TraverseGroup) Traverse(ctx context.Context, q ent.Query) error {
 	return fmt.Errorf("unexpected query type %T. expect *ent.GroupQuery", q)
 }
 
-// The IdempotencyRecordFunc type is an adapter to allow the use of ordinary function as a Querier.
-type IdempotencyRecordFunc func(context.Context, *ent.IdempotencyRecordQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f IdempotencyRecordFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.IdempotencyRecordQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.IdempotencyRecordQuery", q)
-}
-
-// The TraverseIdempotencyRecord type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseIdempotencyRecord func(context.Context, *ent.IdempotencyRecordQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseIdempotencyRecord) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseIdempotencyRecord) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.IdempotencyRecordQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.IdempotencyRecordQuery", q)
-}
-
-// The PromoCodeFunc type is an adapter to allow the use of ordinary function as a Querier.
-type PromoCodeFunc func(context.Context, *ent.PromoCodeQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f PromoCodeFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.PromoCodeQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.PromoCodeQuery", q)
-}
-
-// The TraversePromoCode type is an adapter to allow the use of ordinary function as Traverser.
-type TraversePromoCode func(context.Context, *ent.PromoCodeQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraversePromoCode) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraversePromoCode) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.PromoCodeQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.PromoCodeQuery", q)
-}
-
-// The PromoCodeUsageFunc type is an adapter to allow the use of ordinary function as a Querier.
-type PromoCodeUsageFunc func(context.Context, *ent.PromoCodeUsageQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f PromoCodeUsageFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.PromoCodeUsageQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.PromoCodeUsageQuery", q)
-}
-
-// The TraversePromoCodeUsage type is an adapter to allow the use of ordinary function as Traverser.
-type TraversePromoCodeUsage func(context.Context, *ent.PromoCodeUsageQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraversePromoCodeUsage) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraversePromoCodeUsage) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.PromoCodeUsageQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.PromoCodeUsageQuery", q)
-}
-
 // The ProxyFunc type is an adapter to allow the use of ordinary function as a Querier.
 type ProxyFunc func(context.Context, *ent.ProxyQuery) (ent.Value, error)
 
@@ -412,33 +240,6 @@ func (f TraverseRedeemCode) Traverse(ctx context.Context, q ent.Query) error {
 	return fmt.Errorf("unexpected query type %T. expect *ent.RedeemCodeQuery", q)
 }
 
-// The SecuritySecretFunc type is an adapter to allow the use of ordinary function as a Querier.
-type SecuritySecretFunc func(context.Context, *ent.SecuritySecretQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f SecuritySecretFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.SecuritySecretQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.SecuritySecretQuery", q)
-}
-
-// The TraverseSecuritySecret type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseSecuritySecret func(context.Context, *ent.SecuritySecretQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseSecuritySecret) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseSecuritySecret) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.SecuritySecretQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.SecuritySecretQuery", q)
-}
-
 // The SettingFunc type is an adapter to allow the use of ordinary function as a Querier.
 type SettingFunc func(context.Context, *ent.SettingQuery) (ent.Value, error)
 
@@ -466,33 +267,6 @@ func (f TraverseSetting) Traverse(ctx context.Context, q ent.Query) error {
 	return fmt.Errorf("unexpected query type %T. expect *ent.SettingQuery", q)
 }
 
-// The UsageCleanupTaskFunc type is an adapter to allow the use of ordinary function as a Querier.
-type UsageCleanupTaskFunc func(context.Context, *ent.UsageCleanupTaskQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f UsageCleanupTaskFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.UsageCleanupTaskQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.UsageCleanupTaskQuery", q)
-}
-
-// The TraverseUsageCleanupTask type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseUsageCleanupTask func(context.Context, *ent.UsageCleanupTaskQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseUsageCleanupTask) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseUsageCleanupTask) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.UsageCleanupTaskQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.UsageCleanupTaskQuery", q)
-}
-
 // The UsageLogFunc type is an adapter to allow the use of ordinary function as a Querier.
 type UsageLogFunc func(context.Context, *ent.UsageLogQuery) (ent.Value, error)
 
@@ -574,60 +348,6 @@ func (f TraverseUserAllowedGroup) Traverse(ctx context.Context, q ent.Query) err
 	return fmt.Errorf("unexpected query type %T. expect *ent.UserAllowedGroupQuery", q)
 }
 
-// The UserAttributeDefinitionFunc type is an adapter to allow the use of ordinary function as a Querier.
-type UserAttributeDefinitionFunc func(context.Context, *ent.UserAttributeDefinitionQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f UserAttributeDefinitionFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.UserAttributeDefinitionQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.UserAttributeDefinitionQuery", q)
-}
-
-// The TraverseUserAttributeDefinition type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseUserAttributeDefinition func(context.Context, *ent.UserAttributeDefinitionQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseUserAttributeDefinition) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseUserAttributeDefinition) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.UserAttributeDefinitionQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.UserAttributeDefinitionQuery", q)
-}
-
-// The UserAttributeValueFunc type is an adapter to allow the use of ordinary function as a Querier.
-type UserAttributeValueFunc func(context.Context, *ent.UserAttributeValueQuery) (ent.Value, error)
-
-// Query calls f(ctx, q).
-func (f UserAttributeValueFunc) Query(ctx context.Context, q ent.Query) (ent.Value, error) {
-	if q, ok := q.(*ent.UserAttributeValueQuery); ok {
-		return f(ctx, q)
-	}
-	return nil, fmt.Errorf("unexpected query type %T. expect *ent.UserAttributeValueQuery", q)
-}
-
-// The TraverseUserAttributeValue type is an adapter to allow the use of ordinary function as Traverser.
-type TraverseUserAttributeValue func(context.Context, *ent.UserAttributeValueQuery) error
-
-// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
-func (f TraverseUserAttributeValue) Intercept(next ent.Querier) ent.Querier {
-	return next
-}
-
-// Traverse calls f(ctx, q).
-func (f TraverseUserAttributeValue) Traverse(ctx context.Context, q ent.Query) error {
-	if q, ok := q.(*ent.UserAttributeValueQuery); ok {
-		return f(ctx, q)
-	}
-	return fmt.Errorf("unexpected query type %T. expect *ent.UserAttributeValueQuery", q)
-}
-
 // The UserSubscriptionFunc type is an adapter to allow the use of ordinary function as a Querier.
 type UserSubscriptionFunc func(context.Context, *ent.UserSubscriptionQuery) (ent.Value, error)
 
@@ -658,46 +378,26 @@ func (f TraverseUserSubscription) Traverse(ctx context.Context, q ent.Query) err
 // NewQuery returns the generic Query interface for the given typed query.
 func NewQuery(q ent.Query) (Query, error) {
 	switch q := q.(type) {
-	case *ent.APIKeyQuery:
-		return &query[*ent.APIKeyQuery, predicate.APIKey, apikey.OrderOption]{typ: ent.TypeAPIKey, tq: q}, nil
 	case *ent.AccountQuery:
 		return &query[*ent.AccountQuery, predicate.Account, account.OrderOption]{typ: ent.TypeAccount, tq: q}, nil
 	case *ent.AccountGroupQuery:
 		return &query[*ent.AccountGroupQuery, predicate.AccountGroup, accountgroup.OrderOption]{typ: ent.TypeAccountGroup, tq: q}, nil
-	case *ent.AnnouncementQuery:
-		return &query[*ent.AnnouncementQuery, predicate.Announcement, announcement.OrderOption]{typ: ent.TypeAnnouncement, tq: q}, nil
-	case *ent.AnnouncementReadQuery:
-		return &query[*ent.AnnouncementReadQuery, predicate.AnnouncementRead, announcementread.OrderOption]{typ: ent.TypeAnnouncementRead, tq: q}, nil
-	case *ent.ErrorPassthroughRuleQuery:
-		return &query[*ent.ErrorPassthroughRuleQuery, predicate.ErrorPassthroughRule, errorpassthroughrule.OrderOption]{typ: ent.TypeErrorPassthroughRule, tq: q}, nil
+	case *ent.ApiKeyQuery:
+		return &query[*ent.ApiKeyQuery, predicate.ApiKey, apikey.OrderOption]{typ: ent.TypeApiKey, tq: q}, nil
 	case *ent.GroupQuery:
 		return &query[*ent.GroupQuery, predicate.Group, group.OrderOption]{typ: ent.TypeGroup, tq: q}, nil
-	case *ent.IdempotencyRecordQuery:
-		return &query[*ent.IdempotencyRecordQuery, predicate.IdempotencyRecord, idempotencyrecord.OrderOption]{typ: ent.TypeIdempotencyRecord, tq: q}, nil
-	case *ent.PromoCodeQuery:
-		return &query[*ent.PromoCodeQuery, predicate.PromoCode, promocode.OrderOption]{typ: ent.TypePromoCode, tq: q}, nil
-	case *ent.PromoCodeUsageQuery:
-		return &query[*ent.PromoCodeUsageQuery, predicate.PromoCodeUsage, promocodeusage.OrderOption]{typ: ent.TypePromoCodeUsage, tq: q}, nil
 	case *ent.ProxyQuery:
 		return &query[*ent.ProxyQuery, predicate.Proxy, proxy.OrderOption]{typ: ent.TypeProxy, tq: q}, nil
 	case *ent.RedeemCodeQuery:
 		return &query[*ent.RedeemCodeQuery, predicate.RedeemCode, redeemcode.OrderOption]{typ: ent.TypeRedeemCode, tq: q}, nil
-	case *ent.SecuritySecretQuery:
-		return &query[*ent.SecuritySecretQuery, predicate.SecuritySecret, securitysecret.OrderOption]{typ: ent.TypeSecuritySecret, tq: q}, nil
 	case *ent.SettingQuery:
 		return &query[*ent.SettingQuery, predicate.Setting, setting.OrderOption]{typ: ent.TypeSetting, tq: q}, nil
-	case *ent.UsageCleanupTaskQuery:
-		return &query[*ent.UsageCleanupTaskQuery, predicate.UsageCleanupTask, usagecleanuptask.OrderOption]{typ: ent.TypeUsageCleanupTask, tq: q}, nil
 	case *ent.UsageLogQuery:
 		return &query[*ent.UsageLogQuery, predicate.UsageLog, usagelog.OrderOption]{typ: ent.TypeUsageLog, tq: q}, nil
 	case *ent.UserQuery:
 		return &query[*ent.UserQuery, predicate.User, user.OrderOption]{typ: ent.TypeUser, tq: q}, nil
 	case *ent.UserAllowedGroupQuery:
 		return &query[*ent.UserAllowedGroupQuery, predicate.UserAllowedGroup, userallowedgroup.OrderOption]{typ: ent.TypeUserAllowedGroup, tq: q}, nil
-	case *ent.UserAttributeDefinitionQuery:
-		return &query[*ent.UserAttributeDefinitionQuery, predicate.UserAttributeDefinition, userattributedefinition.OrderOption]{typ: ent.TypeUserAttributeDefinition, tq: q}, nil
-	case *ent.UserAttributeValueQuery:
-		return &query[*ent.UserAttributeValueQuery, predicate.UserAttributeValue, userattributevalue.OrderOption]{typ: ent.TypeUserAttributeValue, tq: q}, nil
 	case *ent.UserSubscriptionQuery:
 		return &query[*ent.UserSubscriptionQuery, predicate.UserSubscription, usersubscription.OrderOption]{typ: ent.TypeUserSubscription, tq: q}, nil
 	default:

backend/ent/migrate/schema.go

@@ -9,90 +9,6 @@ import (
 )
 
 var (
-	// APIKeysColumns holds the columns for the "api_keys" table.
-	APIKeysColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "deleted_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "key", Type: field.TypeString, Unique: true, Size: 128},
-		{Name: "name", Type: field.TypeString, Size: 100},
-		{Name: "status", Type: field.TypeString, Size: 20, Default: "active"},
-		{Name: "last_used_at", Type: field.TypeTime, Nullable: true},
-		{Name: "ip_whitelist", Type: field.TypeJSON, Nullable: true},
-		{Name: "ip_blacklist", Type: field.TypeJSON, Nullable: true},
-		{Name: "quota", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "quota_used", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "expires_at", Type: field.TypeTime, Nullable: true},
-		{Name: "rate_limit_5h", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "rate_limit_1d", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "rate_limit_7d", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "usage_5h", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "usage_1d", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "usage_7d", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "window_5h_start", Type: field.TypeTime, Nullable: true},
-		{Name: "window_1d_start", Type: field.TypeTime, Nullable: true},
-		{Name: "window_7d_start", Type: field.TypeTime, Nullable: true},
-		{Name: "group_id", Type: field.TypeInt64, Nullable: true},
-		{Name: "user_id", Type: field.TypeInt64},
-	}
-	// APIKeysTable holds the schema information for the "api_keys" table.
-	APIKeysTable = &schema.Table{
-		Name:       "api_keys",
-		Columns:    APIKeysColumns,
-		PrimaryKey: []*schema.Column{APIKeysColumns[0]},
-		ForeignKeys: []*schema.ForeignKey{
-			{
-				Symbol:     "api_keys_groups_api_keys",
-				Columns:    []*schema.Column{APIKeysColumns[22]},
-				RefColumns: []*schema.Column{GroupsColumns[0]},
-				OnDelete:   schema.SetNull,
-			},
-			{
-				Symbol:     "api_keys_users_api_keys",
-				Columns:    []*schema.Column{APIKeysColumns[23]},
-				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
-		},
-		Indexes: []*schema.Index{
-			{
-				Name:    "apikey_user_id",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[23]},
-			},
-			{
-				Name:    "apikey_group_id",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[22]},
-			},
-			{
-				Name:    "apikey_status",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[6]},
-			},
-			{
-				Name:    "apikey_deleted_at",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[3]},
-			},
-			{
-				Name:    "apikey_last_used_at",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[7]},
-			},
-			{
-				Name:    "apikey_quota_quota_used",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[10], APIKeysColumns[11]},
-			},
-			{
-				Name:    "apikey_expires_at",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[12]},
-			},
-		},
-	}
 	// AccountsColumns holds the columns for the "accounts" table.
 	AccountsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
@@ -100,26 +16,19 @@ var (
 		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
 		{Name: "deleted_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
 		{Name: "name", Type: field.TypeString, Size: 100},
-		{Name: "notes", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "text"}},
 		{Name: "platform", Type: field.TypeString, Size: 50},
 		{Name: "type", Type: field.TypeString, Size: 20},
 		{Name: "credentials", Type: field.TypeJSON, SchemaType: map[string]string{"postgres": "jsonb"}},
 		{Name: "extra", Type: field.TypeJSON, SchemaType: map[string]string{"postgres": "jsonb"}},
 		{Name: "concurrency", Type: field.TypeInt, Default: 3},
-		{Name: "load_factor", Type: field.TypeInt, Nullable: true},
 		{Name: "priority", Type: field.TypeInt, Default: 50},
-		{Name: "rate_multiplier", Type: field.TypeFloat64, Default: 1, SchemaType: map[string]string{"postgres": "decimal(10,4)"}},
 		{Name: "status", Type: field.TypeString, Size: 20, Default: "active"},
 		{Name: "error_message", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "text"}},
 		{Name: "last_used_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "expires_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "auto_pause_on_expired", Type: field.TypeBool, Default: true},
 		{Name: "schedulable", Type: field.TypeBool, Default: true},
 		{Name: "rate_limited_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
 		{Name: "rate_limit_reset_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
 		{Name: "overload_until", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "temp_unschedulable_until", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "temp_unschedulable_reason", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "text"}},
 		{Name: "session_window_start", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
 		{Name: "session_window_end", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
 		{Name: "session_window_status", Type: field.TypeString, Nullable: true, Size: 20},
@@ -133,7 +42,7 @@ var (
 		ForeignKeys: []*schema.ForeignKey{
 			{
 				Symbol:     "accounts_proxies_proxy",
-				Columns:    []*schema.Column{AccountsColumns[28]},
+				Columns:    []*schema.Column{AccountsColumns[21]},
 				RefColumns: []*schema.Column{ProxiesColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
@@ -142,62 +51,52 @@ var (
 			{
 				Name:    "account_platform",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[6]},
+				Columns: []*schema.Column{AccountsColumns[5]},
 			},
 			{
 				Name:    "account_type",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[7]},
+				Columns: []*schema.Column{AccountsColumns[6]},
 			},
 			{
 				Name:    "account_status",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[14]},
+				Columns: []*schema.Column{AccountsColumns[11]},
 			},
 			{
 				Name:    "account_proxy_id",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[28]},
+				Columns: []*schema.Column{AccountsColumns[21]},
 			},
 			{
 				Name:    "account_priority",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[12]},
+				Columns: []*schema.Column{AccountsColumns[10]},
 			},
 			{
 				Name:    "account_last_used_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[16]},
+				Columns: []*schema.Column{AccountsColumns[13]},
 			},
 			{
 				Name:    "account_schedulable",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[19]},
+				Columns: []*schema.Column{AccountsColumns[14]},
 			},
 			{
 				Name:    "account_rate_limited_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[20]},
+				Columns: []*schema.Column{AccountsColumns[15]},
 			},
 			{
 				Name:    "account_rate_limit_reset_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[21]},
+				Columns: []*schema.Column{AccountsColumns[16]},
 			},
 			{
 				Name:    "account_overload_until",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[22]},
-			},
-			{
-				Name:    "account_platform_priority",
-				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[6], AccountsColumns[12]},
-			},
-			{
-				Name:    "account_priority_status",
-				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[12], AccountsColumns[14]},
+				Columns: []*schema.Column{AccountsColumns[17]},
 			},
 			{
 				Name:    "account_deleted_at",
@@ -245,133 +144,57 @@ var (
 			},
 		},
 	}
-	// AnnouncementsColumns holds the columns for the "announcements" table.
-	AnnouncementsColumns = []*schema.Column{
+	// APIKeysColumns holds the columns for the "api_keys" table.
+	APIKeysColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "title", Type: field.TypeString, Size: 200},
-		{Name: "content", Type: field.TypeString, SchemaType: map[string]string{"postgres": "text"}},
-		{Name: "status", Type: field.TypeString, Size: 20, Default: "draft"},
-		{Name: "notify_mode", Type: field.TypeString, Size: 20, Default: "silent"},
-		{Name: "targeting", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "starts_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "ends_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "created_by", Type: field.TypeInt64, Nullable: true},
-		{Name: "updated_by", Type: field.TypeInt64, Nullable: true},
 		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
 		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-	}
-	// AnnouncementsTable holds the schema information for the "announcements" table.
-	AnnouncementsTable = &schema.Table{
-		Name:       "announcements",
-		Columns:    AnnouncementsColumns,
-		PrimaryKey: []*schema.Column{AnnouncementsColumns[0]},
-		Indexes: []*schema.Index{
-			{
-				Name:    "announcement_status",
-				Unique:  false,
-				Columns: []*schema.Column{AnnouncementsColumns[3]},
-			},
-			{
-				Name:    "announcement_created_at",
-				Unique:  false,
-				Columns: []*schema.Column{AnnouncementsColumns[10]},
-			},
-			{
-				Name:    "announcement_starts_at",
-				Unique:  false,
-				Columns: []*schema.Column{AnnouncementsColumns[6]},
-			},
-			{
-				Name:    "announcement_ends_at",
-				Unique:  false,
-				Columns: []*schema.Column{AnnouncementsColumns[7]},
-			},
-		},
-	}
-	// AnnouncementReadsColumns holds the columns for the "announcement_reads" table.
-	AnnouncementReadsColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "read_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "announcement_id", Type: field.TypeInt64},
+		{Name: "deleted_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
+		{Name: "key", Type: field.TypeString, Unique: true, Size: 128},
+		{Name: "name", Type: field.TypeString, Size: 100},
+		{Name: "status", Type: field.TypeString, Size: 20, Default: "active"},
+		{Name: "group_id", Type: field.TypeInt64, Nullable: true},
 		{Name: "user_id", Type: field.TypeInt64},
 	}
-	// AnnouncementReadsTable holds the schema information for the "announcement_reads" table.
-	AnnouncementReadsTable = &schema.Table{
-		Name:       "announcement_reads",
-		Columns:    AnnouncementReadsColumns,
-		PrimaryKey: []*schema.Column{AnnouncementReadsColumns[0]},
+	// APIKeysTable holds the schema information for the "api_keys" table.
+	APIKeysTable = &schema.Table{
+		Name:       "api_keys",
+		Columns:    APIKeysColumns,
+		PrimaryKey: []*schema.Column{APIKeysColumns[0]},
 		ForeignKeys: []*schema.ForeignKey{
 			{
-				Symbol:     "announcement_reads_announcements_reads",
-				Columns:    []*schema.Column{AnnouncementReadsColumns[3]},
-				RefColumns: []*schema.Column{AnnouncementsColumns[0]},
-				OnDelete:   schema.NoAction,
+				Symbol:     "api_keys_groups_api_keys",
+				Columns:    []*schema.Column{APIKeysColumns[7]},
+				RefColumns: []*schema.Column{GroupsColumns[0]},
+				OnDelete:   schema.SetNull,
 			},
 			{
-				Symbol:     "announcement_reads_users_announcement_reads",
-				Columns:    []*schema.Column{AnnouncementReadsColumns[4]},
+				Symbol:     "api_keys_users_api_keys",
+				Columns:    []*schema.Column{APIKeysColumns[8]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
 		},
 		Indexes: []*schema.Index{
 			{
-				Name:    "announcementread_announcement_id",
+				Name:    "apikey_user_id",
 				Unique:  false,
-				Columns: []*schema.Column{AnnouncementReadsColumns[3]},
+				Columns: []*schema.Column{APIKeysColumns[8]},
 			},
 			{
-				Name:    "announcementread_user_id",
+				Name:    "apikey_group_id",
 				Unique:  false,
-				Columns: []*schema.Column{AnnouncementReadsColumns[4]},
+				Columns: []*schema.Column{APIKeysColumns[7]},
 			},
 			{
-				Name:    "announcementread_read_at",
+				Name:    "apikey_status",
 				Unique:  false,
-				Columns: []*schema.Column{AnnouncementReadsColumns[1]},
+				Columns: []*schema.Column{APIKeysColumns[6]},
 			},
 			{
-				Name:    "announcementread_announcement_id_user_id",
-				Unique:  true,
-				Columns: []*schema.Column{AnnouncementReadsColumns[3], AnnouncementReadsColumns[4]},
-			},
-		},
-	}
-	// ErrorPassthroughRulesColumns holds the columns for the "error_passthrough_rules" table.
-	ErrorPassthroughRulesColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "name", Type: field.TypeString, Size: 100},
-		{Name: "enabled", Type: field.TypeBool, Default: true},
-		{Name: "priority", Type: field.TypeInt, Default: 0},
-		{Name: "error_codes", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "keywords", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "match_mode", Type: field.TypeString, Size: 10, Default: "any"},
-		{Name: "platforms", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "passthrough_code", Type: field.TypeBool, Default: true},
-		{Name: "response_code", Type: field.TypeInt, Nullable: true},
-		{Name: "passthrough_body", Type: field.TypeBool, Default: true},
-		{Name: "custom_message", Type: field.TypeString, Nullable: true, Size: 2147483647},
-		{Name: "skip_monitoring", Type: field.TypeBool, Default: false},
-		{Name: "description", Type: field.TypeString, Nullable: true, Size: 2147483647},
-	}
-	// ErrorPassthroughRulesTable holds the schema information for the "error_passthrough_rules" table.
-	ErrorPassthroughRulesTable = &schema.Table{
-		Name:       "error_passthrough_rules",
-		Columns:    ErrorPassthroughRulesColumns,
-		PrimaryKey: []*schema.Column{ErrorPassthroughRulesColumns[0]},
-		Indexes: []*schema.Index{
-			{
-				Name:    "errorpassthroughrule_enabled",
+				Name:    "apikey_deleted_at",
 				Unique:  false,
-				Columns: []*schema.Column{ErrorPassthroughRulesColumns[4]},
-			},
-			{
-				Name:    "errorpassthroughrule_priority",
-				Unique:  false,
-				Columns: []*schema.Column{ErrorPassthroughRulesColumns[5]},
+				Columns: []*schema.Column{APIKeysColumns[3]},
 			},
 		},
 	}
@@ -392,24 +215,6 @@ var (
 		{Name: "weekly_limit_usd", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
 		{Name: "monthly_limit_usd", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
 		{Name: "default_validity_days", Type: field.TypeInt, Default: 30},
-		{Name: "image_price_1k", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "image_price_2k", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "image_price_4k", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "sora_image_price_360", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "sora_image_price_540", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "sora_video_price_per_request", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "sora_video_price_per_request_hd", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "sora_storage_quota_bytes", Type: field.TypeInt64, Default: 0},
-		{Name: "claude_code_only", Type: field.TypeBool, Default: false},
-		{Name: "fallback_group_id", Type: field.TypeInt64, Nullable: true},
-		{Name: "fallback_group_id_on_invalid_request", Type: field.TypeInt64, Nullable: true},
-		{Name: "model_routing", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "model_routing_enabled", Type: field.TypeBool, Default: false},
-		{Name: "mcp_xml_inject", Type: field.TypeBool, Default: true},
-		{Name: "supported_model_scopes", Type: field.TypeJSON, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "sort_order", Type: field.TypeInt, Default: 0},
-		{Name: "allow_messages_dispatch", Type: field.TypeBool, Default: false},
-		{Name: "default_mapped_model", Type: field.TypeString, Size: 100, Default: ""},
 	}
 	// GroupsTable holds the schema information for the "groups" table.
 	GroupsTable = &schema.Table{
@@ -442,125 +247,6 @@ var (
 				Unique:  false,
 				Columns: []*schema.Column{GroupsColumns[3]},
 			},
-			{
-				Name:    "group_sort_order",
-				Unique:  false,
-				Columns: []*schema.Column{GroupsColumns[30]},
-			},
-		},
-	}
-	// IdempotencyRecordsColumns holds the columns for the "idempotency_records" table.
-	IdempotencyRecordsColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "scope", Type: field.TypeString, Size: 128},
-		{Name: "idempotency_key_hash", Type: field.TypeString, Size: 64},
-		{Name: "request_fingerprint", Type: field.TypeString, Size: 64},
-		{Name: "status", Type: field.TypeString, Size: 32},
-		{Name: "response_status", Type: field.TypeInt, Nullable: true},
-		{Name: "response_body", Type: field.TypeString, Nullable: true},
-		{Name: "error_reason", Type: field.TypeString, Nullable: true, Size: 128},
-		{Name: "locked_until", Type: field.TypeTime, Nullable: true},
-		{Name: "expires_at", Type: field.TypeTime},
-	}
-	// IdempotencyRecordsTable holds the schema information for the "idempotency_records" table.
-	IdempotencyRecordsTable = &schema.Table{
-		Name:       "idempotency_records",
-		Columns:    IdempotencyRecordsColumns,
-		PrimaryKey: []*schema.Column{IdempotencyRecordsColumns[0]},
-		Indexes: []*schema.Index{
-			{
-				Name:    "idempotencyrecord_scope_idempotency_key_hash",
-				Unique:  true,
-				Columns: []*schema.Column{IdempotencyRecordsColumns[3], IdempotencyRecordsColumns[4]},
-			},
-			{
-				Name:    "idempotencyrecord_expires_at",
-				Unique:  false,
-				Columns: []*schema.Column{IdempotencyRecordsColumns[11]},
-			},
-			{
-				Name:    "idempotencyrecord_status_locked_until",
-				Unique:  false,
-				Columns: []*schema.Column{IdempotencyRecordsColumns[6], IdempotencyRecordsColumns[10]},
-			},
-		},
-	}
-	// PromoCodesColumns holds the columns for the "promo_codes" table.
-	PromoCodesColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "code", Type: field.TypeString, Unique: true, Size: 32},
-		{Name: "bonus_amount", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "max_uses", Type: field.TypeInt, Default: 0},
-		{Name: "used_count", Type: field.TypeInt, Default: 0},
-		{Name: "status", Type: field.TypeString, Size: 20, Default: "active"},
-		{Name: "expires_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "notes", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "text"}},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-	}
-	// PromoCodesTable holds the schema information for the "promo_codes" table.
-	PromoCodesTable = &schema.Table{
-		Name:       "promo_codes",
-		Columns:    PromoCodesColumns,
-		PrimaryKey: []*schema.Column{PromoCodesColumns[0]},
-		Indexes: []*schema.Index{
-			{
-				Name:    "promocode_status",
-				Unique:  false,
-				Columns: []*schema.Column{PromoCodesColumns[5]},
-			},
-			{
-				Name:    "promocode_expires_at",
-				Unique:  false,
-				Columns: []*schema.Column{PromoCodesColumns[6]},
-			},
-		},
-	}
-	// PromoCodeUsagesColumns holds the columns for the "promo_code_usages" table.
-	PromoCodeUsagesColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "bonus_amount", Type: field.TypeFloat64, SchemaType: map[string]string{"postgres": "decimal(20,8)"}},
-		{Name: "used_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "promo_code_id", Type: field.TypeInt64},
-		{Name: "user_id", Type: field.TypeInt64},
-	}
-	// PromoCodeUsagesTable holds the schema information for the "promo_code_usages" table.
-	PromoCodeUsagesTable = &schema.Table{
-		Name:       "promo_code_usages",
-		Columns:    PromoCodeUsagesColumns,
-		PrimaryKey: []*schema.Column{PromoCodeUsagesColumns[0]},
-		ForeignKeys: []*schema.ForeignKey{
-			{
-				Symbol:     "promo_code_usages_promo_codes_usage_records",
-				Columns:    []*schema.Column{PromoCodeUsagesColumns[3]},
-				RefColumns: []*schema.Column{PromoCodesColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
-			{
-				Symbol:     "promo_code_usages_users_promo_code_usages",
-				Columns:    []*schema.Column{PromoCodeUsagesColumns[4]},
-				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
-		},
-		Indexes: []*schema.Index{
-			{
-				Name:    "promocodeusage_promo_code_id",
-				Unique:  false,
-				Columns: []*schema.Column{PromoCodeUsagesColumns[3]},
-			},
-			{
-				Name:    "promocodeusage_user_id",
-				Unique:  false,
-				Columns: []*schema.Column{PromoCodeUsagesColumns[4]},
-			},
-			{
-				Name:    "promocodeusage_promo_code_id_user_id",
-				Unique:  true,
-				Columns: []*schema.Column{PromoCodeUsagesColumns[3], PromoCodeUsagesColumns[4]},
-			},
 		},
 	}
 	// ProxiesColumns holds the columns for the "proxies" table.
@@ -646,20 +332,6 @@ var (
 			},
 		},
 	}
-	// SecuritySecretsColumns holds the columns for the "security_secrets" table.
-	SecuritySecretsColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "key", Type: field.TypeString, Unique: true, Size: 100},
-		{Name: "value", Type: field.TypeString, SchemaType: map[string]string{"postgres": "text"}},
-	}
-	// SecuritySecretsTable holds the schema information for the "security_secrets" table.
-	SecuritySecretsTable = &schema.Table{
-		Name:       "security_secrets",
-		Columns:    SecuritySecretsColumns,
-		PrimaryKey: []*schema.Column{SecuritySecretsColumns[0]},
-	}
 	// SettingsColumns holds the columns for the "settings" table.
 	SettingsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
@@ -673,44 +345,6 @@ var (
 		Columns:    SettingsColumns,
 		PrimaryKey: []*schema.Column{SettingsColumns[0]},
 	}
-	// UsageCleanupTasksColumns holds the columns for the "usage_cleanup_tasks" table.
-	UsageCleanupTasksColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "status", Type: field.TypeString, Size: 20},
-		{Name: "filters", Type: field.TypeJSON},
-		{Name: "created_by", Type: field.TypeInt64},
-		{Name: "deleted_rows", Type: field.TypeInt64, Default: 0},
-		{Name: "error_message", Type: field.TypeString, Nullable: true},
-		{Name: "canceled_by", Type: field.TypeInt64, Nullable: true},
-		{Name: "canceled_at", Type: field.TypeTime, Nullable: true},
-		{Name: "started_at", Type: field.TypeTime, Nullable: true},
-		{Name: "finished_at", Type: field.TypeTime, Nullable: true},
-	}
-	// UsageCleanupTasksTable holds the schema information for the "usage_cleanup_tasks" table.
-	UsageCleanupTasksTable = &schema.Table{
-		Name:       "usage_cleanup_tasks",
-		Columns:    UsageCleanupTasksColumns,
-		PrimaryKey: []*schema.Column{UsageCleanupTasksColumns[0]},
-		Indexes: []*schema.Index{
-			{
-				Name:    "usagecleanuptask_status_created_at",
-				Unique:  false,
-				Columns: []*schema.Column{UsageCleanupTasksColumns[3], UsageCleanupTasksColumns[1]},
-			},
-			{
-				Name:    "usagecleanuptask_created_at",
-				Unique:  false,
-				Columns: []*schema.Column{UsageCleanupTasksColumns[1]},
-			},
-			{
-				Name:    "usagecleanuptask_canceled_at",
-				Unique:  false,
-				Columns: []*schema.Column{UsageCleanupTasksColumns[9]},
-			},
-		},
-	}
 	// UsageLogsColumns holds the columns for the "usage_logs" table.
 	UsageLogsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
@@ -729,20 +363,13 @@ var (
 		{Name: "total_cost", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,10)"}},
 		{Name: "actual_cost", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,10)"}},
 		{Name: "rate_multiplier", Type: field.TypeFloat64, Default: 1, SchemaType: map[string]string{"postgres": "decimal(10,4)"}},
-		{Name: "account_rate_multiplier", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(10,4)"}},
 		{Name: "billing_type", Type: field.TypeInt8, Default: 0},
 		{Name: "stream", Type: field.TypeBool, Default: false},
 		{Name: "duration_ms", Type: field.TypeInt, Nullable: true},
 		{Name: "first_token_ms", Type: field.TypeInt, Nullable: true},
-		{Name: "user_agent", Type: field.TypeString, Nullable: true, Size: 512},
-		{Name: "ip_address", Type: field.TypeString, Nullable: true, Size: 45},
-		{Name: "image_count", Type: field.TypeInt, Default: 0},
-		{Name: "image_size", Type: field.TypeString, Nullable: true, Size: 10},
-		{Name: "media_type", Type: field.TypeString, Nullable: true, Size: 16},
-		{Name: "cache_ttl_overridden", Type: field.TypeBool, Default: false},
 		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "api_key_id", Type: field.TypeInt64},
 		{Name: "account_id", Type: field.TypeInt64},
+		{Name: "api_key_id", Type: field.TypeInt64},
 		{Name: "group_id", Type: field.TypeInt64, Nullable: true},
 		{Name: "user_id", Type: field.TypeInt64},
 		{Name: "subscription_id", Type: field.TypeInt64, Nullable: true},
@@ -753,33 +380,33 @@ var (
 		Columns:    UsageLogsColumns,
 		PrimaryKey: []*schema.Column{UsageLogsColumns[0]},
 		ForeignKeys: []*schema.ForeignKey{
-			{
-				Symbol:     "usage_logs_api_keys_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[28]},
-				RefColumns: []*schema.Column{APIKeysColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
 			{
 				Symbol:     "usage_logs_accounts_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[29]},
+				Columns:    []*schema.Column{UsageLogsColumns[21]},
 				RefColumns: []*schema.Column{AccountsColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
+			{
+				Symbol:     "usage_logs_api_keys_usage_logs",
+				Columns:    []*schema.Column{UsageLogsColumns[22]},
+				RefColumns: []*schema.Column{APIKeysColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
 			{
 				Symbol:     "usage_logs_groups_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[30]},
+				Columns:    []*schema.Column{UsageLogsColumns[23]},
 				RefColumns: []*schema.Column{GroupsColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
 			{
 				Symbol:     "usage_logs_users_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[31]},
+				Columns:    []*schema.Column{UsageLogsColumns[24]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
 			{
 				Symbol:     "usage_logs_user_subscriptions_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[32]},
+				Columns:    []*schema.Column{UsageLogsColumns[25]},
 				RefColumns: []*schema.Column{UserSubscriptionsColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
@@ -788,32 +415,32 @@ var (
 			{
 				Name:    "usagelog_user_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[31]},
+				Columns: []*schema.Column{UsageLogsColumns[24]},
 			},
 			{
 				Name:    "usagelog_api_key_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[28]},
+				Columns: []*schema.Column{UsageLogsColumns[22]},
 			},
 			{
 				Name:    "usagelog_account_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[29]},
+				Columns: []*schema.Column{UsageLogsColumns[21]},
 			},
 			{
 				Name:    "usagelog_group_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[30]},
+				Columns: []*schema.Column{UsageLogsColumns[23]},
 			},
 			{
 				Name:    "usagelog_subscription_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[32]},
+				Columns: []*schema.Column{UsageLogsColumns[25]},
 			},
 			{
 				Name:    "usagelog_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[27]},
+				Columns: []*schema.Column{UsageLogsColumns[20]},
 			},
 			{
 				Name:    "usagelog_model",
@@ -828,17 +455,12 @@ var (
 			{
 				Name:    "usagelog_user_id_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[31], UsageLogsColumns[27]},
+				Columns: []*schema.Column{UsageLogsColumns[24], UsageLogsColumns[20]},
 			},
 			{
 				Name:    "usagelog_api_key_id_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[28], UsageLogsColumns[27]},
-			},
-			{
-				Name:    "usagelog_group_id_created_at",
-				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[30], UsageLogsColumns[27]},
+				Columns: []*schema.Column{UsageLogsColumns[22], UsageLogsColumns[20]},
 			},
 		},
 	}
@@ -855,12 +477,8 @@ var (
 		{Name: "concurrency", Type: field.TypeInt, Default: 5},
 		{Name: "status", Type: field.TypeString, Size: 20, Default: "active"},
 		{Name: "username", Type: field.TypeString, Size: 100, Default: ""},
+		{Name: "wechat", Type: field.TypeString, Size: 100, Default: ""},
 		{Name: "notes", Type: field.TypeString, Default: "", SchemaType: map[string]string{"postgres": "text"}},
-		{Name: "totp_secret_encrypted", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "text"}},
-		{Name: "totp_enabled", Type: field.TypeBool, Default: false},
-		{Name: "totp_enabled_at", Type: field.TypeTime, Nullable: true},
-		{Name: "sora_storage_quota_bytes", Type: field.TypeInt64, Default: 0},
-		{Name: "sora_storage_used_bytes", Type: field.TypeInt64, Default: 0},
 	}
 	// UsersTable holds the schema information for the "users" table.
 	UsersTable = &schema.Table{
@@ -913,92 +531,6 @@ var (
 			},
 		},
 	}
-	// UserAttributeDefinitionsColumns holds the columns for the "user_attribute_definitions" table.
-	UserAttributeDefinitionsColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "deleted_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "key", Type: field.TypeString, Size: 100},
-		{Name: "name", Type: field.TypeString, Size: 255},
-		{Name: "description", Type: field.TypeString, Default: "", SchemaType: map[string]string{"postgres": "text"}},
-		{Name: "type", Type: field.TypeString, Size: 20},
-		{Name: "options", Type: field.TypeJSON, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "required", Type: field.TypeBool, Default: false},
-		{Name: "validation", Type: field.TypeJSON, SchemaType: map[string]string{"postgres": "jsonb"}},
-		{Name: "placeholder", Type: field.TypeString, Size: 255, Default: ""},
-		{Name: "display_order", Type: field.TypeInt, Default: 0},
-		{Name: "enabled", Type: field.TypeBool, Default: true},
-	}
-	// UserAttributeDefinitionsTable holds the schema information for the "user_attribute_definitions" table.
-	UserAttributeDefinitionsTable = &schema.Table{
-		Name:       "user_attribute_definitions",
-		Columns:    UserAttributeDefinitionsColumns,
-		PrimaryKey: []*schema.Column{UserAttributeDefinitionsColumns[0]},
-		Indexes: []*schema.Index{
-			{
-				Name:    "userattributedefinition_key",
-				Unique:  false,
-				Columns: []*schema.Column{UserAttributeDefinitionsColumns[4]},
-			},
-			{
-				Name:    "userattributedefinition_enabled",
-				Unique:  false,
-				Columns: []*schema.Column{UserAttributeDefinitionsColumns[13]},
-			},
-			{
-				Name:    "userattributedefinition_display_order",
-				Unique:  false,
-				Columns: []*schema.Column{UserAttributeDefinitionsColumns[12]},
-			},
-			{
-				Name:    "userattributedefinition_deleted_at",
-				Unique:  false,
-				Columns: []*schema.Column{UserAttributeDefinitionsColumns[3]},
-			},
-		},
-	}
-	// UserAttributeValuesColumns holds the columns for the "user_attribute_values" table.
-	UserAttributeValuesColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt64, Increment: true},
-		{Name: "created_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "updated_at", Type: field.TypeTime, SchemaType: map[string]string{"postgres": "timestamptz"}},
-		{Name: "value", Type: field.TypeString, Size: 2147483647, Default: ""},
-		{Name: "user_id", Type: field.TypeInt64},
-		{Name: "attribute_id", Type: field.TypeInt64},
-	}
-	// UserAttributeValuesTable holds the schema information for the "user_attribute_values" table.
-	UserAttributeValuesTable = &schema.Table{
-		Name:       "user_attribute_values",
-		Columns:    UserAttributeValuesColumns,
-		PrimaryKey: []*schema.Column{UserAttributeValuesColumns[0]},
-		ForeignKeys: []*schema.ForeignKey{
-			{
-				Symbol:     "user_attribute_values_users_attribute_values",
-				Columns:    []*schema.Column{UserAttributeValuesColumns[4]},
-				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
-			{
-				Symbol:     "user_attribute_values_user_attribute_definitions_values",
-				Columns:    []*schema.Column{UserAttributeValuesColumns[5]},
-				RefColumns: []*schema.Column{UserAttributeDefinitionsColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
-		},
-		Indexes: []*schema.Index{
-			{
-				Name:    "userattributevalue_user_id_attribute_id",
-				Unique:  true,
-				Columns: []*schema.Column{UserAttributeValuesColumns[4], UserAttributeValuesColumns[5]},
-			},
-			{
-				Name:    "userattributevalue_attribute_id",
-				Unique:  false,
-				Columns: []*schema.Column{UserAttributeValuesColumns[5]},
-			},
-		},
-	}
 	// UserSubscriptionsColumns holds the columns for the "user_subscriptions" table.
 	UserSubscriptionsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
@@ -1066,11 +598,6 @@ var (
 				Unique:  false,
 				Columns: []*schema.Column{UserSubscriptionsColumns[5]},
 			},
-			{
-				Name:    "usersubscription_user_id_status_expires_at",
-				Unique:  false,
-				Columns: []*schema.Column{UserSubscriptionsColumns[16], UserSubscriptionsColumns[6], UserSubscriptionsColumns[5]},
-			},
 			{
 				Name:    "usersubscription_assigned_by",
 				Unique:  false,
@@ -1090,36 +617,21 @@ var (
 	}
 	// Tables holds all the tables in the schema.
 	Tables = []*schema.Table{
-		APIKeysTable,
 		AccountsTable,
 		AccountGroupsTable,
-		AnnouncementsTable,
-		AnnouncementReadsTable,
-		ErrorPassthroughRulesTable,
+		APIKeysTable,
 		GroupsTable,
-		IdempotencyRecordsTable,
-		PromoCodesTable,
-		PromoCodeUsagesTable,
 		ProxiesTable,
 		RedeemCodesTable,
-		SecuritySecretsTable,
 		SettingsTable,
-		UsageCleanupTasksTable,
 		UsageLogsTable,
 		UsersTable,
 		UserAllowedGroupsTable,
-		UserAttributeDefinitionsTable,
-		UserAttributeValuesTable,
 		UserSubscriptionsTable,
 	}
 )
 
 func init() {
-	APIKeysTable.ForeignKeys[0].RefTable = GroupsTable
-	APIKeysTable.ForeignKeys[1].RefTable = UsersTable
-	APIKeysTable.Annotation = &entsql.Annotation{
-		Table: "api_keys",
-	}
 	AccountsTable.ForeignKeys[0].RefTable = ProxiesTable
 	AccountsTable.Annotation = &entsql.Annotation{
 		Table: "accounts",
@@ -1129,31 +641,14 @@ func init() {
 	AccountGroupsTable.Annotation = &entsql.Annotation{
 		Table: "account_groups",
 	}
-	AnnouncementsTable.Annotation = &entsql.Annotation{
-		Table: "announcements",
-	}
-	AnnouncementReadsTable.ForeignKeys[0].RefTable = AnnouncementsTable
-	AnnouncementReadsTable.ForeignKeys[1].RefTable = UsersTable
-	AnnouncementReadsTable.Annotation = &entsql.Annotation{
-		Table: "announcement_reads",
-	}
-	ErrorPassthroughRulesTable.Annotation = &entsql.Annotation{
-		Table: "error_passthrough_rules",
+	APIKeysTable.ForeignKeys[0].RefTable = GroupsTable
+	APIKeysTable.ForeignKeys[1].RefTable = UsersTable
+	APIKeysTable.Annotation = &entsql.Annotation{
+		Table: "api_keys",
 	}
 	GroupsTable.Annotation = &entsql.Annotation{
 		Table: "groups",
 	}
-	IdempotencyRecordsTable.Annotation = &entsql.Annotation{
-		Table: "idempotency_records",
-	}
-	PromoCodesTable.Annotation = &entsql.Annotation{
-		Table: "promo_codes",
-	}
-	PromoCodeUsagesTable.ForeignKeys[0].RefTable = PromoCodesTable
-	PromoCodeUsagesTable.ForeignKeys[1].RefTable = UsersTable
-	PromoCodeUsagesTable.Annotation = &entsql.Annotation{
-		Table: "promo_code_usages",
-	}
 	ProxiesTable.Annotation = &entsql.Annotation{
 		Table: "proxies",
 	}
@@ -1162,17 +657,11 @@ func init() {
 	RedeemCodesTable.Annotation = &entsql.Annotation{
 		Table: "redeem_codes",
 	}
-	SecuritySecretsTable.Annotation = &entsql.Annotation{
-		Table: "security_secrets",
-	}
 	SettingsTable.Annotation = &entsql.Annotation{
 		Table: "settings",
 	}
-	UsageCleanupTasksTable.Annotation = &entsql.Annotation{
-		Table: "usage_cleanup_tasks",
-	}
-	UsageLogsTable.ForeignKeys[0].RefTable = APIKeysTable
-	UsageLogsTable.ForeignKeys[1].RefTable = AccountsTable
+	UsageLogsTable.ForeignKeys[0].RefTable = AccountsTable
+	UsageLogsTable.ForeignKeys[1].RefTable = APIKeysTable
 	UsageLogsTable.ForeignKeys[2].RefTable = GroupsTable
 	UsageLogsTable.ForeignKeys[3].RefTable = UsersTable
 	UsageLogsTable.ForeignKeys[4].RefTable = UserSubscriptionsTable
@@ -1187,14 +676,6 @@ func init() {
 	UserAllowedGroupsTable.Annotation = &entsql.Annotation{
 		Table: "user_allowed_groups",
 	}
-	UserAttributeDefinitionsTable.Annotation = &entsql.Annotation{
-		Table: "user_attribute_definitions",
-	}
-	UserAttributeValuesTable.ForeignKeys[0].RefTable = UsersTable
-	UserAttributeValuesTable.ForeignKeys[1].RefTable = UserAttributeDefinitionsTable
-	UserAttributeValuesTable.Annotation = &entsql.Annotation{
-		Table: "user_attribute_values",
-	}
 	UserSubscriptionsTable.ForeignKeys[0].RefTable = GroupsTable
 	UserSubscriptionsTable.ForeignKeys[1].RefTable = UsersTable
 	UserSubscriptionsTable.ForeignKeys[2].RefTable = UsersTable

backend/ent/predicate/predicate.go

@@ -6,51 +6,27 @@ import (
 	"entgo.io/ent/dialect/sql"
 )
 
-// APIKey is the predicate function for apikey builders.
-type APIKey func(*sql.Selector)
-
 // Account is the predicate function for account builders.
 type Account func(*sql.Selector)
 
 // AccountGroup is the predicate function for accountgroup builders.
 type AccountGroup func(*sql.Selector)
 
-// Announcement is the predicate function for announcement builders.
-type Announcement func(*sql.Selector)
-
-// AnnouncementRead is the predicate function for announcementread builders.
-type AnnouncementRead func(*sql.Selector)
-
-// ErrorPassthroughRule is the predicate function for errorpassthroughrule builders.
-type ErrorPassthroughRule func(*sql.Selector)
+// ApiKey is the predicate function for apikey builders.
+type ApiKey func(*sql.Selector)
 
 // Group is the predicate function for group builders.
 type Group func(*sql.Selector)
 
-// IdempotencyRecord is the predicate function for idempotencyrecord builders.
-type IdempotencyRecord func(*sql.Selector)
-
-// PromoCode is the predicate function for promocode builders.
-type PromoCode func(*sql.Selector)
-
-// PromoCodeUsage is the predicate function for promocodeusage builders.
-type PromoCodeUsage func(*sql.Selector)
-
 // Proxy is the predicate function for proxy builders.
 type Proxy func(*sql.Selector)
 
 // RedeemCode is the predicate function for redeemcode builders.
 type RedeemCode func(*sql.Selector)
 
-// SecuritySecret is the predicate function for securitysecret builders.
-type SecuritySecret func(*sql.Selector)
-
 // Setting is the predicate function for setting builders.
 type Setting func(*sql.Selector)
 
-// UsageCleanupTask is the predicate function for usagecleanuptask builders.
-type UsageCleanupTask func(*sql.Selector)
-
 // UsageLog is the predicate function for usagelog builders.
 type UsageLog func(*sql.Selector)
 
@@ -60,11 +36,5 @@ type User func(*sql.Selector)
 // UserAllowedGroup is the predicate function for userallowedgroup builders.
 type UserAllowedGroup func(*sql.Selector)
 
-// UserAttributeDefinition is the predicate function for userattributedefinition builders.
-type UserAttributeDefinition func(*sql.Selector)
-
-// UserAttributeValue is the predicate function for userattributevalue builders.
-type UserAttributeValue func(*sql.Selector)
-
 // UserSubscription is the predicate function for usersubscription builders.
 type UserSubscription func(*sql.Selector)

backend/ent/promocode.go

@@ -1,228 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-)
-
-// PromoCode is the model entity for the PromoCode schema.
-type PromoCode struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int64 `json:"id,omitempty"`
-	// 优惠码
-	Code string `json:"code,omitempty"`
-	// 赠送余额金额
-	BonusAmount float64 `json:"bonus_amount,omitempty"`
-	// 最大使用次数，0表示无限制
-	MaxUses int `json:"max_uses,omitempty"`
-	// 已使用次数
-	UsedCount int `json:"used_count,omitempty"`
-	// 状态: active, disabled
-	Status string `json:"status,omitempty"`
-	// 过期时间，null表示永不过期
-	ExpiresAt *time.Time `json:"expires_at,omitempty"`
-	// 备注
-	Notes *string `json:"notes,omitempty"`
-	// CreatedAt holds the value of the "created_at" field.
-	CreatedAt time.Time `json:"created_at,omitempty"`
-	// UpdatedAt holds the value of the "updated_at" field.
-	UpdatedAt time.Time `json:"updated_at,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the PromoCodeQuery when eager-loading is set.
-	Edges        PromoCodeEdges `json:"edges"`
-	selectValues sql.SelectValues
-}
-
-// PromoCodeEdges holds the relations/edges for other nodes in the graph.
-type PromoCodeEdges struct {
-	// UsageRecords holds the value of the usage_records edge.
-	UsageRecords []*PromoCodeUsage `json:"usage_records,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [1]bool
-}
-
-// UsageRecordsOrErr returns the UsageRecords value or an error if the edge
-// was not loaded in eager-loading.
-func (e PromoCodeEdges) UsageRecordsOrErr() ([]*PromoCodeUsage, error) {
-	if e.loadedTypes[0] {
-		return e.UsageRecords, nil
-	}
-	return nil, &NotLoadedError{edge: "usage_records"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*PromoCode) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case promocode.FieldBonusAmount:
-			values[i] = new(sql.NullFloat64)
-		case promocode.FieldID, promocode.FieldMaxUses, promocode.FieldUsedCount:
-			values[i] = new(sql.NullInt64)
-		case promocode.FieldCode, promocode.FieldStatus, promocode.FieldNotes:
-			values[i] = new(sql.NullString)
-		case promocode.FieldExpiresAt, promocode.FieldCreatedAt, promocode.FieldUpdatedAt:
-			values[i] = new(sql.NullTime)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the PromoCode fields.
-func (_m *PromoCode) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case promocode.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			_m.ID = int64(value.Int64)
-		case promocode.FieldCode:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field code", values[i])
-			} else if value.Valid {
-				_m.Code = value.String
-			}
-		case promocode.FieldBonusAmount:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field bonus_amount", values[i])
-			} else if value.Valid {
-				_m.BonusAmount = value.Float64
-			}
-		case promocode.FieldMaxUses:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field max_uses", values[i])
-			} else if value.Valid {
-				_m.MaxUses = int(value.Int64)
-			}
-		case promocode.FieldUsedCount:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field used_count", values[i])
-			} else if value.Valid {
-				_m.UsedCount = int(value.Int64)
-			}
-		case promocode.FieldStatus:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field status", values[i])
-			} else if value.Valid {
-				_m.Status = value.String
-			}
-		case promocode.FieldExpiresAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field expires_at", values[i])
-			} else if value.Valid {
-				_m.ExpiresAt = new(time.Time)
-				*_m.ExpiresAt = value.Time
-			}
-		case promocode.FieldNotes:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field notes", values[i])
-			} else if value.Valid {
-				_m.Notes = new(string)
-				*_m.Notes = value.String
-			}
-		case promocode.FieldCreatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field created_at", values[i])
-			} else if value.Valid {
-				_m.CreatedAt = value.Time
-			}
-		case promocode.FieldUpdatedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
-			} else if value.Valid {
-				_m.UpdatedAt = value.Time
-			}
-		default:
-			_m.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the PromoCode.
-// This includes values selected through modifiers, order, etc.
-func (_m *PromoCode) Value(name string) (ent.Value, error) {
-	return _m.selectValues.Get(name)
-}
-
-// QueryUsageRecords queries the "usage_records" edge of the PromoCode entity.
-func (_m *PromoCode) QueryUsageRecords() *PromoCodeUsageQuery {
-	return NewPromoCodeClient(_m.config).QueryUsageRecords(_m)
-}
-
-// Update returns a builder for updating this PromoCode.
-// Note that you need to call PromoCode.Unwrap() before calling this method if this PromoCode
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *PromoCode) Update() *PromoCodeUpdateOne {
-	return NewPromoCodeClient(_m.config).UpdateOne(_m)
-}
-
-// Unwrap unwraps the PromoCode entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (_m *PromoCode) Unwrap() *PromoCode {
-	_tx, ok := _m.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: PromoCode is not a transactional entity")
-	}
-	_m.config.driver = _tx.drv
-	return _m
-}
-
-// String implements the fmt.Stringer.
-func (_m *PromoCode) String() string {
-	var builder strings.Builder
-	builder.WriteString("PromoCode(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
-	builder.WriteString("code=")
-	builder.WriteString(_m.Code)
-	builder.WriteString(", ")
-	builder.WriteString("bonus_amount=")
-	builder.WriteString(fmt.Sprintf("%v", _m.BonusAmount))
-	builder.WriteString(", ")
-	builder.WriteString("max_uses=")
-	builder.WriteString(fmt.Sprintf("%v", _m.MaxUses))
-	builder.WriteString(", ")
-	builder.WriteString("used_count=")
-	builder.WriteString(fmt.Sprintf("%v", _m.UsedCount))
-	builder.WriteString(", ")
-	builder.WriteString("status=")
-	builder.WriteString(_m.Status)
-	builder.WriteString(", ")
-	if v := _m.ExpiresAt; v != nil {
-		builder.WriteString("expires_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.Notes; v != nil {
-		builder.WriteString("notes=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
-	builder.WriteString("created_at=")
-	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
-	builder.WriteString(", ")
-	builder.WriteString("updated_at=")
-	builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// PromoCodes is a parsable slice of PromoCode.
-type PromoCodes []*PromoCode

backend/ent/promocode/promocode.go

@@ -1,165 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package promocode
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-const (
-	// Label holds the string label denoting the promocode type in the database.
-	Label = "promo_code"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldCode holds the string denoting the code field in the database.
-	FieldCode = "code"
-	// FieldBonusAmount holds the string denoting the bonus_amount field in the database.
-	FieldBonusAmount = "bonus_amount"
-	// FieldMaxUses holds the string denoting the max_uses field in the database.
-	FieldMaxUses = "max_uses"
-	// FieldUsedCount holds the string denoting the used_count field in the database.
-	FieldUsedCount = "used_count"
-	// FieldStatus holds the string denoting the status field in the database.
-	FieldStatus = "status"
-	// FieldExpiresAt holds the string denoting the expires_at field in the database.
-	FieldExpiresAt = "expires_at"
-	// FieldNotes holds the string denoting the notes field in the database.
-	FieldNotes = "notes"
-	// FieldCreatedAt holds the string denoting the created_at field in the database.
-	FieldCreatedAt = "created_at"
-	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
-	FieldUpdatedAt = "updated_at"
-	// EdgeUsageRecords holds the string denoting the usage_records edge name in mutations.
-	EdgeUsageRecords = "usage_records"
-	// Table holds the table name of the promocode in the database.
-	Table = "promo_codes"
-	// UsageRecordsTable is the table that holds the usage_records relation/edge.
-	UsageRecordsTable = "promo_code_usages"
-	// UsageRecordsInverseTable is the table name for the PromoCodeUsage entity.
-	// It exists in this package in order to avoid circular dependency with the "promocodeusage" package.
-	UsageRecordsInverseTable = "promo_code_usages"
-	// UsageRecordsColumn is the table column denoting the usage_records relation/edge.
-	UsageRecordsColumn = "promo_code_id"
-)
-
-// Columns holds all SQL columns for promocode fields.
-var Columns = []string{
-	FieldID,
-	FieldCode,
-	FieldBonusAmount,
-	FieldMaxUses,
-	FieldUsedCount,
-	FieldStatus,
-	FieldExpiresAt,
-	FieldNotes,
-	FieldCreatedAt,
-	FieldUpdatedAt,
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// CodeValidator is a validator for the "code" field. It is called by the builders before save.
-	CodeValidator func(string) error
-	// DefaultBonusAmount holds the default value on creation for the "bonus_amount" field.
-	DefaultBonusAmount float64
-	// DefaultMaxUses holds the default value on creation for the "max_uses" field.
-	DefaultMaxUses int
-	// DefaultUsedCount holds the default value on creation for the "used_count" field.
-	DefaultUsedCount int
-	// DefaultStatus holds the default value on creation for the "status" field.
-	DefaultStatus string
-	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	StatusValidator func(string) error
-	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
-	DefaultCreatedAt func() time.Time
-	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
-	DefaultUpdatedAt func() time.Time
-	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
-	UpdateDefaultUpdatedAt func() time.Time
-)
-
-// OrderOption defines the ordering options for the PromoCode queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByCode orders the results by the code field.
-func ByCode(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCode, opts...).ToFunc()
-}
-
-// ByBonusAmount orders the results by the bonus_amount field.
-func ByBonusAmount(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldBonusAmount, opts...).ToFunc()
-}
-
-// ByMaxUses orders the results by the max_uses field.
-func ByMaxUses(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldMaxUses, opts...).ToFunc()
-}
-
-// ByUsedCount orders the results by the used_count field.
-func ByUsedCount(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUsedCount, opts...).ToFunc()
-}
-
-// ByStatus orders the results by the status field.
-func ByStatus(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldStatus, opts...).ToFunc()
-}
-
-// ByExpiresAt orders the results by the expires_at field.
-func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
-}
-
-// ByNotes orders the results by the notes field.
-func ByNotes(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldNotes, opts...).ToFunc()
-}
-
-// ByCreatedAt orders the results by the created_at field.
-func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
-}
-
-// ByUpdatedAt orders the results by the updated_at field.
-func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
-}
-
-// ByUsageRecordsCount orders the results by usage_records count.
-func ByUsageRecordsCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newUsageRecordsStep(), opts...)
-	}
-}
-
-// ByUsageRecords orders the results by usage_records terms.
-func ByUsageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newUsageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-func newUsageRecordsStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(UsageRecordsInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, UsageRecordsTable, UsageRecordsColumn),
-	)
-}

backend/ent/promocode/where.go

@@ -1,594 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package promocode
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldID, id))
-}
-
-// Code applies equality check predicate on the "code" field. It's identical to CodeEQ.
-func Code(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldCode, v))
-}
-
-// BonusAmount applies equality check predicate on the "bonus_amount" field. It's identical to BonusAmountEQ.
-func BonusAmount(v float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldBonusAmount, v))
-}
-
-// MaxUses applies equality check predicate on the "max_uses" field. It's identical to MaxUsesEQ.
-func MaxUses(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldMaxUses, v))
-}
-
-// UsedCount applies equality check predicate on the "used_count" field. It's identical to UsedCountEQ.
-func UsedCount(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldUsedCount, v))
-}
-
-// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
-func Status(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldStatus, v))
-}
-
-// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ.
-func ExpiresAt(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldExpiresAt, v))
-}
-
-// Notes applies equality check predicate on the "notes" field. It's identical to NotesEQ.
-func Notes(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldNotes, v))
-}
-
-// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
-func CreatedAt(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
-func UpdatedAt(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// CodeEQ applies the EQ predicate on the "code" field.
-func CodeEQ(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldCode, v))
-}
-
-// CodeNEQ applies the NEQ predicate on the "code" field.
-func CodeNEQ(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldCode, v))
-}
-
-// CodeIn applies the In predicate on the "code" field.
-func CodeIn(vs ...string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldCode, vs...))
-}
-
-// CodeNotIn applies the NotIn predicate on the "code" field.
-func CodeNotIn(vs ...string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldCode, vs...))
-}
-
-// CodeGT applies the GT predicate on the "code" field.
-func CodeGT(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldCode, v))
-}
-
-// CodeGTE applies the GTE predicate on the "code" field.
-func CodeGTE(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldCode, v))
-}
-
-// CodeLT applies the LT predicate on the "code" field.
-func CodeLT(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldCode, v))
-}
-
-// CodeLTE applies the LTE predicate on the "code" field.
-func CodeLTE(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldCode, v))
-}
-
-// CodeContains applies the Contains predicate on the "code" field.
-func CodeContains(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldContains(FieldCode, v))
-}
-
-// CodeHasPrefix applies the HasPrefix predicate on the "code" field.
-func CodeHasPrefix(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldHasPrefix(FieldCode, v))
-}
-
-// CodeHasSuffix applies the HasSuffix predicate on the "code" field.
-func CodeHasSuffix(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldHasSuffix(FieldCode, v))
-}
-
-// CodeEqualFold applies the EqualFold predicate on the "code" field.
-func CodeEqualFold(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEqualFold(FieldCode, v))
-}
-
-// CodeContainsFold applies the ContainsFold predicate on the "code" field.
-func CodeContainsFold(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldContainsFold(FieldCode, v))
-}
-
-// BonusAmountEQ applies the EQ predicate on the "bonus_amount" field.
-func BonusAmountEQ(v float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldBonusAmount, v))
-}
-
-// BonusAmountNEQ applies the NEQ predicate on the "bonus_amount" field.
-func BonusAmountNEQ(v float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldBonusAmount, v))
-}
-
-// BonusAmountIn applies the In predicate on the "bonus_amount" field.
-func BonusAmountIn(vs ...float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldBonusAmount, vs...))
-}
-
-// BonusAmountNotIn applies the NotIn predicate on the "bonus_amount" field.
-func BonusAmountNotIn(vs ...float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldBonusAmount, vs...))
-}
-
-// BonusAmountGT applies the GT predicate on the "bonus_amount" field.
-func BonusAmountGT(v float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldBonusAmount, v))
-}
-
-// BonusAmountGTE applies the GTE predicate on the "bonus_amount" field.
-func BonusAmountGTE(v float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldBonusAmount, v))
-}
-
-// BonusAmountLT applies the LT predicate on the "bonus_amount" field.
-func BonusAmountLT(v float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldBonusAmount, v))
-}
-
-// BonusAmountLTE applies the LTE predicate on the "bonus_amount" field.
-func BonusAmountLTE(v float64) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldBonusAmount, v))
-}
-
-// MaxUsesEQ applies the EQ predicate on the "max_uses" field.
-func MaxUsesEQ(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldMaxUses, v))
-}
-
-// MaxUsesNEQ applies the NEQ predicate on the "max_uses" field.
-func MaxUsesNEQ(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldMaxUses, v))
-}
-
-// MaxUsesIn applies the In predicate on the "max_uses" field.
-func MaxUsesIn(vs ...int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldMaxUses, vs...))
-}
-
-// MaxUsesNotIn applies the NotIn predicate on the "max_uses" field.
-func MaxUsesNotIn(vs ...int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldMaxUses, vs...))
-}
-
-// MaxUsesGT applies the GT predicate on the "max_uses" field.
-func MaxUsesGT(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldMaxUses, v))
-}
-
-// MaxUsesGTE applies the GTE predicate on the "max_uses" field.
-func MaxUsesGTE(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldMaxUses, v))
-}
-
-// MaxUsesLT applies the LT predicate on the "max_uses" field.
-func MaxUsesLT(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldMaxUses, v))
-}
-
-// MaxUsesLTE applies the LTE predicate on the "max_uses" field.
-func MaxUsesLTE(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldMaxUses, v))
-}
-
-// UsedCountEQ applies the EQ predicate on the "used_count" field.
-func UsedCountEQ(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldUsedCount, v))
-}
-
-// UsedCountNEQ applies the NEQ predicate on the "used_count" field.
-func UsedCountNEQ(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldUsedCount, v))
-}
-
-// UsedCountIn applies the In predicate on the "used_count" field.
-func UsedCountIn(vs ...int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldUsedCount, vs...))
-}
-
-// UsedCountNotIn applies the NotIn predicate on the "used_count" field.
-func UsedCountNotIn(vs ...int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldUsedCount, vs...))
-}
-
-// UsedCountGT applies the GT predicate on the "used_count" field.
-func UsedCountGT(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldUsedCount, v))
-}
-
-// UsedCountGTE applies the GTE predicate on the "used_count" field.
-func UsedCountGTE(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldUsedCount, v))
-}
-
-// UsedCountLT applies the LT predicate on the "used_count" field.
-func UsedCountLT(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldUsedCount, v))
-}
-
-// UsedCountLTE applies the LTE predicate on the "used_count" field.
-func UsedCountLTE(v int) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldUsedCount, v))
-}
-
-// StatusEQ applies the EQ predicate on the "status" field.
-func StatusEQ(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldStatus, v))
-}
-
-// StatusNEQ applies the NEQ predicate on the "status" field.
-func StatusNEQ(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldStatus, v))
-}
-
-// StatusIn applies the In predicate on the "status" field.
-func StatusIn(vs ...string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldStatus, vs...))
-}
-
-// StatusNotIn applies the NotIn predicate on the "status" field.
-func StatusNotIn(vs ...string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldStatus, vs...))
-}
-
-// StatusGT applies the GT predicate on the "status" field.
-func StatusGT(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldStatus, v))
-}
-
-// StatusGTE applies the GTE predicate on the "status" field.
-func StatusGTE(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldStatus, v))
-}
-
-// StatusLT applies the LT predicate on the "status" field.
-func StatusLT(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldStatus, v))
-}
-
-// StatusLTE applies the LTE predicate on the "status" field.
-func StatusLTE(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldStatus, v))
-}
-
-// StatusContains applies the Contains predicate on the "status" field.
-func StatusContains(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldContains(FieldStatus, v))
-}
-
-// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
-func StatusHasPrefix(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldHasPrefix(FieldStatus, v))
-}
-
-// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
-func StatusHasSuffix(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldHasSuffix(FieldStatus, v))
-}
-
-// StatusEqualFold applies the EqualFold predicate on the "status" field.
-func StatusEqualFold(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEqualFold(FieldStatus, v))
-}
-
-// StatusContainsFold applies the ContainsFold predicate on the "status" field.
-func StatusContainsFold(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldContainsFold(FieldStatus, v))
-}
-
-// ExpiresAtEQ applies the EQ predicate on the "expires_at" field.
-func ExpiresAtEQ(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldExpiresAt, v))
-}
-
-// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field.
-func ExpiresAtNEQ(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldExpiresAt, v))
-}
-
-// ExpiresAtIn applies the In predicate on the "expires_at" field.
-func ExpiresAtIn(vs ...time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldExpiresAt, vs...))
-}
-
-// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field.
-func ExpiresAtNotIn(vs ...time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldExpiresAt, vs...))
-}
-
-// ExpiresAtGT applies the GT predicate on the "expires_at" field.
-func ExpiresAtGT(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldExpiresAt, v))
-}
-
-// ExpiresAtGTE applies the GTE predicate on the "expires_at" field.
-func ExpiresAtGTE(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldExpiresAt, v))
-}
-
-// ExpiresAtLT applies the LT predicate on the "expires_at" field.
-func ExpiresAtLT(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldExpiresAt, v))
-}
-
-// ExpiresAtLTE applies the LTE predicate on the "expires_at" field.
-func ExpiresAtLTE(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldExpiresAt, v))
-}
-
-// ExpiresAtIsNil applies the IsNil predicate on the "expires_at" field.
-func ExpiresAtIsNil() predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIsNull(FieldExpiresAt))
-}
-
-// ExpiresAtNotNil applies the NotNil predicate on the "expires_at" field.
-func ExpiresAtNotNil() predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotNull(FieldExpiresAt))
-}
-
-// NotesEQ applies the EQ predicate on the "notes" field.
-func NotesEQ(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldNotes, v))
-}
-
-// NotesNEQ applies the NEQ predicate on the "notes" field.
-func NotesNEQ(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldNotes, v))
-}
-
-// NotesIn applies the In predicate on the "notes" field.
-func NotesIn(vs ...string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldNotes, vs...))
-}
-
-// NotesNotIn applies the NotIn predicate on the "notes" field.
-func NotesNotIn(vs ...string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldNotes, vs...))
-}
-
-// NotesGT applies the GT predicate on the "notes" field.
-func NotesGT(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldNotes, v))
-}
-
-// NotesGTE applies the GTE predicate on the "notes" field.
-func NotesGTE(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldNotes, v))
-}
-
-// NotesLT applies the LT predicate on the "notes" field.
-func NotesLT(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldNotes, v))
-}
-
-// NotesLTE applies the LTE predicate on the "notes" field.
-func NotesLTE(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldNotes, v))
-}
-
-// NotesContains applies the Contains predicate on the "notes" field.
-func NotesContains(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldContains(FieldNotes, v))
-}
-
-// NotesHasPrefix applies the HasPrefix predicate on the "notes" field.
-func NotesHasPrefix(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldHasPrefix(FieldNotes, v))
-}
-
-// NotesHasSuffix applies the HasSuffix predicate on the "notes" field.
-func NotesHasSuffix(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldHasSuffix(FieldNotes, v))
-}
-
-// NotesIsNil applies the IsNil predicate on the "notes" field.
-func NotesIsNil() predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIsNull(FieldNotes))
-}
-
-// NotesNotNil applies the NotNil predicate on the "notes" field.
-func NotesNotNil() predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotNull(FieldNotes))
-}
-
-// NotesEqualFold applies the EqualFold predicate on the "notes" field.
-func NotesEqualFold(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEqualFold(FieldNotes, v))
-}
-
-// NotesContainsFold applies the ContainsFold predicate on the "notes" field.
-func NotesContainsFold(v string) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldContainsFold(FieldNotes, v))
-}
-
-// CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldCreatedAt, v))
-}
-
-// CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldCreatedAt, v))
-}
-
-// CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldCreatedAt, v))
-}
-
-// CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldCreatedAt, v))
-}
-
-// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldNotIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldGTE(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v time.Time) predicate.PromoCode {
-	return predicate.PromoCode(sql.FieldLTE(FieldUpdatedAt, v))
-}
-
-// HasUsageRecords applies the HasEdge predicate on the "usage_records" edge.
-func HasUsageRecords() predicate.PromoCode {
-	return predicate.PromoCode(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, UsageRecordsTable, UsageRecordsColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasUsageRecordsWith applies the HasEdge predicate on the "usage_records" edge with a given conditions (other predicates).
-func HasUsageRecordsWith(preds ...predicate.PromoCodeUsage) predicate.PromoCode {
-	return predicate.PromoCode(func(s *sql.Selector) {
-		step := newUsageRecordsStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.PromoCode) predicate.PromoCode {
-	return predicate.PromoCode(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.PromoCode) predicate.PromoCode {
-	return predicate.PromoCode(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.PromoCode) predicate.PromoCode {
-	return predicate.PromoCode(sql.NotPredicates(p))
-}

backend/ent/promocode_delete.go

@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-)
-
-// PromoCodeDelete is the builder for deleting a PromoCode entity.
-type PromoCodeDelete struct {
-	config
-	hooks    []Hook
-	mutation *PromoCodeMutation
-}
-
-// Where appends a list predicates to the PromoCodeDelete builder.
-func (_d *PromoCodeDelete) Where(ps ...predicate.PromoCode) *PromoCodeDelete {
-	_d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *PromoCodeDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *PromoCodeDelete) ExecX(ctx context.Context) int {
-	n, err := _d.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (_d *PromoCodeDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(promocode.Table, sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64))
-	if ps := _d.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	_d.mutation.done = true
-	return affected, err
-}
-
-// PromoCodeDeleteOne is the builder for deleting a single PromoCode entity.
-type PromoCodeDeleteOne struct {
-	_d *PromoCodeDelete
-}
-
-// Where appends a list predicates to the PromoCodeDelete builder.
-func (_d *PromoCodeDeleteOne) Where(ps ...predicate.PromoCode) *PromoCodeDeleteOne {
-	_d._d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query.
-func (_d *PromoCodeDeleteOne) Exec(ctx context.Context) error {
-	n, err := _d._d.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{promocode.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *PromoCodeDeleteOne) ExecX(ctx context.Context) {
-	if err := _d.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/promocode_query.go

@@ -1,643 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"database/sql/driver"
-	"fmt"
-	"math"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
-)
-
-// PromoCodeQuery is the builder for querying PromoCode entities.
-type PromoCodeQuery struct {
-	config
-	ctx              *QueryContext
-	order            []promocode.OrderOption
-	inters           []Interceptor
-	predicates       []predicate.PromoCode
-	withUsageRecords *PromoCodeUsageQuery
-	modifiers        []func(*sql.Selector)
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the PromoCodeQuery builder.
-func (_q *PromoCodeQuery) Where(ps ...predicate.PromoCode) *PromoCodeQuery {
-	_q.predicates = append(_q.predicates, ps...)
-	return _q
-}
-
-// Limit the number of records to be returned by this query.
-func (_q *PromoCodeQuery) Limit(limit int) *PromoCodeQuery {
-	_q.ctx.Limit = &limit
-	return _q
-}
-
-// Offset to start from.
-func (_q *PromoCodeQuery) Offset(offset int) *PromoCodeQuery {
-	_q.ctx.Offset = &offset
-	return _q
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (_q *PromoCodeQuery) Unique(unique bool) *PromoCodeQuery {
-	_q.ctx.Unique = &unique
-	return _q
-}
-
-// Order specifies how the records should be ordered.
-func (_q *PromoCodeQuery) Order(o ...promocode.OrderOption) *PromoCodeQuery {
-	_q.order = append(_q.order, o...)
-	return _q
-}
-
-// QueryUsageRecords chains the current query on the "usage_records" edge.
-func (_q *PromoCodeQuery) QueryUsageRecords() *PromoCodeUsageQuery {
-	query := (&PromoCodeUsageClient{config: _q.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := _q.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := _q.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(promocode.Table, promocode.FieldID, selector),
-			sqlgraph.To(promocodeusage.Table, promocodeusage.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, promocode.UsageRecordsTable, promocode.UsageRecordsColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first PromoCode entity from the query.
-// Returns a *NotFoundError when no PromoCode was found.
-func (_q *PromoCodeQuery) First(ctx context.Context) (*PromoCode, error) {
-	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{promocode.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (_q *PromoCodeQuery) FirstX(ctx context.Context) *PromoCode {
-	node, err := _q.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first PromoCode ID from the query.
-// Returns a *NotFoundError when no PromoCode ID was found.
-func (_q *PromoCodeQuery) FirstID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{promocode.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *PromoCodeQuery) FirstIDX(ctx context.Context) int64 {
-	id, err := _q.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single PromoCode entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one PromoCode entity is found.
-// Returns a *NotFoundError when no PromoCode entities are found.
-func (_q *PromoCodeQuery) Only(ctx context.Context) (*PromoCode, error) {
-	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{promocode.Label}
-	default:
-		return nil, &NotSingularError{promocode.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (_q *PromoCodeQuery) OnlyX(ctx context.Context) *PromoCode {
-	node, err := _q.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only PromoCode ID in the query.
-// Returns a *NotSingularError when more than one PromoCode ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (_q *PromoCodeQuery) OnlyID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{promocode.Label}
-	default:
-		err = &NotSingularError{promocode.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *PromoCodeQuery) OnlyIDX(ctx context.Context) int64 {
-	id, err := _q.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of PromoCodes.
-func (_q *PromoCodeQuery) All(ctx context.Context) ([]*PromoCode, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*PromoCode, *PromoCodeQuery]()
-	return withInterceptors[[]*PromoCode](ctx, _q, qr, _q.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (_q *PromoCodeQuery) AllX(ctx context.Context) []*PromoCode {
-	nodes, err := _q.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of PromoCode IDs.
-func (_q *PromoCodeQuery) IDs(ctx context.Context) (ids []int64, err error) {
-	if _q.ctx.Unique == nil && _q.path != nil {
-		_q.Unique(true)
-	}
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
-	if err = _q.Select(promocode.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (_q *PromoCodeQuery) IDsX(ctx context.Context) []int64 {
-	ids, err := _q.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (_q *PromoCodeQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, _q, querierCount[*PromoCodeQuery](), _q.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (_q *PromoCodeQuery) CountX(ctx context.Context) int {
-	count, err := _q.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (_q *PromoCodeQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
-	switch _, err := _q.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (_q *PromoCodeQuery) ExistX(ctx context.Context) bool {
-	exist, err := _q.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the PromoCodeQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (_q *PromoCodeQuery) Clone() *PromoCodeQuery {
-	if _q == nil {
-		return nil
-	}
-	return &PromoCodeQuery{
-		config:           _q.config,
-		ctx:              _q.ctx.Clone(),
-		order:            append([]promocode.OrderOption{}, _q.order...),
-		inters:           append([]Interceptor{}, _q.inters...),
-		predicates:       append([]predicate.PromoCode{}, _q.predicates...),
-		withUsageRecords: _q.withUsageRecords.Clone(),
-		// clone intermediate query.
-		sql:  _q.sql.Clone(),
-		path: _q.path,
-	}
-}
-
-// WithUsageRecords tells the query-builder to eager-load the nodes that are connected to
-// the "usage_records" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *PromoCodeQuery) WithUsageRecords(opts ...func(*PromoCodeUsageQuery)) *PromoCodeQuery {
-	query := (&PromoCodeUsageClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withUsageRecords = query
-	return _q
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		Code string `json:"code,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.PromoCode.Query().
-//		GroupBy(promocode.FieldCode).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (_q *PromoCodeQuery) GroupBy(field string, fields ...string) *PromoCodeGroupBy {
-	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &PromoCodeGroupBy{build: _q}
-	grbuild.flds = &_q.ctx.Fields
-	grbuild.label = promocode.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		Code string `json:"code,omitempty"`
-//	}
-//
-//	client.PromoCode.Query().
-//		Select(promocode.FieldCode).
-//		Scan(ctx, &v)
-func (_q *PromoCodeQuery) Select(fields ...string) *PromoCodeSelect {
-	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &PromoCodeSelect{PromoCodeQuery: _q}
-	sbuild.label = promocode.Label
-	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a PromoCodeSelect configured with the given aggregations.
-func (_q *PromoCodeQuery) Aggregate(fns ...AggregateFunc) *PromoCodeSelect {
-	return _q.Select().Aggregate(fns...)
-}
-
-func (_q *PromoCodeQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range _q.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, _q); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range _q.ctx.Fields {
-		if !promocode.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if _q.path != nil {
-		prev, err := _q.path(ctx)
-		if err != nil {
-			return err
-		}
-		_q.sql = prev
-	}
-	return nil
-}
-
-func (_q *PromoCodeQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*PromoCode, error) {
-	var (
-		nodes       = []*PromoCode{}
-		_spec       = _q.querySpec()
-		loadedTypes = [1]bool{
-			_q.withUsageRecords != nil,
-		}
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*PromoCode).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &PromoCode{config: _q.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := _q.withUsageRecords; query != nil {
-		if err := _q.loadUsageRecords(ctx, query, nodes,
-			func(n *PromoCode) { n.Edges.UsageRecords = []*PromoCodeUsage{} },
-			func(n *PromoCode, e *PromoCodeUsage) { n.Edges.UsageRecords = append(n.Edges.UsageRecords, e) }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (_q *PromoCodeQuery) loadUsageRecords(ctx context.Context, query *PromoCodeUsageQuery, nodes []*PromoCode, init func(*PromoCode), assign func(*PromoCode, *PromoCodeUsage)) error {
-	fks := make([]driver.Value, 0, len(nodes))
-	nodeids := make(map[int64]*PromoCode)
-	for i := range nodes {
-		fks = append(fks, nodes[i].ID)
-		nodeids[nodes[i].ID] = nodes[i]
-		if init != nil {
-			init(nodes[i])
-		}
-	}
-	if len(query.ctx.Fields) > 0 {
-		query.ctx.AppendFieldOnce(promocodeusage.FieldPromoCodeID)
-	}
-	query.Where(predicate.PromoCodeUsage(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(promocode.UsageRecordsColumn), fks...))
-	}))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		fk := n.PromoCodeID
-		node, ok := nodeids[fk]
-		if !ok {
-			return fmt.Errorf(`unexpected referenced foreign-key "promo_code_id" returned %v for node %v`, fk, n.ID)
-		}
-		assign(node, n)
-	}
-	return nil
-}
-
-func (_q *PromoCodeQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	_spec.Node.Columns = _q.ctx.Fields
-	if len(_q.ctx.Fields) > 0 {
-		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
-}
-
-func (_q *PromoCodeQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(promocode.Table, promocode.Columns, sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64))
-	_spec.From = _q.sql
-	if unique := _q.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if _q.path != nil {
-		_spec.Unique = true
-	}
-	if fields := _q.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, promocode.FieldID)
-		for i := range fields {
-			if fields[i] != promocode.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-	}
-	if ps := _q.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := _q.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (_q *PromoCodeQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(_q.driver.Dialect())
-	t1 := builder.Table(promocode.Table)
-	columns := _q.ctx.Fields
-	if len(columns) == 0 {
-		columns = promocode.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if _q.sql != nil {
-		selector = _q.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if _q.ctx.Unique != nil && *_q.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
-	for _, p := range _q.predicates {
-		p(selector)
-	}
-	for _, p := range _q.order {
-		p(selector)
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *PromoCodeQuery) ForUpdate(opts ...sql.LockOption) *PromoCodeQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *PromoCodeQuery) ForShare(opts ...sql.LockOption) *PromoCodeQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// PromoCodeGroupBy is the group-by builder for PromoCode entities.
-type PromoCodeGroupBy struct {
-	selector
-	build *PromoCodeQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (_g *PromoCodeGroupBy) Aggregate(fns ...AggregateFunc) *PromoCodeGroupBy {
-	_g.fns = append(_g.fns, fns...)
-	return _g
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_g *PromoCodeGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
-	if err := _g.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*PromoCodeQuery, *PromoCodeGroupBy](ctx, _g.build, _g, _g.build.inters, v)
-}
-
-func (_g *PromoCodeGroupBy) sqlScan(ctx context.Context, root *PromoCodeQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(_g.fns))
-	for _, fn := range _g.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
-		for _, f := range *_g.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*_g.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// PromoCodeSelect is the builder for selecting fields of PromoCode entities.
-type PromoCodeSelect struct {
-	*PromoCodeQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (_s *PromoCodeSelect) Aggregate(fns ...AggregateFunc) *PromoCodeSelect {
-	_s.fns = append(_s.fns, fns...)
-	return _s
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_s *PromoCodeSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
-	if err := _s.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*PromoCodeQuery, *PromoCodeSelect](ctx, _s.PromoCodeQuery, _s, _s.inters, v)
-}
-
-func (_s *PromoCodeSelect) sqlScan(ctx context.Context, root *PromoCodeQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(_s.fns))
-	for _, fn := range _s.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*_s.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}

backend/ent/promocode_update.go

@@ -1,745 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
-)
-
-// PromoCodeUpdate is the builder for updating PromoCode entities.
-type PromoCodeUpdate struct {
-	config
-	hooks    []Hook
-	mutation *PromoCodeMutation
-}
-
-// Where appends a list predicates to the PromoCodeUpdate builder.
-func (_u *PromoCodeUpdate) Where(ps ...predicate.PromoCode) *PromoCodeUpdate {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// SetCode sets the "code" field.
-func (_u *PromoCodeUpdate) SetCode(v string) *PromoCodeUpdate {
-	_u.mutation.SetCode(v)
-	return _u
-}
-
-// SetNillableCode sets the "code" field if the given value is not nil.
-func (_u *PromoCodeUpdate) SetNillableCode(v *string) *PromoCodeUpdate {
-	if v != nil {
-		_u.SetCode(*v)
-	}
-	return _u
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (_u *PromoCodeUpdate) SetBonusAmount(v float64) *PromoCodeUpdate {
-	_u.mutation.ResetBonusAmount()
-	_u.mutation.SetBonusAmount(v)
-	return _u
-}
-
-// SetNillableBonusAmount sets the "bonus_amount" field if the given value is not nil.
-func (_u *PromoCodeUpdate) SetNillableBonusAmount(v *float64) *PromoCodeUpdate {
-	if v != nil {
-		_u.SetBonusAmount(*v)
-	}
-	return _u
-}
-
-// AddBonusAmount adds value to the "bonus_amount" field.
-func (_u *PromoCodeUpdate) AddBonusAmount(v float64) *PromoCodeUpdate {
-	_u.mutation.AddBonusAmount(v)
-	return _u
-}
-
-// SetMaxUses sets the "max_uses" field.
-func (_u *PromoCodeUpdate) SetMaxUses(v int) *PromoCodeUpdate {
-	_u.mutation.ResetMaxUses()
-	_u.mutation.SetMaxUses(v)
-	return _u
-}
-
-// SetNillableMaxUses sets the "max_uses" field if the given value is not nil.
-func (_u *PromoCodeUpdate) SetNillableMaxUses(v *int) *PromoCodeUpdate {
-	if v != nil {
-		_u.SetMaxUses(*v)
-	}
-	return _u
-}
-
-// AddMaxUses adds value to the "max_uses" field.
-func (_u *PromoCodeUpdate) AddMaxUses(v int) *PromoCodeUpdate {
-	_u.mutation.AddMaxUses(v)
-	return _u
-}
-
-// SetUsedCount sets the "used_count" field.
-func (_u *PromoCodeUpdate) SetUsedCount(v int) *PromoCodeUpdate {
-	_u.mutation.ResetUsedCount()
-	_u.mutation.SetUsedCount(v)
-	return _u
-}
-
-// SetNillableUsedCount sets the "used_count" field if the given value is not nil.
-func (_u *PromoCodeUpdate) SetNillableUsedCount(v *int) *PromoCodeUpdate {
-	if v != nil {
-		_u.SetUsedCount(*v)
-	}
-	return _u
-}
-
-// AddUsedCount adds value to the "used_count" field.
-func (_u *PromoCodeUpdate) AddUsedCount(v int) *PromoCodeUpdate {
-	_u.mutation.AddUsedCount(v)
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *PromoCodeUpdate) SetStatus(v string) *PromoCodeUpdate {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *PromoCodeUpdate) SetNillableStatus(v *string) *PromoCodeUpdate {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetExpiresAt sets the "expires_at" field.
-func (_u *PromoCodeUpdate) SetExpiresAt(v time.Time) *PromoCodeUpdate {
-	_u.mutation.SetExpiresAt(v)
-	return _u
-}
-
-// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (_u *PromoCodeUpdate) SetNillableExpiresAt(v *time.Time) *PromoCodeUpdate {
-	if v != nil {
-		_u.SetExpiresAt(*v)
-	}
-	return _u
-}
-
-// ClearExpiresAt clears the value of the "expires_at" field.
-func (_u *PromoCodeUpdate) ClearExpiresAt() *PromoCodeUpdate {
-	_u.mutation.ClearExpiresAt()
-	return _u
-}
-
-// SetNotes sets the "notes" field.
-func (_u *PromoCodeUpdate) SetNotes(v string) *PromoCodeUpdate {
-	_u.mutation.SetNotes(v)
-	return _u
-}
-
-// SetNillableNotes sets the "notes" field if the given value is not nil.
-func (_u *PromoCodeUpdate) SetNillableNotes(v *string) *PromoCodeUpdate {
-	if v != nil {
-		_u.SetNotes(*v)
-	}
-	return _u
-}
-
-// ClearNotes clears the value of the "notes" field.
-func (_u *PromoCodeUpdate) ClearNotes() *PromoCodeUpdate {
-	_u.mutation.ClearNotes()
-	return _u
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *PromoCodeUpdate) SetUpdatedAt(v time.Time) *PromoCodeUpdate {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// AddUsageRecordIDs adds the "usage_records" edge to the PromoCodeUsage entity by IDs.
-func (_u *PromoCodeUpdate) AddUsageRecordIDs(ids ...int64) *PromoCodeUpdate {
-	_u.mutation.AddUsageRecordIDs(ids...)
-	return _u
-}
-
-// AddUsageRecords adds the "usage_records" edges to the PromoCodeUsage entity.
-func (_u *PromoCodeUpdate) AddUsageRecords(v ...*PromoCodeUsage) *PromoCodeUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddUsageRecordIDs(ids...)
-}
-
-// Mutation returns the PromoCodeMutation object of the builder.
-func (_u *PromoCodeUpdate) Mutation() *PromoCodeMutation {
-	return _u.mutation
-}
-
-// ClearUsageRecords clears all "usage_records" edges to the PromoCodeUsage entity.
-func (_u *PromoCodeUpdate) ClearUsageRecords() *PromoCodeUpdate {
-	_u.mutation.ClearUsageRecords()
-	return _u
-}
-
-// RemoveUsageRecordIDs removes the "usage_records" edge to PromoCodeUsage entities by IDs.
-func (_u *PromoCodeUpdate) RemoveUsageRecordIDs(ids ...int64) *PromoCodeUpdate {
-	_u.mutation.RemoveUsageRecordIDs(ids...)
-	return _u
-}
-
-// RemoveUsageRecords removes "usage_records" edges to PromoCodeUsage entities.
-func (_u *PromoCodeUpdate) RemoveUsageRecords(v ...*PromoCodeUsage) *PromoCodeUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemoveUsageRecordIDs(ids...)
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *PromoCodeUpdate) Save(ctx context.Context) (int, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *PromoCodeUpdate) SaveX(ctx context.Context) int {
-	affected, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (_u *PromoCodeUpdate) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *PromoCodeUpdate) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *PromoCodeUpdate) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := promocode.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *PromoCodeUpdate) check() error {
-	if v, ok := _u.mutation.Code(); ok {
-		if err := promocode.CodeValidator(v); err != nil {
-			return &ValidationError{Name: "code", err: fmt.Errorf(`ent: validator failed for field "PromoCode.code": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Status(); ok {
-		if err := promocode.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "PromoCode.status": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *PromoCodeUpdate) sqlSave(ctx context.Context) (_node int, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(promocode.Table, promocode.Columns, sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64))
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.Code(); ok {
-		_spec.SetField(promocode.FieldCode, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.BonusAmount(); ok {
-		_spec.SetField(promocode.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedBonusAmount(); ok {
-		_spec.AddField(promocode.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.MaxUses(); ok {
-		_spec.SetField(promocode.FieldMaxUses, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedMaxUses(); ok {
-		_spec.AddField(promocode.FieldMaxUses, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.UsedCount(); ok {
-		_spec.SetField(promocode.FieldUsedCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedUsedCount(); ok {
-		_spec.AddField(promocode.FieldUsedCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(promocode.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.ExpiresAt(); ok {
-		_spec.SetField(promocode.FieldExpiresAt, field.TypeTime, value)
-	}
-	if _u.mutation.ExpiresAtCleared() {
-		_spec.ClearField(promocode.FieldExpiresAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.Notes(); ok {
-		_spec.SetField(promocode.FieldNotes, field.TypeString, value)
-	}
-	if _u.mutation.NotesCleared() {
-		_spec.ClearField(promocode.FieldNotes, field.TypeString)
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(promocode.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if _u.mutation.UsageRecordsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   promocode.UsageRecordsTable,
-			Columns: []string{promocode.UsageRecordsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedUsageRecordsIDs(); len(nodes) > 0 && !_u.mutation.UsageRecordsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   promocode.UsageRecordsTable,
-			Columns: []string{promocode.UsageRecordsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.UsageRecordsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   promocode.UsageRecordsTable,
-			Columns: []string{promocode.UsageRecordsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{promocode.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}
-
-// PromoCodeUpdateOne is the builder for updating a single PromoCode entity.
-type PromoCodeUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *PromoCodeMutation
-}
-
-// SetCode sets the "code" field.
-func (_u *PromoCodeUpdateOne) SetCode(v string) *PromoCodeUpdateOne {
-	_u.mutation.SetCode(v)
-	return _u
-}
-
-// SetNillableCode sets the "code" field if the given value is not nil.
-func (_u *PromoCodeUpdateOne) SetNillableCode(v *string) *PromoCodeUpdateOne {
-	if v != nil {
-		_u.SetCode(*v)
-	}
-	return _u
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (_u *PromoCodeUpdateOne) SetBonusAmount(v float64) *PromoCodeUpdateOne {
-	_u.mutation.ResetBonusAmount()
-	_u.mutation.SetBonusAmount(v)
-	return _u
-}
-
-// SetNillableBonusAmount sets the "bonus_amount" field if the given value is not nil.
-func (_u *PromoCodeUpdateOne) SetNillableBonusAmount(v *float64) *PromoCodeUpdateOne {
-	if v != nil {
-		_u.SetBonusAmount(*v)
-	}
-	return _u
-}
-
-// AddBonusAmount adds value to the "bonus_amount" field.
-func (_u *PromoCodeUpdateOne) AddBonusAmount(v float64) *PromoCodeUpdateOne {
-	_u.mutation.AddBonusAmount(v)
-	return _u
-}
-
-// SetMaxUses sets the "max_uses" field.
-func (_u *PromoCodeUpdateOne) SetMaxUses(v int) *PromoCodeUpdateOne {
-	_u.mutation.ResetMaxUses()
-	_u.mutation.SetMaxUses(v)
-	return _u
-}
-
-// SetNillableMaxUses sets the "max_uses" field if the given value is not nil.
-func (_u *PromoCodeUpdateOne) SetNillableMaxUses(v *int) *PromoCodeUpdateOne {
-	if v != nil {
-		_u.SetMaxUses(*v)
-	}
-	return _u
-}
-
-// AddMaxUses adds value to the "max_uses" field.
-func (_u *PromoCodeUpdateOne) AddMaxUses(v int) *PromoCodeUpdateOne {
-	_u.mutation.AddMaxUses(v)
-	return _u
-}
-
-// SetUsedCount sets the "used_count" field.
-func (_u *PromoCodeUpdateOne) SetUsedCount(v int) *PromoCodeUpdateOne {
-	_u.mutation.ResetUsedCount()
-	_u.mutation.SetUsedCount(v)
-	return _u
-}
-
-// SetNillableUsedCount sets the "used_count" field if the given value is not nil.
-func (_u *PromoCodeUpdateOne) SetNillableUsedCount(v *int) *PromoCodeUpdateOne {
-	if v != nil {
-		_u.SetUsedCount(*v)
-	}
-	return _u
-}
-
-// AddUsedCount adds value to the "used_count" field.
-func (_u *PromoCodeUpdateOne) AddUsedCount(v int) *PromoCodeUpdateOne {
-	_u.mutation.AddUsedCount(v)
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *PromoCodeUpdateOne) SetStatus(v string) *PromoCodeUpdateOne {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *PromoCodeUpdateOne) SetNillableStatus(v *string) *PromoCodeUpdateOne {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetExpiresAt sets the "expires_at" field.
-func (_u *PromoCodeUpdateOne) SetExpiresAt(v time.Time) *PromoCodeUpdateOne {
-	_u.mutation.SetExpiresAt(v)
-	return _u
-}
-
-// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil.
-func (_u *PromoCodeUpdateOne) SetNillableExpiresAt(v *time.Time) *PromoCodeUpdateOne {
-	if v != nil {
-		_u.SetExpiresAt(*v)
-	}
-	return _u
-}
-
-// ClearExpiresAt clears the value of the "expires_at" field.
-func (_u *PromoCodeUpdateOne) ClearExpiresAt() *PromoCodeUpdateOne {
-	_u.mutation.ClearExpiresAt()
-	return _u
-}
-
-// SetNotes sets the "notes" field.
-func (_u *PromoCodeUpdateOne) SetNotes(v string) *PromoCodeUpdateOne {
-	_u.mutation.SetNotes(v)
-	return _u
-}
-
-// SetNillableNotes sets the "notes" field if the given value is not nil.
-func (_u *PromoCodeUpdateOne) SetNillableNotes(v *string) *PromoCodeUpdateOne {
-	if v != nil {
-		_u.SetNotes(*v)
-	}
-	return _u
-}
-
-// ClearNotes clears the value of the "notes" field.
-func (_u *PromoCodeUpdateOne) ClearNotes() *PromoCodeUpdateOne {
-	_u.mutation.ClearNotes()
-	return _u
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *PromoCodeUpdateOne) SetUpdatedAt(v time.Time) *PromoCodeUpdateOne {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// AddUsageRecordIDs adds the "usage_records" edge to the PromoCodeUsage entity by IDs.
-func (_u *PromoCodeUpdateOne) AddUsageRecordIDs(ids ...int64) *PromoCodeUpdateOne {
-	_u.mutation.AddUsageRecordIDs(ids...)
-	return _u
-}
-
-// AddUsageRecords adds the "usage_records" edges to the PromoCodeUsage entity.
-func (_u *PromoCodeUpdateOne) AddUsageRecords(v ...*PromoCodeUsage) *PromoCodeUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddUsageRecordIDs(ids...)
-}
-
-// Mutation returns the PromoCodeMutation object of the builder.
-func (_u *PromoCodeUpdateOne) Mutation() *PromoCodeMutation {
-	return _u.mutation
-}
-
-// ClearUsageRecords clears all "usage_records" edges to the PromoCodeUsage entity.
-func (_u *PromoCodeUpdateOne) ClearUsageRecords() *PromoCodeUpdateOne {
-	_u.mutation.ClearUsageRecords()
-	return _u
-}
-
-// RemoveUsageRecordIDs removes the "usage_records" edge to PromoCodeUsage entities by IDs.
-func (_u *PromoCodeUpdateOne) RemoveUsageRecordIDs(ids ...int64) *PromoCodeUpdateOne {
-	_u.mutation.RemoveUsageRecordIDs(ids...)
-	return _u
-}
-
-// RemoveUsageRecords removes "usage_records" edges to PromoCodeUsage entities.
-func (_u *PromoCodeUpdateOne) RemoveUsageRecords(v ...*PromoCodeUsage) *PromoCodeUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemoveUsageRecordIDs(ids...)
-}
-
-// Where appends a list predicates to the PromoCodeUpdate builder.
-func (_u *PromoCodeUpdateOne) Where(ps ...predicate.PromoCode) *PromoCodeUpdateOne {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (_u *PromoCodeUpdateOne) Select(field string, fields ...string) *PromoCodeUpdateOne {
-	_u.fields = append([]string{field}, fields...)
-	return _u
-}
-
-// Save executes the query and returns the updated PromoCode entity.
-func (_u *PromoCodeUpdateOne) Save(ctx context.Context) (*PromoCode, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *PromoCodeUpdateOne) SaveX(ctx context.Context) *PromoCode {
-	node, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (_u *PromoCodeUpdateOne) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *PromoCodeUpdateOne) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_u *PromoCodeUpdateOne) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := promocode.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *PromoCodeUpdateOne) check() error {
-	if v, ok := _u.mutation.Code(); ok {
-		if err := promocode.CodeValidator(v); err != nil {
-			return &ValidationError{Name: "code", err: fmt.Errorf(`ent: validator failed for field "PromoCode.code": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.Status(); ok {
-		if err := promocode.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "PromoCode.status": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *PromoCodeUpdateOne) sqlSave(ctx context.Context) (_node *PromoCode, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(promocode.Table, promocode.Columns, sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64))
-	id, ok := _u.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "PromoCode.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := _u.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, promocode.FieldID)
-		for _, f := range fields {
-			if !promocode.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != promocode.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.Code(); ok {
-		_spec.SetField(promocode.FieldCode, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.BonusAmount(); ok {
-		_spec.SetField(promocode.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedBonusAmount(); ok {
-		_spec.AddField(promocode.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.MaxUses(); ok {
-		_spec.SetField(promocode.FieldMaxUses, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedMaxUses(); ok {
-		_spec.AddField(promocode.FieldMaxUses, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.UsedCount(); ok {
-		_spec.SetField(promocode.FieldUsedCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedUsedCount(); ok {
-		_spec.AddField(promocode.FieldUsedCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(promocode.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.ExpiresAt(); ok {
-		_spec.SetField(promocode.FieldExpiresAt, field.TypeTime, value)
-	}
-	if _u.mutation.ExpiresAtCleared() {
-		_spec.ClearField(promocode.FieldExpiresAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.Notes(); ok {
-		_spec.SetField(promocode.FieldNotes, field.TypeString, value)
-	}
-	if _u.mutation.NotesCleared() {
-		_spec.ClearField(promocode.FieldNotes, field.TypeString)
-	}
-	if value, ok := _u.mutation.UpdatedAt(); ok {
-		_spec.SetField(promocode.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if _u.mutation.UsageRecordsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   promocode.UsageRecordsTable,
-			Columns: []string{promocode.UsageRecordsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedUsageRecordsIDs(); len(nodes) > 0 && !_u.mutation.UsageRecordsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   promocode.UsageRecordsTable,
-			Columns: []string{promocode.UsageRecordsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.UsageRecordsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   promocode.UsageRecordsTable,
-			Columns: []string{promocode.UsageRecordsColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	_node = &PromoCode{config: _u.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{promocode.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}

backend/ent/promocodeusage.go

@@ -1,187 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// PromoCodeUsage is the model entity for the PromoCodeUsage schema.
-type PromoCodeUsage struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int64 `json:"id,omitempty"`
-	// 优惠码ID
-	PromoCodeID int64 `json:"promo_code_id,omitempty"`
-	// 使用用户ID
-	UserID int64 `json:"user_id,omitempty"`
-	// 实际赠送金额
-	BonusAmount float64 `json:"bonus_amount,omitempty"`
-	// 使用时间
-	UsedAt time.Time `json:"used_at,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the PromoCodeUsageQuery when eager-loading is set.
-	Edges        PromoCodeUsageEdges `json:"edges"`
-	selectValues sql.SelectValues
-}
-
-// PromoCodeUsageEdges holds the relations/edges for other nodes in the graph.
-type PromoCodeUsageEdges struct {
-	// PromoCode holds the value of the promo_code edge.
-	PromoCode *PromoCode `json:"promo_code,omitempty"`
-	// User holds the value of the user edge.
-	User *User `json:"user,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [2]bool
-}
-
-// PromoCodeOrErr returns the PromoCode value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e PromoCodeUsageEdges) PromoCodeOrErr() (*PromoCode, error) {
-	if e.PromoCode != nil {
-		return e.PromoCode, nil
-	} else if e.loadedTypes[0] {
-		return nil, &NotFoundError{label: promocode.Label}
-	}
-	return nil, &NotLoadedError{edge: "promo_code"}
-}
-
-// UserOrErr returns the User value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e PromoCodeUsageEdges) UserOrErr() (*User, error) {
-	if e.User != nil {
-		return e.User, nil
-	} else if e.loadedTypes[1] {
-		return nil, &NotFoundError{label: user.Label}
-	}
-	return nil, &NotLoadedError{edge: "user"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*PromoCodeUsage) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case promocodeusage.FieldBonusAmount:
-			values[i] = new(sql.NullFloat64)
-		case promocodeusage.FieldID, promocodeusage.FieldPromoCodeID, promocodeusage.FieldUserID:
-			values[i] = new(sql.NullInt64)
-		case promocodeusage.FieldUsedAt:
-			values[i] = new(sql.NullTime)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the PromoCodeUsage fields.
-func (_m *PromoCodeUsage) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case promocodeusage.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			_m.ID = int64(value.Int64)
-		case promocodeusage.FieldPromoCodeID:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field promo_code_id", values[i])
-			} else if value.Valid {
-				_m.PromoCodeID = value.Int64
-			}
-		case promocodeusage.FieldUserID:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field user_id", values[i])
-			} else if value.Valid {
-				_m.UserID = value.Int64
-			}
-		case promocodeusage.FieldBonusAmount:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field bonus_amount", values[i])
-			} else if value.Valid {
-				_m.BonusAmount = value.Float64
-			}
-		case promocodeusage.FieldUsedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field used_at", values[i])
-			} else if value.Valid {
-				_m.UsedAt = value.Time
-			}
-		default:
-			_m.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the PromoCodeUsage.
-// This includes values selected through modifiers, order, etc.
-func (_m *PromoCodeUsage) Value(name string) (ent.Value, error) {
-	return _m.selectValues.Get(name)
-}
-
-// QueryPromoCode queries the "promo_code" edge of the PromoCodeUsage entity.
-func (_m *PromoCodeUsage) QueryPromoCode() *PromoCodeQuery {
-	return NewPromoCodeUsageClient(_m.config).QueryPromoCode(_m)
-}
-
-// QueryUser queries the "user" edge of the PromoCodeUsage entity.
-func (_m *PromoCodeUsage) QueryUser() *UserQuery {
-	return NewPromoCodeUsageClient(_m.config).QueryUser(_m)
-}
-
-// Update returns a builder for updating this PromoCodeUsage.
-// Note that you need to call PromoCodeUsage.Unwrap() before calling this method if this PromoCodeUsage
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *PromoCodeUsage) Update() *PromoCodeUsageUpdateOne {
-	return NewPromoCodeUsageClient(_m.config).UpdateOne(_m)
-}
-
-// Unwrap unwraps the PromoCodeUsage entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (_m *PromoCodeUsage) Unwrap() *PromoCodeUsage {
-	_tx, ok := _m.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: PromoCodeUsage is not a transactional entity")
-	}
-	_m.config.driver = _tx.drv
-	return _m
-}
-
-// String implements the fmt.Stringer.
-func (_m *PromoCodeUsage) String() string {
-	var builder strings.Builder
-	builder.WriteString("PromoCodeUsage(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
-	builder.WriteString("promo_code_id=")
-	builder.WriteString(fmt.Sprintf("%v", _m.PromoCodeID))
-	builder.WriteString(", ")
-	builder.WriteString("user_id=")
-	builder.WriteString(fmt.Sprintf("%v", _m.UserID))
-	builder.WriteString(", ")
-	builder.WriteString("bonus_amount=")
-	builder.WriteString(fmt.Sprintf("%v", _m.BonusAmount))
-	builder.WriteString(", ")
-	builder.WriteString("used_at=")
-	builder.WriteString(_m.UsedAt.Format(time.ANSIC))
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// PromoCodeUsages is a parsable slice of PromoCodeUsage.
-type PromoCodeUsages []*PromoCodeUsage

backend/ent/promocodeusage/promocodeusage.go

@@ -1,125 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package promocodeusage
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-const (
-	// Label holds the string label denoting the promocodeusage type in the database.
-	Label = "promo_code_usage"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldPromoCodeID holds the string denoting the promo_code_id field in the database.
-	FieldPromoCodeID = "promo_code_id"
-	// FieldUserID holds the string denoting the user_id field in the database.
-	FieldUserID = "user_id"
-	// FieldBonusAmount holds the string denoting the bonus_amount field in the database.
-	FieldBonusAmount = "bonus_amount"
-	// FieldUsedAt holds the string denoting the used_at field in the database.
-	FieldUsedAt = "used_at"
-	// EdgePromoCode holds the string denoting the promo_code edge name in mutations.
-	EdgePromoCode = "promo_code"
-	// EdgeUser holds the string denoting the user edge name in mutations.
-	EdgeUser = "user"
-	// Table holds the table name of the promocodeusage in the database.
-	Table = "promo_code_usages"
-	// PromoCodeTable is the table that holds the promo_code relation/edge.
-	PromoCodeTable = "promo_code_usages"
-	// PromoCodeInverseTable is the table name for the PromoCode entity.
-	// It exists in this package in order to avoid circular dependency with the "promocode" package.
-	PromoCodeInverseTable = "promo_codes"
-	// PromoCodeColumn is the table column denoting the promo_code relation/edge.
-	PromoCodeColumn = "promo_code_id"
-	// UserTable is the table that holds the user relation/edge.
-	UserTable = "promo_code_usages"
-	// UserInverseTable is the table name for the User entity.
-	// It exists in this package in order to avoid circular dependency with the "user" package.
-	UserInverseTable = "users"
-	// UserColumn is the table column denoting the user relation/edge.
-	UserColumn = "user_id"
-)
-
-// Columns holds all SQL columns for promocodeusage fields.
-var Columns = []string{
-	FieldID,
-	FieldPromoCodeID,
-	FieldUserID,
-	FieldBonusAmount,
-	FieldUsedAt,
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// DefaultUsedAt holds the default value on creation for the "used_at" field.
-	DefaultUsedAt func() time.Time
-)
-
-// OrderOption defines the ordering options for the PromoCodeUsage queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByPromoCodeID orders the results by the promo_code_id field.
-func ByPromoCodeID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldPromoCodeID, opts...).ToFunc()
-}
-
-// ByUserID orders the results by the user_id field.
-func ByUserID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUserID, opts...).ToFunc()
-}
-
-// ByBonusAmount orders the results by the bonus_amount field.
-func ByBonusAmount(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldBonusAmount, opts...).ToFunc()
-}
-
-// ByUsedAt orders the results by the used_at field.
-func ByUsedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUsedAt, opts...).ToFunc()
-}
-
-// ByPromoCodeField orders the results by promo_code field.
-func ByPromoCodeField(field string, opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newPromoCodeStep(), sql.OrderByField(field, opts...))
-	}
-}
-
-// ByUserField orders the results by user field.
-func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
-	}
-}
-func newPromoCodeStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(PromoCodeInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2O, true, PromoCodeTable, PromoCodeColumn),
-	)
-}
-func newUserStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(UserInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
-	)
-}

backend/ent/promocodeusage/where.go

@@ -1,257 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package promocodeusage
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldLTE(FieldID, id))
-}
-
-// PromoCodeID applies equality check predicate on the "promo_code_id" field. It's identical to PromoCodeIDEQ.
-func PromoCodeID(v int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldPromoCodeID, v))
-}
-
-// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
-func UserID(v int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldUserID, v))
-}
-
-// BonusAmount applies equality check predicate on the "bonus_amount" field. It's identical to BonusAmountEQ.
-func BonusAmount(v float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldBonusAmount, v))
-}
-
-// UsedAt applies equality check predicate on the "used_at" field. It's identical to UsedAtEQ.
-func UsedAt(v time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldUsedAt, v))
-}
-
-// PromoCodeIDEQ applies the EQ predicate on the "promo_code_id" field.
-func PromoCodeIDEQ(v int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldPromoCodeID, v))
-}
-
-// PromoCodeIDNEQ applies the NEQ predicate on the "promo_code_id" field.
-func PromoCodeIDNEQ(v int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNEQ(FieldPromoCodeID, v))
-}
-
-// PromoCodeIDIn applies the In predicate on the "promo_code_id" field.
-func PromoCodeIDIn(vs ...int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldIn(FieldPromoCodeID, vs...))
-}
-
-// PromoCodeIDNotIn applies the NotIn predicate on the "promo_code_id" field.
-func PromoCodeIDNotIn(vs ...int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNotIn(FieldPromoCodeID, vs...))
-}
-
-// UserIDEQ applies the EQ predicate on the "user_id" field.
-func UserIDEQ(v int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldUserID, v))
-}
-
-// UserIDNEQ applies the NEQ predicate on the "user_id" field.
-func UserIDNEQ(v int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNEQ(FieldUserID, v))
-}
-
-// UserIDIn applies the In predicate on the "user_id" field.
-func UserIDIn(vs ...int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldIn(FieldUserID, vs...))
-}
-
-// UserIDNotIn applies the NotIn predicate on the "user_id" field.
-func UserIDNotIn(vs ...int64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNotIn(FieldUserID, vs...))
-}
-
-// BonusAmountEQ applies the EQ predicate on the "bonus_amount" field.
-func BonusAmountEQ(v float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldBonusAmount, v))
-}
-
-// BonusAmountNEQ applies the NEQ predicate on the "bonus_amount" field.
-func BonusAmountNEQ(v float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNEQ(FieldBonusAmount, v))
-}
-
-// BonusAmountIn applies the In predicate on the "bonus_amount" field.
-func BonusAmountIn(vs ...float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldIn(FieldBonusAmount, vs...))
-}
-
-// BonusAmountNotIn applies the NotIn predicate on the "bonus_amount" field.
-func BonusAmountNotIn(vs ...float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNotIn(FieldBonusAmount, vs...))
-}
-
-// BonusAmountGT applies the GT predicate on the "bonus_amount" field.
-func BonusAmountGT(v float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldGT(FieldBonusAmount, v))
-}
-
-// BonusAmountGTE applies the GTE predicate on the "bonus_amount" field.
-func BonusAmountGTE(v float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldGTE(FieldBonusAmount, v))
-}
-
-// BonusAmountLT applies the LT predicate on the "bonus_amount" field.
-func BonusAmountLT(v float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldLT(FieldBonusAmount, v))
-}
-
-// BonusAmountLTE applies the LTE predicate on the "bonus_amount" field.
-func BonusAmountLTE(v float64) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldLTE(FieldBonusAmount, v))
-}
-
-// UsedAtEQ applies the EQ predicate on the "used_at" field.
-func UsedAtEQ(v time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldEQ(FieldUsedAt, v))
-}
-
-// UsedAtNEQ applies the NEQ predicate on the "used_at" field.
-func UsedAtNEQ(v time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNEQ(FieldUsedAt, v))
-}
-
-// UsedAtIn applies the In predicate on the "used_at" field.
-func UsedAtIn(vs ...time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldIn(FieldUsedAt, vs...))
-}
-
-// UsedAtNotIn applies the NotIn predicate on the "used_at" field.
-func UsedAtNotIn(vs ...time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldNotIn(FieldUsedAt, vs...))
-}
-
-// UsedAtGT applies the GT predicate on the "used_at" field.
-func UsedAtGT(v time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldGT(FieldUsedAt, v))
-}
-
-// UsedAtGTE applies the GTE predicate on the "used_at" field.
-func UsedAtGTE(v time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldGTE(FieldUsedAt, v))
-}
-
-// UsedAtLT applies the LT predicate on the "used_at" field.
-func UsedAtLT(v time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldLT(FieldUsedAt, v))
-}
-
-// UsedAtLTE applies the LTE predicate on the "used_at" field.
-func UsedAtLTE(v time.Time) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.FieldLTE(FieldUsedAt, v))
-}
-
-// HasPromoCode applies the HasEdge predicate on the "promo_code" edge.
-func HasPromoCode() predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, PromoCodeTable, PromoCodeColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasPromoCodeWith applies the HasEdge predicate on the "promo_code" edge with a given conditions (other predicates).
-func HasPromoCodeWith(preds ...predicate.PromoCode) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(func(s *sql.Selector) {
-		step := newPromoCodeStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// HasUser applies the HasEdge predicate on the "user" edge.
-func HasUser() predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
-func HasUserWith(preds ...predicate.User) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(func(s *sql.Selector) {
-		step := newUserStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.PromoCodeUsage) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.PromoCodeUsage) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.PromoCodeUsage) predicate.PromoCodeUsage {
-	return predicate.PromoCodeUsage(sql.NotPredicates(p))
-}

backend/ent/promocodeusage_create.go

@@ -1,696 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// PromoCodeUsageCreate is the builder for creating a PromoCodeUsage entity.
-type PromoCodeUsageCreate struct {
-	config
-	mutation *PromoCodeUsageMutation
-	hooks    []Hook
-	conflict []sql.ConflictOption
-}
-
-// SetPromoCodeID sets the "promo_code_id" field.
-func (_c *PromoCodeUsageCreate) SetPromoCodeID(v int64) *PromoCodeUsageCreate {
-	_c.mutation.SetPromoCodeID(v)
-	return _c
-}
-
-// SetUserID sets the "user_id" field.
-func (_c *PromoCodeUsageCreate) SetUserID(v int64) *PromoCodeUsageCreate {
-	_c.mutation.SetUserID(v)
-	return _c
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (_c *PromoCodeUsageCreate) SetBonusAmount(v float64) *PromoCodeUsageCreate {
-	_c.mutation.SetBonusAmount(v)
-	return _c
-}
-
-// SetUsedAt sets the "used_at" field.
-func (_c *PromoCodeUsageCreate) SetUsedAt(v time.Time) *PromoCodeUsageCreate {
-	_c.mutation.SetUsedAt(v)
-	return _c
-}
-
-// SetNillableUsedAt sets the "used_at" field if the given value is not nil.
-func (_c *PromoCodeUsageCreate) SetNillableUsedAt(v *time.Time) *PromoCodeUsageCreate {
-	if v != nil {
-		_c.SetUsedAt(*v)
-	}
-	return _c
-}
-
-// SetPromoCode sets the "promo_code" edge to the PromoCode entity.
-func (_c *PromoCodeUsageCreate) SetPromoCode(v *PromoCode) *PromoCodeUsageCreate {
-	return _c.SetPromoCodeID(v.ID)
-}
-
-// SetUser sets the "user" edge to the User entity.
-func (_c *PromoCodeUsageCreate) SetUser(v *User) *PromoCodeUsageCreate {
-	return _c.SetUserID(v.ID)
-}
-
-// Mutation returns the PromoCodeUsageMutation object of the builder.
-func (_c *PromoCodeUsageCreate) Mutation() *PromoCodeUsageMutation {
-	return _c.mutation
-}
-
-// Save creates the PromoCodeUsage in the database.
-func (_c *PromoCodeUsageCreate) Save(ctx context.Context) (*PromoCodeUsage, error) {
-	_c.defaults()
-	return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
-}
-
-// SaveX calls Save and panics if Save returns an error.
-func (_c *PromoCodeUsageCreate) SaveX(ctx context.Context) *PromoCodeUsage {
-	v, err := _c.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (_c *PromoCodeUsageCreate) Exec(ctx context.Context) error {
-	_, err := _c.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_c *PromoCodeUsageCreate) ExecX(ctx context.Context) {
-	if err := _c.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (_c *PromoCodeUsageCreate) defaults() {
-	if _, ok := _c.mutation.UsedAt(); !ok {
-		v := promocodeusage.DefaultUsedAt()
-		_c.mutation.SetUsedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_c *PromoCodeUsageCreate) check() error {
-	if _, ok := _c.mutation.PromoCodeID(); !ok {
-		return &ValidationError{Name: "promo_code_id", err: errors.New(`ent: missing required field "PromoCodeUsage.promo_code_id"`)}
-	}
-	if _, ok := _c.mutation.UserID(); !ok {
-		return &ValidationError{Name: "user_id", err: errors.New(`ent: missing required field "PromoCodeUsage.user_id"`)}
-	}
-	if _, ok := _c.mutation.BonusAmount(); !ok {
-		return &ValidationError{Name: "bonus_amount", err: errors.New(`ent: missing required field "PromoCodeUsage.bonus_amount"`)}
-	}
-	if _, ok := _c.mutation.UsedAt(); !ok {
-		return &ValidationError{Name: "used_at", err: errors.New(`ent: missing required field "PromoCodeUsage.used_at"`)}
-	}
-	if len(_c.mutation.PromoCodeIDs()) == 0 {
-		return &ValidationError{Name: "promo_code", err: errors.New(`ent: missing required edge "PromoCodeUsage.promo_code"`)}
-	}
-	if len(_c.mutation.UserIDs()) == 0 {
-		return &ValidationError{Name: "user", err: errors.New(`ent: missing required edge "PromoCodeUsage.user"`)}
-	}
-	return nil
-}
-
-func (_c *PromoCodeUsageCreate) sqlSave(ctx context.Context) (*PromoCodeUsage, error) {
-	if err := _c.check(); err != nil {
-		return nil, err
-	}
-	_node, _spec := _c.createSpec()
-	if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil {
-		if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	id := _spec.ID.Value.(int64)
-	_node.ID = int64(id)
-	_c.mutation.id = &_node.ID
-	_c.mutation.done = true
-	return _node, nil
-}
-
-func (_c *PromoCodeUsageCreate) createSpec() (*PromoCodeUsage, *sqlgraph.CreateSpec) {
-	var (
-		_node = &PromoCodeUsage{config: _c.config}
-		_spec = sqlgraph.NewCreateSpec(promocodeusage.Table, sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64))
-	)
-	_spec.OnConflict = _c.conflict
-	if value, ok := _c.mutation.BonusAmount(); ok {
-		_spec.SetField(promocodeusage.FieldBonusAmount, field.TypeFloat64, value)
-		_node.BonusAmount = value
-	}
-	if value, ok := _c.mutation.UsedAt(); ok {
-		_spec.SetField(promocodeusage.FieldUsedAt, field.TypeTime, value)
-		_node.UsedAt = value
-	}
-	if nodes := _c.mutation.PromoCodeIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.PromoCodeTable,
-			Columns: []string{promocodeusage.PromoCodeColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.PromoCodeID = nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	if nodes := _c.mutation.UserIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.UserTable,
-			Columns: []string{promocodeusage.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.UserID = nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	return _node, _spec
-}
-
-// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
-// of the `INSERT` statement. For example:
-//
-//	client.PromoCodeUsage.Create().
-//		SetPromoCodeID(v).
-//		OnConflict(
-//			// Update the row with the new values
-//			// the was proposed for insertion.
-//			sql.ResolveWithNewValues(),
-//		).
-//		// Override some of the fields with custom
-//		// update values.
-//		Update(func(u *ent.PromoCodeUsageUpsert) {
-//			SetPromoCodeID(v+v).
-//		}).
-//		Exec(ctx)
-func (_c *PromoCodeUsageCreate) OnConflict(opts ...sql.ConflictOption) *PromoCodeUsageUpsertOne {
-	_c.conflict = opts
-	return &PromoCodeUsageUpsertOne{
-		create: _c,
-	}
-}
-
-// OnConflictColumns calls `OnConflict` and configures the columns
-// as conflict target. Using this option is equivalent to using:
-//
-//	client.PromoCodeUsage.Create().
-//		OnConflict(sql.ConflictColumns(columns...)).
-//		Exec(ctx)
-func (_c *PromoCodeUsageCreate) OnConflictColumns(columns ...string) *PromoCodeUsageUpsertOne {
-	_c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
-	return &PromoCodeUsageUpsertOne{
-		create: _c,
-	}
-}
-
-type (
-	// PromoCodeUsageUpsertOne is the builder for "upsert"-ing
-	//  one PromoCodeUsage node.
-	PromoCodeUsageUpsertOne struct {
-		create *PromoCodeUsageCreate
-	}
-
-	// PromoCodeUsageUpsert is the "OnConflict" setter.
-	PromoCodeUsageUpsert struct {
-		*sql.UpdateSet
-	}
-)
-
-// SetPromoCodeID sets the "promo_code_id" field.
-func (u *PromoCodeUsageUpsert) SetPromoCodeID(v int64) *PromoCodeUsageUpsert {
-	u.Set(promocodeusage.FieldPromoCodeID, v)
-	return u
-}
-
-// UpdatePromoCodeID sets the "promo_code_id" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsert) UpdatePromoCodeID() *PromoCodeUsageUpsert {
-	u.SetExcluded(promocodeusage.FieldPromoCodeID)
-	return u
-}
-
-// SetUserID sets the "user_id" field.
-func (u *PromoCodeUsageUpsert) SetUserID(v int64) *PromoCodeUsageUpsert {
-	u.Set(promocodeusage.FieldUserID, v)
-	return u
-}
-
-// UpdateUserID sets the "user_id" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsert) UpdateUserID() *PromoCodeUsageUpsert {
-	u.SetExcluded(promocodeusage.FieldUserID)
-	return u
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (u *PromoCodeUsageUpsert) SetBonusAmount(v float64) *PromoCodeUsageUpsert {
-	u.Set(promocodeusage.FieldBonusAmount, v)
-	return u
-}
-
-// UpdateBonusAmount sets the "bonus_amount" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsert) UpdateBonusAmount() *PromoCodeUsageUpsert {
-	u.SetExcluded(promocodeusage.FieldBonusAmount)
-	return u
-}
-
-// AddBonusAmount adds v to the "bonus_amount" field.
-func (u *PromoCodeUsageUpsert) AddBonusAmount(v float64) *PromoCodeUsageUpsert {
-	u.Add(promocodeusage.FieldBonusAmount, v)
-	return u
-}
-
-// SetUsedAt sets the "used_at" field.
-func (u *PromoCodeUsageUpsert) SetUsedAt(v time.Time) *PromoCodeUsageUpsert {
-	u.Set(promocodeusage.FieldUsedAt, v)
-	return u
-}
-
-// UpdateUsedAt sets the "used_at" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsert) UpdateUsedAt() *PromoCodeUsageUpsert {
-	u.SetExcluded(promocodeusage.FieldUsedAt)
-	return u
-}
-
-// UpdateNewValues updates the mutable fields using the new values that were set on create.
-// Using this option is equivalent to using:
-//
-//	client.PromoCodeUsage.Create().
-//		OnConflict(
-//			sql.ResolveWithNewValues(),
-//		).
-//		Exec(ctx)
-func (u *PromoCodeUsageUpsertOne) UpdateNewValues() *PromoCodeUsageUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
-	return u
-}
-
-// Ignore sets each column to itself in case of conflict.
-// Using this option is equivalent to using:
-//
-//	client.PromoCodeUsage.Create().
-//	    OnConflict(sql.ResolveWithIgnore()).
-//	    Exec(ctx)
-func (u *PromoCodeUsageUpsertOne) Ignore() *PromoCodeUsageUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
-	return u
-}
-
-// DoNothing configures the conflict_action to `DO NOTHING`.
-// Supported only by SQLite and PostgreSQL.
-func (u *PromoCodeUsageUpsertOne) DoNothing() *PromoCodeUsageUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.DoNothing())
-	return u
-}
-
-// Update allows overriding fields `UPDATE` values. See the PromoCodeUsageCreate.OnConflict
-// documentation for more info.
-func (u *PromoCodeUsageUpsertOne) Update(set func(*PromoCodeUsageUpsert)) *PromoCodeUsageUpsertOne {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
-		set(&PromoCodeUsageUpsert{UpdateSet: update})
-	}))
-	return u
-}
-
-// SetPromoCodeID sets the "promo_code_id" field.
-func (u *PromoCodeUsageUpsertOne) SetPromoCodeID(v int64) *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetPromoCodeID(v)
-	})
-}
-
-// UpdatePromoCodeID sets the "promo_code_id" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertOne) UpdatePromoCodeID() *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdatePromoCodeID()
-	})
-}
-
-// SetUserID sets the "user_id" field.
-func (u *PromoCodeUsageUpsertOne) SetUserID(v int64) *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetUserID(v)
-	})
-}
-
-// UpdateUserID sets the "user_id" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertOne) UpdateUserID() *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdateUserID()
-	})
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (u *PromoCodeUsageUpsertOne) SetBonusAmount(v float64) *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetBonusAmount(v)
-	})
-}
-
-// AddBonusAmount adds v to the "bonus_amount" field.
-func (u *PromoCodeUsageUpsertOne) AddBonusAmount(v float64) *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.AddBonusAmount(v)
-	})
-}
-
-// UpdateBonusAmount sets the "bonus_amount" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertOne) UpdateBonusAmount() *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdateBonusAmount()
-	})
-}
-
-// SetUsedAt sets the "used_at" field.
-func (u *PromoCodeUsageUpsertOne) SetUsedAt(v time.Time) *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetUsedAt(v)
-	})
-}
-
-// UpdateUsedAt sets the "used_at" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertOne) UpdateUsedAt() *PromoCodeUsageUpsertOne {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdateUsedAt()
-	})
-}
-
-// Exec executes the query.
-func (u *PromoCodeUsageUpsertOne) Exec(ctx context.Context) error {
-	if len(u.create.conflict) == 0 {
-		return errors.New("ent: missing options for PromoCodeUsageCreate.OnConflict")
-	}
-	return u.create.Exec(ctx)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (u *PromoCodeUsageUpsertOne) ExecX(ctx context.Context) {
-	if err := u.create.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// Exec executes the UPSERT query and returns the inserted/updated ID.
-func (u *PromoCodeUsageUpsertOne) ID(ctx context.Context) (id int64, err error) {
-	node, err := u.create.Save(ctx)
-	if err != nil {
-		return id, err
-	}
-	return node.ID, nil
-}
-
-// IDX is like ID, but panics if an error occurs.
-func (u *PromoCodeUsageUpsertOne) IDX(ctx context.Context) int64 {
-	id, err := u.ID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// PromoCodeUsageCreateBulk is the builder for creating many PromoCodeUsage entities in bulk.
-type PromoCodeUsageCreateBulk struct {
-	config
-	err      error
-	builders []*PromoCodeUsageCreate
-	conflict []sql.ConflictOption
-}
-
-// Save creates the PromoCodeUsage entities in the database.
-func (_c *PromoCodeUsageCreateBulk) Save(ctx context.Context) ([]*PromoCodeUsage, error) {
-	if _c.err != nil {
-		return nil, _c.err
-	}
-	specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
-	nodes := make([]*PromoCodeUsage, len(_c.builders))
-	mutators := make([]Mutator, len(_c.builders))
-	for i := range _c.builders {
-		func(i int, root context.Context) {
-			builder := _c.builders[i]
-			builder.defaults()
-			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-				mutation, ok := m.(*PromoCodeUsageMutation)
-				if !ok {
-					return nil, fmt.Errorf("unexpected mutation type %T", m)
-				}
-				if err := builder.check(); err != nil {
-					return nil, err
-				}
-				builder.mutation = mutation
-				var err error
-				nodes[i], specs[i] = builder.createSpec()
-				if i < len(mutators)-1 {
-					_, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
-				} else {
-					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
-					spec.OnConflict = _c.conflict
-					// Invoke the actual operation on the latest mutation in the chain.
-					if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil {
-						if sqlgraph.IsConstraintError(err) {
-							err = &ConstraintError{msg: err.Error(), wrap: err}
-						}
-					}
-				}
-				if err != nil {
-					return nil, err
-				}
-				mutation.id = &nodes[i].ID
-				if specs[i].ID.Value != nil {
-					id := specs[i].ID.Value.(int64)
-					nodes[i].ID = int64(id)
-				}
-				mutation.done = true
-				return nodes[i], nil
-			})
-			for i := len(builder.hooks) - 1; i >= 0; i-- {
-				mut = builder.hooks[i](mut)
-			}
-			mutators[i] = mut
-		}(i, ctx)
-	}
-	if len(mutators) > 0 {
-		if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_c *PromoCodeUsageCreateBulk) SaveX(ctx context.Context) []*PromoCodeUsage {
-	v, err := _c.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (_c *PromoCodeUsageCreateBulk) Exec(ctx context.Context) error {
-	_, err := _c.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_c *PromoCodeUsageCreateBulk) ExecX(ctx context.Context) {
-	if err := _c.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
-// of the `INSERT` statement. For example:
-//
-//	client.PromoCodeUsage.CreateBulk(builders...).
-//		OnConflict(
-//			// Update the row with the new values
-//			// the was proposed for insertion.
-//			sql.ResolveWithNewValues(),
-//		).
-//		// Override some of the fields with custom
-//		// update values.
-//		Update(func(u *ent.PromoCodeUsageUpsert) {
-//			SetPromoCodeID(v+v).
-//		}).
-//		Exec(ctx)
-func (_c *PromoCodeUsageCreateBulk) OnConflict(opts ...sql.ConflictOption) *PromoCodeUsageUpsertBulk {
-	_c.conflict = opts
-	return &PromoCodeUsageUpsertBulk{
-		create: _c,
-	}
-}
-
-// OnConflictColumns calls `OnConflict` and configures the columns
-// as conflict target. Using this option is equivalent to using:
-//
-//	client.PromoCodeUsage.Create().
-//		OnConflict(sql.ConflictColumns(columns...)).
-//		Exec(ctx)
-func (_c *PromoCodeUsageCreateBulk) OnConflictColumns(columns ...string) *PromoCodeUsageUpsertBulk {
-	_c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
-	return &PromoCodeUsageUpsertBulk{
-		create: _c,
-	}
-}
-
-// PromoCodeUsageUpsertBulk is the builder for "upsert"-ing
-// a bulk of PromoCodeUsage nodes.
-type PromoCodeUsageUpsertBulk struct {
-	create *PromoCodeUsageCreateBulk
-}
-
-// UpdateNewValues updates the mutable fields using the new values that
-// were set on create. Using this option is equivalent to using:
-//
-//	client.PromoCodeUsage.Create().
-//		OnConflict(
-//			sql.ResolveWithNewValues(),
-//		).
-//		Exec(ctx)
-func (u *PromoCodeUsageUpsertBulk) UpdateNewValues() *PromoCodeUsageUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
-	return u
-}
-
-// Ignore sets each column to itself in case of conflict.
-// Using this option is equivalent to using:
-//
-//	client.PromoCodeUsage.Create().
-//		OnConflict(sql.ResolveWithIgnore()).
-//		Exec(ctx)
-func (u *PromoCodeUsageUpsertBulk) Ignore() *PromoCodeUsageUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
-	return u
-}
-
-// DoNothing configures the conflict_action to `DO NOTHING`.
-// Supported only by SQLite and PostgreSQL.
-func (u *PromoCodeUsageUpsertBulk) DoNothing() *PromoCodeUsageUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.DoNothing())
-	return u
-}
-
-// Update allows overriding fields `UPDATE` values. See the PromoCodeUsageCreateBulk.OnConflict
-// documentation for more info.
-func (u *PromoCodeUsageUpsertBulk) Update(set func(*PromoCodeUsageUpsert)) *PromoCodeUsageUpsertBulk {
-	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
-		set(&PromoCodeUsageUpsert{UpdateSet: update})
-	}))
-	return u
-}
-
-// SetPromoCodeID sets the "promo_code_id" field.
-func (u *PromoCodeUsageUpsertBulk) SetPromoCodeID(v int64) *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetPromoCodeID(v)
-	})
-}
-
-// UpdatePromoCodeID sets the "promo_code_id" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertBulk) UpdatePromoCodeID() *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdatePromoCodeID()
-	})
-}
-
-// SetUserID sets the "user_id" field.
-func (u *PromoCodeUsageUpsertBulk) SetUserID(v int64) *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetUserID(v)
-	})
-}
-
-// UpdateUserID sets the "user_id" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertBulk) UpdateUserID() *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdateUserID()
-	})
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (u *PromoCodeUsageUpsertBulk) SetBonusAmount(v float64) *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetBonusAmount(v)
-	})
-}
-
-// AddBonusAmount adds v to the "bonus_amount" field.
-func (u *PromoCodeUsageUpsertBulk) AddBonusAmount(v float64) *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.AddBonusAmount(v)
-	})
-}
-
-// UpdateBonusAmount sets the "bonus_amount" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertBulk) UpdateBonusAmount() *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdateBonusAmount()
-	})
-}
-
-// SetUsedAt sets the "used_at" field.
-func (u *PromoCodeUsageUpsertBulk) SetUsedAt(v time.Time) *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.SetUsedAt(v)
-	})
-}
-
-// UpdateUsedAt sets the "used_at" field to the value that was provided on create.
-func (u *PromoCodeUsageUpsertBulk) UpdateUsedAt() *PromoCodeUsageUpsertBulk {
-	return u.Update(func(s *PromoCodeUsageUpsert) {
-		s.UpdateUsedAt()
-	})
-}
-
-// Exec executes the query.
-func (u *PromoCodeUsageUpsertBulk) Exec(ctx context.Context) error {
-	if u.create.err != nil {
-		return u.create.err
-	}
-	for i, b := range u.create.builders {
-		if len(b.conflict) != 0 {
-			return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the PromoCodeUsageCreateBulk instead", i)
-		}
-	}
-	if len(u.create.conflict) == 0 {
-		return errors.New("ent: missing options for PromoCodeUsageCreateBulk.OnConflict")
-	}
-	return u.create.Exec(ctx)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (u *PromoCodeUsageUpsertBulk) ExecX(ctx context.Context) {
-	if err := u.create.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/promocodeusage_delete.go

@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
-)
-
-// PromoCodeUsageDelete is the builder for deleting a PromoCodeUsage entity.
-type PromoCodeUsageDelete struct {
-	config
-	hooks    []Hook
-	mutation *PromoCodeUsageMutation
-}
-
-// Where appends a list predicates to the PromoCodeUsageDelete builder.
-func (_d *PromoCodeUsageDelete) Where(ps ...predicate.PromoCodeUsage) *PromoCodeUsageDelete {
-	_d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *PromoCodeUsageDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *PromoCodeUsageDelete) ExecX(ctx context.Context) int {
-	n, err := _d.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (_d *PromoCodeUsageDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(promocodeusage.Table, sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64))
-	if ps := _d.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	_d.mutation.done = true
-	return affected, err
-}
-
-// PromoCodeUsageDeleteOne is the builder for deleting a single PromoCodeUsage entity.
-type PromoCodeUsageDeleteOne struct {
-	_d *PromoCodeUsageDelete
-}
-
-// Where appends a list predicates to the PromoCodeUsageDelete builder.
-func (_d *PromoCodeUsageDeleteOne) Where(ps ...predicate.PromoCodeUsage) *PromoCodeUsageDeleteOne {
-	_d._d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query.
-func (_d *PromoCodeUsageDeleteOne) Exec(ctx context.Context) error {
-	n, err := _d._d.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{promocodeusage.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *PromoCodeUsageDeleteOne) ExecX(ctx context.Context) {
-	if err := _d.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/promocodeusage_query.go

@@ -1,718 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"fmt"
-	"math"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// PromoCodeUsageQuery is the builder for querying PromoCodeUsage entities.
-type PromoCodeUsageQuery struct {
-	config
-	ctx           *QueryContext
-	order         []promocodeusage.OrderOption
-	inters        []Interceptor
-	predicates    []predicate.PromoCodeUsage
-	withPromoCode *PromoCodeQuery
-	withUser      *UserQuery
-	modifiers     []func(*sql.Selector)
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the PromoCodeUsageQuery builder.
-func (_q *PromoCodeUsageQuery) Where(ps ...predicate.PromoCodeUsage) *PromoCodeUsageQuery {
-	_q.predicates = append(_q.predicates, ps...)
-	return _q
-}
-
-// Limit the number of records to be returned by this query.
-func (_q *PromoCodeUsageQuery) Limit(limit int) *PromoCodeUsageQuery {
-	_q.ctx.Limit = &limit
-	return _q
-}
-
-// Offset to start from.
-func (_q *PromoCodeUsageQuery) Offset(offset int) *PromoCodeUsageQuery {
-	_q.ctx.Offset = &offset
-	return _q
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (_q *PromoCodeUsageQuery) Unique(unique bool) *PromoCodeUsageQuery {
-	_q.ctx.Unique = &unique
-	return _q
-}
-
-// Order specifies how the records should be ordered.
-func (_q *PromoCodeUsageQuery) Order(o ...promocodeusage.OrderOption) *PromoCodeUsageQuery {
-	_q.order = append(_q.order, o...)
-	return _q
-}
-
-// QueryPromoCode chains the current query on the "promo_code" edge.
-func (_q *PromoCodeUsageQuery) QueryPromoCode() *PromoCodeQuery {
-	query := (&PromoCodeClient{config: _q.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := _q.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := _q.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(promocodeusage.Table, promocodeusage.FieldID, selector),
-			sqlgraph.To(promocode.Table, promocode.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, promocodeusage.PromoCodeTable, promocodeusage.PromoCodeColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// QueryUser chains the current query on the "user" edge.
-func (_q *PromoCodeUsageQuery) QueryUser() *UserQuery {
-	query := (&UserClient{config: _q.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := _q.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := _q.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(promocodeusage.Table, promocodeusage.FieldID, selector),
-			sqlgraph.To(user.Table, user.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, promocodeusage.UserTable, promocodeusage.UserColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first PromoCodeUsage entity from the query.
-// Returns a *NotFoundError when no PromoCodeUsage was found.
-func (_q *PromoCodeUsageQuery) First(ctx context.Context) (*PromoCodeUsage, error) {
-	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{promocodeusage.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) FirstX(ctx context.Context) *PromoCodeUsage {
-	node, err := _q.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first PromoCodeUsage ID from the query.
-// Returns a *NotFoundError when no PromoCodeUsage ID was found.
-func (_q *PromoCodeUsageQuery) FirstID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{promocodeusage.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) FirstIDX(ctx context.Context) int64 {
-	id, err := _q.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single PromoCodeUsage entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one PromoCodeUsage entity is found.
-// Returns a *NotFoundError when no PromoCodeUsage entities are found.
-func (_q *PromoCodeUsageQuery) Only(ctx context.Context) (*PromoCodeUsage, error) {
-	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{promocodeusage.Label}
-	default:
-		return nil, &NotSingularError{promocodeusage.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) OnlyX(ctx context.Context) *PromoCodeUsage {
-	node, err := _q.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only PromoCodeUsage ID in the query.
-// Returns a *NotSingularError when more than one PromoCodeUsage ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (_q *PromoCodeUsageQuery) OnlyID(ctx context.Context) (id int64, err error) {
-	var ids []int64
-	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{promocodeusage.Label}
-	default:
-		err = &NotSingularError{promocodeusage.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) OnlyIDX(ctx context.Context) int64 {
-	id, err := _q.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of PromoCodeUsages.
-func (_q *PromoCodeUsageQuery) All(ctx context.Context) ([]*PromoCodeUsage, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*PromoCodeUsage, *PromoCodeUsageQuery]()
-	return withInterceptors[[]*PromoCodeUsage](ctx, _q, qr, _q.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) AllX(ctx context.Context) []*PromoCodeUsage {
-	nodes, err := _q.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of PromoCodeUsage IDs.
-func (_q *PromoCodeUsageQuery) IDs(ctx context.Context) (ids []int64, err error) {
-	if _q.ctx.Unique == nil && _q.path != nil {
-		_q.Unique(true)
-	}
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
-	if err = _q.Select(promocodeusage.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) IDsX(ctx context.Context) []int64 {
-	ids, err := _q.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (_q *PromoCodeUsageQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, _q, querierCount[*PromoCodeUsageQuery](), _q.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) CountX(ctx context.Context) int {
-	count, err := _q.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (_q *PromoCodeUsageQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
-	switch _, err := _q.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (_q *PromoCodeUsageQuery) ExistX(ctx context.Context) bool {
-	exist, err := _q.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the PromoCodeUsageQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (_q *PromoCodeUsageQuery) Clone() *PromoCodeUsageQuery {
-	if _q == nil {
-		return nil
-	}
-	return &PromoCodeUsageQuery{
-		config:        _q.config,
-		ctx:           _q.ctx.Clone(),
-		order:         append([]promocodeusage.OrderOption{}, _q.order...),
-		inters:        append([]Interceptor{}, _q.inters...),
-		predicates:    append([]predicate.PromoCodeUsage{}, _q.predicates...),
-		withPromoCode: _q.withPromoCode.Clone(),
-		withUser:      _q.withUser.Clone(),
-		// clone intermediate query.
-		sql:  _q.sql.Clone(),
-		path: _q.path,
-	}
-}
-
-// WithPromoCode tells the query-builder to eager-load the nodes that are connected to
-// the "promo_code" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *PromoCodeUsageQuery) WithPromoCode(opts ...func(*PromoCodeQuery)) *PromoCodeUsageQuery {
-	query := (&PromoCodeClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withPromoCode = query
-	return _q
-}
-
-// WithUser tells the query-builder to eager-load the nodes that are connected to
-// the "user" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *PromoCodeUsageQuery) WithUser(opts ...func(*UserQuery)) *PromoCodeUsageQuery {
-	query := (&UserClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withUser = query
-	return _q
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		PromoCodeID int64 `json:"promo_code_id,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.PromoCodeUsage.Query().
-//		GroupBy(promocodeusage.FieldPromoCodeID).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (_q *PromoCodeUsageQuery) GroupBy(field string, fields ...string) *PromoCodeUsageGroupBy {
-	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &PromoCodeUsageGroupBy{build: _q}
-	grbuild.flds = &_q.ctx.Fields
-	grbuild.label = promocodeusage.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		PromoCodeID int64 `json:"promo_code_id,omitempty"`
-//	}
-//
-//	client.PromoCodeUsage.Query().
-//		Select(promocodeusage.FieldPromoCodeID).
-//		Scan(ctx, &v)
-func (_q *PromoCodeUsageQuery) Select(fields ...string) *PromoCodeUsageSelect {
-	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &PromoCodeUsageSelect{PromoCodeUsageQuery: _q}
-	sbuild.label = promocodeusage.Label
-	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a PromoCodeUsageSelect configured with the given aggregations.
-func (_q *PromoCodeUsageQuery) Aggregate(fns ...AggregateFunc) *PromoCodeUsageSelect {
-	return _q.Select().Aggregate(fns...)
-}
-
-func (_q *PromoCodeUsageQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range _q.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, _q); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range _q.ctx.Fields {
-		if !promocodeusage.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if _q.path != nil {
-		prev, err := _q.path(ctx)
-		if err != nil {
-			return err
-		}
-		_q.sql = prev
-	}
-	return nil
-}
-
-func (_q *PromoCodeUsageQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*PromoCodeUsage, error) {
-	var (
-		nodes       = []*PromoCodeUsage{}
-		_spec       = _q.querySpec()
-		loadedTypes = [2]bool{
-			_q.withPromoCode != nil,
-			_q.withUser != nil,
-		}
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*PromoCodeUsage).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &PromoCodeUsage{config: _q.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := _q.withPromoCode; query != nil {
-		if err := _q.loadPromoCode(ctx, query, nodes, nil,
-			func(n *PromoCodeUsage, e *PromoCode) { n.Edges.PromoCode = e }); err != nil {
-			return nil, err
-		}
-	}
-	if query := _q.withUser; query != nil {
-		if err := _q.loadUser(ctx, query, nodes, nil,
-			func(n *PromoCodeUsage, e *User) { n.Edges.User = e }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (_q *PromoCodeUsageQuery) loadPromoCode(ctx context.Context, query *PromoCodeQuery, nodes []*PromoCodeUsage, init func(*PromoCodeUsage), assign func(*PromoCodeUsage, *PromoCode)) error {
-	ids := make([]int64, 0, len(nodes))
-	nodeids := make(map[int64][]*PromoCodeUsage)
-	for i := range nodes {
-		fk := nodes[i].PromoCodeID
-		if _, ok := nodeids[fk]; !ok {
-			ids = append(ids, fk)
-		}
-		nodeids[fk] = append(nodeids[fk], nodes[i])
-	}
-	if len(ids) == 0 {
-		return nil
-	}
-	query.Where(promocode.IDIn(ids...))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nodeids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected foreign-key "promo_code_id" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
-func (_q *PromoCodeUsageQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*PromoCodeUsage, init func(*PromoCodeUsage), assign func(*PromoCodeUsage, *User)) error {
-	ids := make([]int64, 0, len(nodes))
-	nodeids := make(map[int64][]*PromoCodeUsage)
-	for i := range nodes {
-		fk := nodes[i].UserID
-		if _, ok := nodeids[fk]; !ok {
-			ids = append(ids, fk)
-		}
-		nodeids[fk] = append(nodeids[fk], nodes[i])
-	}
-	if len(ids) == 0 {
-		return nil
-	}
-	query.Where(user.IDIn(ids...))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nodeids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
-
-func (_q *PromoCodeUsageQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
-	_spec.Node.Columns = _q.ctx.Fields
-	if len(_q.ctx.Fields) > 0 {
-		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
-}
-
-func (_q *PromoCodeUsageQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(promocodeusage.Table, promocodeusage.Columns, sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64))
-	_spec.From = _q.sql
-	if unique := _q.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if _q.path != nil {
-		_spec.Unique = true
-	}
-	if fields := _q.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, promocodeusage.FieldID)
-		for i := range fields {
-			if fields[i] != promocodeusage.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-		if _q.withPromoCode != nil {
-			_spec.Node.AddColumnOnce(promocodeusage.FieldPromoCodeID)
-		}
-		if _q.withUser != nil {
-			_spec.Node.AddColumnOnce(promocodeusage.FieldUserID)
-		}
-	}
-	if ps := _q.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := _q.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (_q *PromoCodeUsageQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(_q.driver.Dialect())
-	t1 := builder.Table(promocodeusage.Table)
-	columns := _q.ctx.Fields
-	if len(columns) == 0 {
-		columns = promocodeusage.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if _q.sql != nil {
-		selector = _q.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if _q.ctx.Unique != nil && *_q.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
-	for _, p := range _q.predicates {
-		p(selector)
-	}
-	for _, p := range _q.order {
-		p(selector)
-	}
-	if offset := _q.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := _q.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *PromoCodeUsageQuery) ForUpdate(opts ...sql.LockOption) *PromoCodeUsageQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *PromoCodeUsageQuery) ForShare(opts ...sql.LockOption) *PromoCodeUsageQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// PromoCodeUsageGroupBy is the group-by builder for PromoCodeUsage entities.
-type PromoCodeUsageGroupBy struct {
-	selector
-	build *PromoCodeUsageQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (_g *PromoCodeUsageGroupBy) Aggregate(fns ...AggregateFunc) *PromoCodeUsageGroupBy {
-	_g.fns = append(_g.fns, fns...)
-	return _g
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_g *PromoCodeUsageGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
-	if err := _g.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*PromoCodeUsageQuery, *PromoCodeUsageGroupBy](ctx, _g.build, _g, _g.build.inters, v)
-}
-
-func (_g *PromoCodeUsageGroupBy) sqlScan(ctx context.Context, root *PromoCodeUsageQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(_g.fns))
-	for _, fn := range _g.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
-		for _, f := range *_g.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*_g.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// PromoCodeUsageSelect is the builder for selecting fields of PromoCodeUsage entities.
-type PromoCodeUsageSelect struct {
-	*PromoCodeUsageQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (_s *PromoCodeUsageSelect) Aggregate(fns ...AggregateFunc) *PromoCodeUsageSelect {
-	_s.fns = append(_s.fns, fns...)
-	return _s
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_s *PromoCodeUsageSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
-	if err := _s.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*PromoCodeUsageQuery, *PromoCodeUsageSelect](ctx, _s.PromoCodeUsageQuery, _s, _s.inters, v)
-}
-
-func (_s *PromoCodeUsageSelect) sqlScan(ctx context.Context, root *PromoCodeUsageQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(_s.fns))
-	for _, fn := range _s.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*_s.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}

backend/ent/promocodeusage_update.go

@@ -1,510 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
-	"github.com/Wei-Shaw/sub2api/ent/user"
-)
-
-// PromoCodeUsageUpdate is the builder for updating PromoCodeUsage entities.
-type PromoCodeUsageUpdate struct {
-	config
-	hooks    []Hook
-	mutation *PromoCodeUsageMutation
-}
-
-// Where appends a list predicates to the PromoCodeUsageUpdate builder.
-func (_u *PromoCodeUsageUpdate) Where(ps ...predicate.PromoCodeUsage) *PromoCodeUsageUpdate {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// SetPromoCodeID sets the "promo_code_id" field.
-func (_u *PromoCodeUsageUpdate) SetPromoCodeID(v int64) *PromoCodeUsageUpdate {
-	_u.mutation.SetPromoCodeID(v)
-	return _u
-}
-
-// SetNillablePromoCodeID sets the "promo_code_id" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdate) SetNillablePromoCodeID(v *int64) *PromoCodeUsageUpdate {
-	if v != nil {
-		_u.SetPromoCodeID(*v)
-	}
-	return _u
-}
-
-// SetUserID sets the "user_id" field.
-func (_u *PromoCodeUsageUpdate) SetUserID(v int64) *PromoCodeUsageUpdate {
-	_u.mutation.SetUserID(v)
-	return _u
-}
-
-// SetNillableUserID sets the "user_id" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdate) SetNillableUserID(v *int64) *PromoCodeUsageUpdate {
-	if v != nil {
-		_u.SetUserID(*v)
-	}
-	return _u
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (_u *PromoCodeUsageUpdate) SetBonusAmount(v float64) *PromoCodeUsageUpdate {
-	_u.mutation.ResetBonusAmount()
-	_u.mutation.SetBonusAmount(v)
-	return _u
-}
-
-// SetNillableBonusAmount sets the "bonus_amount" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdate) SetNillableBonusAmount(v *float64) *PromoCodeUsageUpdate {
-	if v != nil {
-		_u.SetBonusAmount(*v)
-	}
-	return _u
-}
-
-// AddBonusAmount adds value to the "bonus_amount" field.
-func (_u *PromoCodeUsageUpdate) AddBonusAmount(v float64) *PromoCodeUsageUpdate {
-	_u.mutation.AddBonusAmount(v)
-	return _u
-}
-
-// SetUsedAt sets the "used_at" field.
-func (_u *PromoCodeUsageUpdate) SetUsedAt(v time.Time) *PromoCodeUsageUpdate {
-	_u.mutation.SetUsedAt(v)
-	return _u
-}
-
-// SetNillableUsedAt sets the "used_at" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdate) SetNillableUsedAt(v *time.Time) *PromoCodeUsageUpdate {
-	if v != nil {
-		_u.SetUsedAt(*v)
-	}
-	return _u
-}
-
-// SetPromoCode sets the "promo_code" edge to the PromoCode entity.
-func (_u *PromoCodeUsageUpdate) SetPromoCode(v *PromoCode) *PromoCodeUsageUpdate {
-	return _u.SetPromoCodeID(v.ID)
-}
-
-// SetUser sets the "user" edge to the User entity.
-func (_u *PromoCodeUsageUpdate) SetUser(v *User) *PromoCodeUsageUpdate {
-	return _u.SetUserID(v.ID)
-}
-
-// Mutation returns the PromoCodeUsageMutation object of the builder.
-func (_u *PromoCodeUsageUpdate) Mutation() *PromoCodeUsageMutation {
-	return _u.mutation
-}
-
-// ClearPromoCode clears the "promo_code" edge to the PromoCode entity.
-func (_u *PromoCodeUsageUpdate) ClearPromoCode() *PromoCodeUsageUpdate {
-	_u.mutation.ClearPromoCode()
-	return _u
-}
-
-// ClearUser clears the "user" edge to the User entity.
-func (_u *PromoCodeUsageUpdate) ClearUser() *PromoCodeUsageUpdate {
-	_u.mutation.ClearUser()
-	return _u
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *PromoCodeUsageUpdate) Save(ctx context.Context) (int, error) {
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *PromoCodeUsageUpdate) SaveX(ctx context.Context) int {
-	affected, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (_u *PromoCodeUsageUpdate) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *PromoCodeUsageUpdate) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *PromoCodeUsageUpdate) check() error {
-	if _u.mutation.PromoCodeCleared() && len(_u.mutation.PromoCodeIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "PromoCodeUsage.promo_code"`)
-	}
-	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "PromoCodeUsage.user"`)
-	}
-	return nil
-}
-
-func (_u *PromoCodeUsageUpdate) sqlSave(ctx context.Context) (_node int, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(promocodeusage.Table, promocodeusage.Columns, sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64))
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.BonusAmount(); ok {
-		_spec.SetField(promocodeusage.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedBonusAmount(); ok {
-		_spec.AddField(promocodeusage.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.UsedAt(); ok {
-		_spec.SetField(promocodeusage.FieldUsedAt, field.TypeTime, value)
-	}
-	if _u.mutation.PromoCodeCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.PromoCodeTable,
-			Columns: []string{promocodeusage.PromoCodeColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.PromoCodeIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.PromoCodeTable,
-			Columns: []string{promocodeusage.PromoCodeColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _u.mutation.UserCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.UserTable,
-			Columns: []string{promocodeusage.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.UserTable,
-			Columns: []string{promocodeusage.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{promocodeusage.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}
-
-// PromoCodeUsageUpdateOne is the builder for updating a single PromoCodeUsage entity.
-type PromoCodeUsageUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *PromoCodeUsageMutation
-}
-
-// SetPromoCodeID sets the "promo_code_id" field.
-func (_u *PromoCodeUsageUpdateOne) SetPromoCodeID(v int64) *PromoCodeUsageUpdateOne {
-	_u.mutation.SetPromoCodeID(v)
-	return _u
-}
-
-// SetNillablePromoCodeID sets the "promo_code_id" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdateOne) SetNillablePromoCodeID(v *int64) *PromoCodeUsageUpdateOne {
-	if v != nil {
-		_u.SetPromoCodeID(*v)
-	}
-	return _u
-}
-
-// SetUserID sets the "user_id" field.
-func (_u *PromoCodeUsageUpdateOne) SetUserID(v int64) *PromoCodeUsageUpdateOne {
-	_u.mutation.SetUserID(v)
-	return _u
-}
-
-// SetNillableUserID sets the "user_id" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdateOne) SetNillableUserID(v *int64) *PromoCodeUsageUpdateOne {
-	if v != nil {
-		_u.SetUserID(*v)
-	}
-	return _u
-}
-
-// SetBonusAmount sets the "bonus_amount" field.
-func (_u *PromoCodeUsageUpdateOne) SetBonusAmount(v float64) *PromoCodeUsageUpdateOne {
-	_u.mutation.ResetBonusAmount()
-	_u.mutation.SetBonusAmount(v)
-	return _u
-}
-
-// SetNillableBonusAmount sets the "bonus_amount" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdateOne) SetNillableBonusAmount(v *float64) *PromoCodeUsageUpdateOne {
-	if v != nil {
-		_u.SetBonusAmount(*v)
-	}
-	return _u
-}
-
-// AddBonusAmount adds value to the "bonus_amount" field.
-func (_u *PromoCodeUsageUpdateOne) AddBonusAmount(v float64) *PromoCodeUsageUpdateOne {
-	_u.mutation.AddBonusAmount(v)
-	return _u
-}
-
-// SetUsedAt sets the "used_at" field.
-func (_u *PromoCodeUsageUpdateOne) SetUsedAt(v time.Time) *PromoCodeUsageUpdateOne {
-	_u.mutation.SetUsedAt(v)
-	return _u
-}
-
-// SetNillableUsedAt sets the "used_at" field if the given value is not nil.
-func (_u *PromoCodeUsageUpdateOne) SetNillableUsedAt(v *time.Time) *PromoCodeUsageUpdateOne {
-	if v != nil {
-		_u.SetUsedAt(*v)
-	}
-	return _u
-}
-
-// SetPromoCode sets the "promo_code" edge to the PromoCode entity.
-func (_u *PromoCodeUsageUpdateOne) SetPromoCode(v *PromoCode) *PromoCodeUsageUpdateOne {
-	return _u.SetPromoCodeID(v.ID)
-}
-
-// SetUser sets the "user" edge to the User entity.
-func (_u *PromoCodeUsageUpdateOne) SetUser(v *User) *PromoCodeUsageUpdateOne {
-	return _u.SetUserID(v.ID)
-}
-
-// Mutation returns the PromoCodeUsageMutation object of the builder.
-func (_u *PromoCodeUsageUpdateOne) Mutation() *PromoCodeUsageMutation {
-	return _u.mutation
-}
-
-// ClearPromoCode clears the "promo_code" edge to the PromoCode entity.
-func (_u *PromoCodeUsageUpdateOne) ClearPromoCode() *PromoCodeUsageUpdateOne {
-	_u.mutation.ClearPromoCode()
-	return _u
-}
-
-// ClearUser clears the "user" edge to the User entity.
-func (_u *PromoCodeUsageUpdateOne) ClearUser() *PromoCodeUsageUpdateOne {
-	_u.mutation.ClearUser()
-	return _u
-}
-
-// Where appends a list predicates to the PromoCodeUsageUpdate builder.
-func (_u *PromoCodeUsageUpdateOne) Where(ps ...predicate.PromoCodeUsage) *PromoCodeUsageUpdateOne {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (_u *PromoCodeUsageUpdateOne) Select(field string, fields ...string) *PromoCodeUsageUpdateOne {
-	_u.fields = append([]string{field}, fields...)
-	return _u
-}
-
-// Save executes the query and returns the updated PromoCodeUsage entity.
-func (_u *PromoCodeUsageUpdateOne) Save(ctx context.Context) (*PromoCodeUsage, error) {
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *PromoCodeUsageUpdateOne) SaveX(ctx context.Context) *PromoCodeUsage {
-	node, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (_u *PromoCodeUsageUpdateOne) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *PromoCodeUsageUpdateOne) ExecX(ctx context.Context) {
-	if err := _u.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *PromoCodeUsageUpdateOne) check() error {
-	if _u.mutation.PromoCodeCleared() && len(_u.mutation.PromoCodeIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "PromoCodeUsage.promo_code"`)
-	}
-	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "PromoCodeUsage.user"`)
-	}
-	return nil
-}
-
-func (_u *PromoCodeUsageUpdateOne) sqlSave(ctx context.Context) (_node *PromoCodeUsage, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(promocodeusage.Table, promocodeusage.Columns, sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64))
-	id, ok := _u.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "PromoCodeUsage.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := _u.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, promocodeusage.FieldID)
-		for _, f := range fields {
-			if !promocodeusage.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != promocodeusage.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := _u.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := _u.mutation.BonusAmount(); ok {
-		_spec.SetField(promocodeusage.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedBonusAmount(); ok {
-		_spec.AddField(promocodeusage.FieldBonusAmount, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.UsedAt(); ok {
-		_spec.SetField(promocodeusage.FieldUsedAt, field.TypeTime, value)
-	}
-	if _u.mutation.PromoCodeCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.PromoCodeTable,
-			Columns: []string{promocodeusage.PromoCodeColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.PromoCodeIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.PromoCodeTable,
-			Columns: []string{promocodeusage.PromoCodeColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocode.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if _u.mutation.UserCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.UserTable,
-			Columns: []string{promocodeusage.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   promocodeusage.UserTable,
-			Columns: []string{promocodeusage.UserColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	_node = &PromoCodeUsage{config: _u.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{promocodeusage.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}

backend/ent/proxy_query.go

@@ -9,7 +9,6 @@ import (
 	"math"
 
 	"entgo.io/ent"
-	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -26,7 +25,6 @@ type ProxyQuery struct {
 	inters       []Interceptor
 	predicates   []predicate.Proxy
 	withAccounts *AccountQuery
-	modifiers    []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -386,9 +384,6 @@ func (_q *ProxyQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Proxy,
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -444,9 +439,6 @@ func (_q *ProxyQuery) loadAccounts(ctx context.Context, query *AccountQuery, nod
 
 func (_q *ProxyQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	_spec.Node.Columns = _q.ctx.Fields
 	if len(_q.ctx.Fields) > 0 {
 		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
@@ -509,9 +501,6 @@ func (_q *ProxyQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if _q.ctx.Unique != nil && *_q.ctx.Unique {
 		selector.Distinct()
 	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
 	for _, p := range _q.predicates {
 		p(selector)
 	}
@@ -529,32 +518,6 @@ func (_q *ProxyQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *ProxyQuery) ForUpdate(opts ...sql.LockOption) *ProxyQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *ProxyQuery) ForShare(opts ...sql.LockOption) *ProxyQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // ProxyGroupBy is the group-by builder for Proxy entities.
 type ProxyGroupBy struct {
 	selector

backend/ent/redeemcode_query.go

@@ -8,7 +8,6 @@ import (
 	"math"
 
 	"entgo.io/ent"
-	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/dialect/sql/sqlgraph"
 	"entgo.io/ent/schema/field"
@@ -27,7 +26,6 @@ type RedeemCodeQuery struct {
 	predicates []predicate.RedeemCode
 	withUser   *UserQuery
 	withGroup  *GroupQuery
-	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -422,9 +420,6 @@ func (_q *RedeemCodeQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*R
 		node.Edges.loadedTypes = loadedTypes
 		return node.assignValues(columns, values)
 	}
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	for i := range hooks {
 		hooks[i](ctx, _spec)
 	}
@@ -516,9 +511,6 @@ func (_q *RedeemCodeQuery) loadGroup(ctx context.Context, query *GroupQuery, nod
 
 func (_q *RedeemCodeQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := _q.querySpec()
-	if len(_q.modifiers) > 0 {
-		_spec.Modifiers = _q.modifiers
-	}
 	_spec.Node.Columns = _q.ctx.Fields
 	if len(_q.ctx.Fields) > 0 {
 		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
@@ -587,9 +579,6 @@ func (_q *RedeemCodeQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	if _q.ctx.Unique != nil && *_q.ctx.Unique {
 		selector.Distinct()
 	}
-	for _, m := range _q.modifiers {
-		m(selector)
-	}
 	for _, p := range _q.predicates {
 		p(selector)
 	}
@@ -607,32 +596,6 @@ func (_q *RedeemCodeQuery) sqlQuery(ctx context.Context) *sql.Selector {
 	return selector
 }
 
-// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
-// updated, deleted or "selected ... for update" by other sessions, until the transaction is
-// either committed or rolled-back.
-func (_q *RedeemCodeQuery) ForUpdate(opts ...sql.LockOption) *RedeemCodeQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForUpdate(opts...)
-	})
-	return _q
-}
-
-// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
-// on any rows that are read. Other sessions can read the rows, but cannot modify them
-// until your transaction commits.
-func (_q *RedeemCodeQuery) ForShare(opts ...sql.LockOption) *RedeemCodeQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // RedeemCodeGroupBy is the group-by builder for RedeemCode entities.
 type RedeemCodeGroupBy struct {
 	selector

backend/ent/runtime/runtime.go

@@ -7,25 +7,15 @@ import (
 
 	"github.com/Wei-Shaw/sub2api/ent/account"
 	"github.com/Wei-Shaw/sub2api/ent/accountgroup"
-	"github.com/Wei-Shaw/sub2api/ent/announcement"
-	"github.com/Wei-Shaw/sub2api/ent/announcementread"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
-	"github.com/Wei-Shaw/sub2api/ent/errorpassthroughrule"
 	"github.com/Wei-Shaw/sub2api/ent/group"
-	"github.com/Wei-Shaw/sub2api/ent/idempotencyrecord"
-	"github.com/Wei-Shaw/sub2api/ent/promocode"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
 	"github.com/Wei-Shaw/sub2api/ent/proxy"
 	"github.com/Wei-Shaw/sub2api/ent/redeemcode"
 	"github.com/Wei-Shaw/sub2api/ent/schema"
-	"github.com/Wei-Shaw/sub2api/ent/securitysecret"
 	"github.com/Wei-Shaw/sub2api/ent/setting"
-	"github.com/Wei-Shaw/sub2api/ent/usagecleanuptask"
 	"github.com/Wei-Shaw/sub2api/ent/usagelog"
 	"github.com/Wei-Shaw/sub2api/ent/user"
 	"github.com/Wei-Shaw/sub2api/ent/userallowedgroup"
-	"github.com/Wei-Shaw/sub2api/ent/userattributedefinition"
-	"github.com/Wei-Shaw/sub2api/ent/userattributevalue"
 	"github.com/Wei-Shaw/sub2api/ent/usersubscription"
 )
 
@@ -33,14 +23,127 @@ import (
 // (default values, validators, hooks and policies) and stitches it
 // to their package variables.
 func init() {
-	apikeyMixin := schema.APIKey{}.Mixin()
+	accountMixin := schema.Account{}.Mixin()
+	accountMixinHooks1 := accountMixin[1].Hooks()
+	account.Hooks[0] = accountMixinHooks1[0]
+	accountMixinInters1 := accountMixin[1].Interceptors()
+	account.Interceptors[0] = accountMixinInters1[0]
+	accountMixinFields0 := accountMixin[0].Fields()
+	_ = accountMixinFields0
+	accountFields := schema.Account{}.Fields()
+	_ = accountFields
+	// accountDescCreatedAt is the schema descriptor for created_at field.
+	accountDescCreatedAt := accountMixinFields0[0].Descriptor()
+	// account.DefaultCreatedAt holds the default value on creation for the created_at field.
+	account.DefaultCreatedAt = accountDescCreatedAt.Default.(func() time.Time)
+	// accountDescUpdatedAt is the schema descriptor for updated_at field.
+	accountDescUpdatedAt := accountMixinFields0[1].Descriptor()
+	// account.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	account.DefaultUpdatedAt = accountDescUpdatedAt.Default.(func() time.Time)
+	// account.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	account.UpdateDefaultUpdatedAt = accountDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// accountDescName is the schema descriptor for name field.
+	accountDescName := accountFields[0].Descriptor()
+	// account.NameValidator is a validator for the "name" field. It is called by the builders before save.
+	account.NameValidator = func() func(string) error {
+		validators := accountDescName.Validators
+		fns := [...]func(string) error{
+			validators[0].(func(string) error),
+			validators[1].(func(string) error),
+		}
+		return func(name string) error {
+			for _, fn := range fns {
+				if err := fn(name); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+	}()
+	// accountDescPlatform is the schema descriptor for platform field.
+	accountDescPlatform := accountFields[1].Descriptor()
+	// account.PlatformValidator is a validator for the "platform" field. It is called by the builders before save.
+	account.PlatformValidator = func() func(string) error {
+		validators := accountDescPlatform.Validators
+		fns := [...]func(string) error{
+			validators[0].(func(string) error),
+			validators[1].(func(string) error),
+		}
+		return func(platform string) error {
+			for _, fn := range fns {
+				if err := fn(platform); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+	}()
+	// accountDescType is the schema descriptor for type field.
+	accountDescType := accountFields[2].Descriptor()
+	// account.TypeValidator is a validator for the "type" field. It is called by the builders before save.
+	account.TypeValidator = func() func(string) error {
+		validators := accountDescType.Validators
+		fns := [...]func(string) error{
+			validators[0].(func(string) error),
+			validators[1].(func(string) error),
+		}
+		return func(_type string) error {
+			for _, fn := range fns {
+				if err := fn(_type); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+	}()
+	// accountDescCredentials is the schema descriptor for credentials field.
+	accountDescCredentials := accountFields[3].Descriptor()
+	// account.DefaultCredentials holds the default value on creation for the credentials field.
+	account.DefaultCredentials = accountDescCredentials.Default.(func() map[string]interface{})
+	// accountDescExtra is the schema descriptor for extra field.
+	accountDescExtra := accountFields[4].Descriptor()
+	// account.DefaultExtra holds the default value on creation for the extra field.
+	account.DefaultExtra = accountDescExtra.Default.(func() map[string]interface{})
+	// accountDescConcurrency is the schema descriptor for concurrency field.
+	accountDescConcurrency := accountFields[6].Descriptor()
+	// account.DefaultConcurrency holds the default value on creation for the concurrency field.
+	account.DefaultConcurrency = accountDescConcurrency.Default.(int)
+	// accountDescPriority is the schema descriptor for priority field.
+	accountDescPriority := accountFields[7].Descriptor()
+	// account.DefaultPriority holds the default value on creation for the priority field.
+	account.DefaultPriority = accountDescPriority.Default.(int)
+	// accountDescStatus is the schema descriptor for status field.
+	accountDescStatus := accountFields[8].Descriptor()
+	// account.DefaultStatus holds the default value on creation for the status field.
+	account.DefaultStatus = accountDescStatus.Default.(string)
+	// account.StatusValidator is a validator for the "status" field. It is called by the builders before save.
+	account.StatusValidator = accountDescStatus.Validators[0].(func(string) error)
+	// accountDescSchedulable is the schema descriptor for schedulable field.
+	accountDescSchedulable := accountFields[11].Descriptor()
+	// account.DefaultSchedulable holds the default value on creation for the schedulable field.
+	account.DefaultSchedulable = accountDescSchedulable.Default.(bool)
+	// accountDescSessionWindowStatus is the schema descriptor for session_window_status field.
+	accountDescSessionWindowStatus := accountFields[17].Descriptor()
+	// account.SessionWindowStatusValidator is a validator for the "session_window_status" field. It is called by the builders before save.
+	account.SessionWindowStatusValidator = accountDescSessionWindowStatus.Validators[0].(func(string) error)
+	accountgroupFields := schema.AccountGroup{}.Fields()
+	_ = accountgroupFields
+	// accountgroupDescPriority is the schema descriptor for priority field.
+	accountgroupDescPriority := accountgroupFields[2].Descriptor()
+	// accountgroup.DefaultPriority holds the default value on creation for the priority field.
+	accountgroup.DefaultPriority = accountgroupDescPriority.Default.(int)
+	// accountgroupDescCreatedAt is the schema descriptor for created_at field.
+	accountgroupDescCreatedAt := accountgroupFields[3].Descriptor()
+	// accountgroup.DefaultCreatedAt holds the default value on creation for the created_at field.
+	accountgroup.DefaultCreatedAt = accountgroupDescCreatedAt.Default.(func() time.Time)
+	apikeyMixin := schema.ApiKey{}.Mixin()
 	apikeyMixinHooks1 := apikeyMixin[1].Hooks()
 	apikey.Hooks[0] = apikeyMixinHooks1[0]
 	apikeyMixinInters1 := apikeyMixin[1].Interceptors()
 	apikey.Interceptors[0] = apikeyMixinInters1[0]
 	apikeyMixinFields0 := apikeyMixin[0].Fields()
 	_ = apikeyMixinFields0
-	apikeyFields := schema.APIKey{}.Fields()
+	apikeyFields := schema.ApiKey{}.Fields()
 	_ = apikeyFields
 	// apikeyDescCreatedAt is the schema descriptor for created_at field.
 	apikeyDescCreatedAt := apikeyMixinFields0[0].Descriptor()
@@ -94,274 +197,6 @@ func init() {
 	apikey.DefaultStatus = apikeyDescStatus.Default.(string)
 	// apikey.StatusValidator is a validator for the "status" field. It is called by the builders before save.
 	apikey.StatusValidator = apikeyDescStatus.Validators[0].(func(string) error)
-	// apikeyDescQuota is the schema descriptor for quota field.
-	apikeyDescQuota := apikeyFields[8].Descriptor()
-	// apikey.DefaultQuota holds the default value on creation for the quota field.
-	apikey.DefaultQuota = apikeyDescQuota.Default.(float64)
-	// apikeyDescQuotaUsed is the schema descriptor for quota_used field.
-	apikeyDescQuotaUsed := apikeyFields[9].Descriptor()
-	// apikey.DefaultQuotaUsed holds the default value on creation for the quota_used field.
-	apikey.DefaultQuotaUsed = apikeyDescQuotaUsed.Default.(float64)
-	// apikeyDescRateLimit5h is the schema descriptor for rate_limit_5h field.
-	apikeyDescRateLimit5h := apikeyFields[11].Descriptor()
-	// apikey.DefaultRateLimit5h holds the default value on creation for the rate_limit_5h field.
-	apikey.DefaultRateLimit5h = apikeyDescRateLimit5h.Default.(float64)
-	// apikeyDescRateLimit1d is the schema descriptor for rate_limit_1d field.
-	apikeyDescRateLimit1d := apikeyFields[12].Descriptor()
-	// apikey.DefaultRateLimit1d holds the default value on creation for the rate_limit_1d field.
-	apikey.DefaultRateLimit1d = apikeyDescRateLimit1d.Default.(float64)
-	// apikeyDescRateLimit7d is the schema descriptor for rate_limit_7d field.
-	apikeyDescRateLimit7d := apikeyFields[13].Descriptor()
-	// apikey.DefaultRateLimit7d holds the default value on creation for the rate_limit_7d field.
-	apikey.DefaultRateLimit7d = apikeyDescRateLimit7d.Default.(float64)
-	// apikeyDescUsage5h is the schema descriptor for usage_5h field.
-	apikeyDescUsage5h := apikeyFields[14].Descriptor()
-	// apikey.DefaultUsage5h holds the default value on creation for the usage_5h field.
-	apikey.DefaultUsage5h = apikeyDescUsage5h.Default.(float64)
-	// apikeyDescUsage1d is the schema descriptor for usage_1d field.
-	apikeyDescUsage1d := apikeyFields[15].Descriptor()
-	// apikey.DefaultUsage1d holds the default value on creation for the usage_1d field.
-	apikey.DefaultUsage1d = apikeyDescUsage1d.Default.(float64)
-	// apikeyDescUsage7d is the schema descriptor for usage_7d field.
-	apikeyDescUsage7d := apikeyFields[16].Descriptor()
-	// apikey.DefaultUsage7d holds the default value on creation for the usage_7d field.
-	apikey.DefaultUsage7d = apikeyDescUsage7d.Default.(float64)
-	accountMixin := schema.Account{}.Mixin()
-	accountMixinHooks1 := accountMixin[1].Hooks()
-	account.Hooks[0] = accountMixinHooks1[0]
-	accountMixinInters1 := accountMixin[1].Interceptors()
-	account.Interceptors[0] = accountMixinInters1[0]
-	accountMixinFields0 := accountMixin[0].Fields()
-	_ = accountMixinFields0
-	accountFields := schema.Account{}.Fields()
-	_ = accountFields
-	// accountDescCreatedAt is the schema descriptor for created_at field.
-	accountDescCreatedAt := accountMixinFields0[0].Descriptor()
-	// account.DefaultCreatedAt holds the default value on creation for the created_at field.
-	account.DefaultCreatedAt = accountDescCreatedAt.Default.(func() time.Time)
-	// accountDescUpdatedAt is the schema descriptor for updated_at field.
-	accountDescUpdatedAt := accountMixinFields0[1].Descriptor()
-	// account.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	account.DefaultUpdatedAt = accountDescUpdatedAt.Default.(func() time.Time)
-	// account.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	account.UpdateDefaultUpdatedAt = accountDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// accountDescName is the schema descriptor for name field.
-	accountDescName := accountFields[0].Descriptor()
-	// account.NameValidator is a validator for the "name" field. It is called by the builders before save.
-	account.NameValidator = func() func(string) error {
-		validators := accountDescName.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(name string) error {
-			for _, fn := range fns {
-				if err := fn(name); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// accountDescPlatform is the schema descriptor for platform field.
-	accountDescPlatform := accountFields[2].Descriptor()
-	// account.PlatformValidator is a validator for the "platform" field. It is called by the builders before save.
-	account.PlatformValidator = func() func(string) error {
-		validators := accountDescPlatform.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(platform string) error {
-			for _, fn := range fns {
-				if err := fn(platform); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// accountDescType is the schema descriptor for type field.
-	accountDescType := accountFields[3].Descriptor()
-	// account.TypeValidator is a validator for the "type" field. It is called by the builders before save.
-	account.TypeValidator = func() func(string) error {
-		validators := accountDescType.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(_type string) error {
-			for _, fn := range fns {
-				if err := fn(_type); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// accountDescCredentials is the schema descriptor for credentials field.
-	accountDescCredentials := accountFields[4].Descriptor()
-	// account.DefaultCredentials holds the default value on creation for the credentials field.
-	account.DefaultCredentials = accountDescCredentials.Default.(func() map[string]interface{})
-	// accountDescExtra is the schema descriptor for extra field.
-	accountDescExtra := accountFields[5].Descriptor()
-	// account.DefaultExtra holds the default value on creation for the extra field.
-	account.DefaultExtra = accountDescExtra.Default.(func() map[string]interface{})
-	// accountDescConcurrency is the schema descriptor for concurrency field.
-	accountDescConcurrency := accountFields[7].Descriptor()
-	// account.DefaultConcurrency holds the default value on creation for the concurrency field.
-	account.DefaultConcurrency = accountDescConcurrency.Default.(int)
-	// accountDescPriority is the schema descriptor for priority field.
-	accountDescPriority := accountFields[9].Descriptor()
-	// account.DefaultPriority holds the default value on creation for the priority field.
-	account.DefaultPriority = accountDescPriority.Default.(int)
-	// accountDescRateMultiplier is the schema descriptor for rate_multiplier field.
-	accountDescRateMultiplier := accountFields[10].Descriptor()
-	// account.DefaultRateMultiplier holds the default value on creation for the rate_multiplier field.
-	account.DefaultRateMultiplier = accountDescRateMultiplier.Default.(float64)
-	// accountDescStatus is the schema descriptor for status field.
-	accountDescStatus := accountFields[11].Descriptor()
-	// account.DefaultStatus holds the default value on creation for the status field.
-	account.DefaultStatus = accountDescStatus.Default.(string)
-	// account.StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	account.StatusValidator = accountDescStatus.Validators[0].(func(string) error)
-	// accountDescAutoPauseOnExpired is the schema descriptor for auto_pause_on_expired field.
-	accountDescAutoPauseOnExpired := accountFields[15].Descriptor()
-	// account.DefaultAutoPauseOnExpired holds the default value on creation for the auto_pause_on_expired field.
-	account.DefaultAutoPauseOnExpired = accountDescAutoPauseOnExpired.Default.(bool)
-	// accountDescSchedulable is the schema descriptor for schedulable field.
-	accountDescSchedulable := accountFields[16].Descriptor()
-	// account.DefaultSchedulable holds the default value on creation for the schedulable field.
-	account.DefaultSchedulable = accountDescSchedulable.Default.(bool)
-	// accountDescSessionWindowStatus is the schema descriptor for session_window_status field.
-	accountDescSessionWindowStatus := accountFields[24].Descriptor()
-	// account.SessionWindowStatusValidator is a validator for the "session_window_status" field. It is called by the builders before save.
-	account.SessionWindowStatusValidator = accountDescSessionWindowStatus.Validators[0].(func(string) error)
-	accountgroupFields := schema.AccountGroup{}.Fields()
-	_ = accountgroupFields
-	// accountgroupDescPriority is the schema descriptor for priority field.
-	accountgroupDescPriority := accountgroupFields[2].Descriptor()
-	// accountgroup.DefaultPriority holds the default value on creation for the priority field.
-	accountgroup.DefaultPriority = accountgroupDescPriority.Default.(int)
-	// accountgroupDescCreatedAt is the schema descriptor for created_at field.
-	accountgroupDescCreatedAt := accountgroupFields[3].Descriptor()
-	// accountgroup.DefaultCreatedAt holds the default value on creation for the created_at field.
-	accountgroup.DefaultCreatedAt = accountgroupDescCreatedAt.Default.(func() time.Time)
-	announcementFields := schema.Announcement{}.Fields()
-	_ = announcementFields
-	// announcementDescTitle is the schema descriptor for title field.
-	announcementDescTitle := announcementFields[0].Descriptor()
-	// announcement.TitleValidator is a validator for the "title" field. It is called by the builders before save.
-	announcement.TitleValidator = func() func(string) error {
-		validators := announcementDescTitle.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(title string) error {
-			for _, fn := range fns {
-				if err := fn(title); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// announcementDescContent is the schema descriptor for content field.
-	announcementDescContent := announcementFields[1].Descriptor()
-	// announcement.ContentValidator is a validator for the "content" field. It is called by the builders before save.
-	announcement.ContentValidator = announcementDescContent.Validators[0].(func(string) error)
-	// announcementDescStatus is the schema descriptor for status field.
-	announcementDescStatus := announcementFields[2].Descriptor()
-	// announcement.DefaultStatus holds the default value on creation for the status field.
-	announcement.DefaultStatus = announcementDescStatus.Default.(string)
-	// announcement.StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	announcement.StatusValidator = announcementDescStatus.Validators[0].(func(string) error)
-	// announcementDescNotifyMode is the schema descriptor for notify_mode field.
-	announcementDescNotifyMode := announcementFields[3].Descriptor()
-	// announcement.DefaultNotifyMode holds the default value on creation for the notify_mode field.
-	announcement.DefaultNotifyMode = announcementDescNotifyMode.Default.(string)
-	// announcement.NotifyModeValidator is a validator for the "notify_mode" field. It is called by the builders before save.
-	announcement.NotifyModeValidator = announcementDescNotifyMode.Validators[0].(func(string) error)
-	// announcementDescCreatedAt is the schema descriptor for created_at field.
-	announcementDescCreatedAt := announcementFields[9].Descriptor()
-	// announcement.DefaultCreatedAt holds the default value on creation for the created_at field.
-	announcement.DefaultCreatedAt = announcementDescCreatedAt.Default.(func() time.Time)
-	// announcementDescUpdatedAt is the schema descriptor for updated_at field.
-	announcementDescUpdatedAt := announcementFields[10].Descriptor()
-	// announcement.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	announcement.DefaultUpdatedAt = announcementDescUpdatedAt.Default.(func() time.Time)
-	// announcement.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	announcement.UpdateDefaultUpdatedAt = announcementDescUpdatedAt.UpdateDefault.(func() time.Time)
-	announcementreadFields := schema.AnnouncementRead{}.Fields()
-	_ = announcementreadFields
-	// announcementreadDescReadAt is the schema descriptor for read_at field.
-	announcementreadDescReadAt := announcementreadFields[2].Descriptor()
-	// announcementread.DefaultReadAt holds the default value on creation for the read_at field.
-	announcementread.DefaultReadAt = announcementreadDescReadAt.Default.(func() time.Time)
-	// announcementreadDescCreatedAt is the schema descriptor for created_at field.
-	announcementreadDescCreatedAt := announcementreadFields[3].Descriptor()
-	// announcementread.DefaultCreatedAt holds the default value on creation for the created_at field.
-	announcementread.DefaultCreatedAt = announcementreadDescCreatedAt.Default.(func() time.Time)
-	errorpassthroughruleMixin := schema.ErrorPassthroughRule{}.Mixin()
-	errorpassthroughruleMixinFields0 := errorpassthroughruleMixin[0].Fields()
-	_ = errorpassthroughruleMixinFields0
-	errorpassthroughruleFields := schema.ErrorPassthroughRule{}.Fields()
-	_ = errorpassthroughruleFields
-	// errorpassthroughruleDescCreatedAt is the schema descriptor for created_at field.
-	errorpassthroughruleDescCreatedAt := errorpassthroughruleMixinFields0[0].Descriptor()
-	// errorpassthroughrule.DefaultCreatedAt holds the default value on creation for the created_at field.
-	errorpassthroughrule.DefaultCreatedAt = errorpassthroughruleDescCreatedAt.Default.(func() time.Time)
-	// errorpassthroughruleDescUpdatedAt is the schema descriptor for updated_at field.
-	errorpassthroughruleDescUpdatedAt := errorpassthroughruleMixinFields0[1].Descriptor()
-	// errorpassthroughrule.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	errorpassthroughrule.DefaultUpdatedAt = errorpassthroughruleDescUpdatedAt.Default.(func() time.Time)
-	// errorpassthroughrule.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	errorpassthroughrule.UpdateDefaultUpdatedAt = errorpassthroughruleDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// errorpassthroughruleDescName is the schema descriptor for name field.
-	errorpassthroughruleDescName := errorpassthroughruleFields[0].Descriptor()
-	// errorpassthroughrule.NameValidator is a validator for the "name" field. It is called by the builders before save.
-	errorpassthroughrule.NameValidator = func() func(string) error {
-		validators := errorpassthroughruleDescName.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(name string) error {
-			for _, fn := range fns {
-				if err := fn(name); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// errorpassthroughruleDescEnabled is the schema descriptor for enabled field.
-	errorpassthroughruleDescEnabled := errorpassthroughruleFields[1].Descriptor()
-	// errorpassthroughrule.DefaultEnabled holds the default value on creation for the enabled field.
-	errorpassthroughrule.DefaultEnabled = errorpassthroughruleDescEnabled.Default.(bool)
-	// errorpassthroughruleDescPriority is the schema descriptor for priority field.
-	errorpassthroughruleDescPriority := errorpassthroughruleFields[2].Descriptor()
-	// errorpassthroughrule.DefaultPriority holds the default value on creation for the priority field.
-	errorpassthroughrule.DefaultPriority = errorpassthroughruleDescPriority.Default.(int)
-	// errorpassthroughruleDescMatchMode is the schema descriptor for match_mode field.
-	errorpassthroughruleDescMatchMode := errorpassthroughruleFields[5].Descriptor()
-	// errorpassthroughrule.DefaultMatchMode holds the default value on creation for the match_mode field.
-	errorpassthroughrule.DefaultMatchMode = errorpassthroughruleDescMatchMode.Default.(string)
-	// errorpassthroughrule.MatchModeValidator is a validator for the "match_mode" field. It is called by the builders before save.
-	errorpassthroughrule.MatchModeValidator = errorpassthroughruleDescMatchMode.Validators[0].(func(string) error)
-	// errorpassthroughruleDescPassthroughCode is the schema descriptor for passthrough_code field.
-	errorpassthroughruleDescPassthroughCode := errorpassthroughruleFields[7].Descriptor()
-	// errorpassthroughrule.DefaultPassthroughCode holds the default value on creation for the passthrough_code field.
-	errorpassthroughrule.DefaultPassthroughCode = errorpassthroughruleDescPassthroughCode.Default.(bool)
-	// errorpassthroughruleDescPassthroughBody is the schema descriptor for passthrough_body field.
-	errorpassthroughruleDescPassthroughBody := errorpassthroughruleFields[9].Descriptor()
-	// errorpassthroughrule.DefaultPassthroughBody holds the default value on creation for the passthrough_body field.
-	errorpassthroughrule.DefaultPassthroughBody = errorpassthroughruleDescPassthroughBody.Default.(bool)
-	// errorpassthroughruleDescSkipMonitoring is the schema descriptor for skip_monitoring field.
-	errorpassthroughruleDescSkipMonitoring := errorpassthroughruleFields[11].Descriptor()
-	// errorpassthroughrule.DefaultSkipMonitoring holds the default value on creation for the skip_monitoring field.
-	errorpassthroughrule.DefaultSkipMonitoring = errorpassthroughruleDescSkipMonitoring.Default.(bool)
 	groupMixin := schema.Group{}.Mixin()
 	groupMixinHooks1 := groupMixin[1].Hooks()
 	group.Hooks[0] = groupMixinHooks1[0]
@@ -429,129 +264,6 @@ func init() {
 	groupDescDefaultValidityDays := groupFields[10].Descriptor()
 	// group.DefaultDefaultValidityDays holds the default value on creation for the default_validity_days field.
 	group.DefaultDefaultValidityDays = groupDescDefaultValidityDays.Default.(int)
-	// groupDescSoraStorageQuotaBytes is the schema descriptor for sora_storage_quota_bytes field.
-	groupDescSoraStorageQuotaBytes := groupFields[18].Descriptor()
-	// group.DefaultSoraStorageQuotaBytes holds the default value on creation for the sora_storage_quota_bytes field.
-	group.DefaultSoraStorageQuotaBytes = groupDescSoraStorageQuotaBytes.Default.(int64)
-	// groupDescClaudeCodeOnly is the schema descriptor for claude_code_only field.
-	groupDescClaudeCodeOnly := groupFields[19].Descriptor()
-	// group.DefaultClaudeCodeOnly holds the default value on creation for the claude_code_only field.
-	group.DefaultClaudeCodeOnly = groupDescClaudeCodeOnly.Default.(bool)
-	// groupDescModelRoutingEnabled is the schema descriptor for model_routing_enabled field.
-	groupDescModelRoutingEnabled := groupFields[23].Descriptor()
-	// group.DefaultModelRoutingEnabled holds the default value on creation for the model_routing_enabled field.
-	group.DefaultModelRoutingEnabled = groupDescModelRoutingEnabled.Default.(bool)
-	// groupDescMcpXMLInject is the schema descriptor for mcp_xml_inject field.
-	groupDescMcpXMLInject := groupFields[24].Descriptor()
-	// group.DefaultMcpXMLInject holds the default value on creation for the mcp_xml_inject field.
-	group.DefaultMcpXMLInject = groupDescMcpXMLInject.Default.(bool)
-	// groupDescSupportedModelScopes is the schema descriptor for supported_model_scopes field.
-	groupDescSupportedModelScopes := groupFields[25].Descriptor()
-	// group.DefaultSupportedModelScopes holds the default value on creation for the supported_model_scopes field.
-	group.DefaultSupportedModelScopes = groupDescSupportedModelScopes.Default.([]string)
-	// groupDescSortOrder is the schema descriptor for sort_order field.
-	groupDescSortOrder := groupFields[26].Descriptor()
-	// group.DefaultSortOrder holds the default value on creation for the sort_order field.
-	group.DefaultSortOrder = groupDescSortOrder.Default.(int)
-	// groupDescAllowMessagesDispatch is the schema descriptor for allow_messages_dispatch field.
-	groupDescAllowMessagesDispatch := groupFields[27].Descriptor()
-	// group.DefaultAllowMessagesDispatch holds the default value on creation for the allow_messages_dispatch field.
-	group.DefaultAllowMessagesDispatch = groupDescAllowMessagesDispatch.Default.(bool)
-	// groupDescDefaultMappedModel is the schema descriptor for default_mapped_model field.
-	groupDescDefaultMappedModel := groupFields[28].Descriptor()
-	// group.DefaultDefaultMappedModel holds the default value on creation for the default_mapped_model field.
-	group.DefaultDefaultMappedModel = groupDescDefaultMappedModel.Default.(string)
-	// group.DefaultMappedModelValidator is a validator for the "default_mapped_model" field. It is called by the builders before save.
-	group.DefaultMappedModelValidator = groupDescDefaultMappedModel.Validators[0].(func(string) error)
-	idempotencyrecordMixin := schema.IdempotencyRecord{}.Mixin()
-	idempotencyrecordMixinFields0 := idempotencyrecordMixin[0].Fields()
-	_ = idempotencyrecordMixinFields0
-	idempotencyrecordFields := schema.IdempotencyRecord{}.Fields()
-	_ = idempotencyrecordFields
-	// idempotencyrecordDescCreatedAt is the schema descriptor for created_at field.
-	idempotencyrecordDescCreatedAt := idempotencyrecordMixinFields0[0].Descriptor()
-	// idempotencyrecord.DefaultCreatedAt holds the default value on creation for the created_at field.
-	idempotencyrecord.DefaultCreatedAt = idempotencyrecordDescCreatedAt.Default.(func() time.Time)
-	// idempotencyrecordDescUpdatedAt is the schema descriptor for updated_at field.
-	idempotencyrecordDescUpdatedAt := idempotencyrecordMixinFields0[1].Descriptor()
-	// idempotencyrecord.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	idempotencyrecord.DefaultUpdatedAt = idempotencyrecordDescUpdatedAt.Default.(func() time.Time)
-	// idempotencyrecord.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	idempotencyrecord.UpdateDefaultUpdatedAt = idempotencyrecordDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// idempotencyrecordDescScope is the schema descriptor for scope field.
-	idempotencyrecordDescScope := idempotencyrecordFields[0].Descriptor()
-	// idempotencyrecord.ScopeValidator is a validator for the "scope" field. It is called by the builders before save.
-	idempotencyrecord.ScopeValidator = idempotencyrecordDescScope.Validators[0].(func(string) error)
-	// idempotencyrecordDescIdempotencyKeyHash is the schema descriptor for idempotency_key_hash field.
-	idempotencyrecordDescIdempotencyKeyHash := idempotencyrecordFields[1].Descriptor()
-	// idempotencyrecord.IdempotencyKeyHashValidator is a validator for the "idempotency_key_hash" field. It is called by the builders before save.
-	idempotencyrecord.IdempotencyKeyHashValidator = idempotencyrecordDescIdempotencyKeyHash.Validators[0].(func(string) error)
-	// idempotencyrecordDescRequestFingerprint is the schema descriptor for request_fingerprint field.
-	idempotencyrecordDescRequestFingerprint := idempotencyrecordFields[2].Descriptor()
-	// idempotencyrecord.RequestFingerprintValidator is a validator for the "request_fingerprint" field. It is called by the builders before save.
-	idempotencyrecord.RequestFingerprintValidator = idempotencyrecordDescRequestFingerprint.Validators[0].(func(string) error)
-	// idempotencyrecordDescStatus is the schema descriptor for status field.
-	idempotencyrecordDescStatus := idempotencyrecordFields[3].Descriptor()
-	// idempotencyrecord.StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	idempotencyrecord.StatusValidator = idempotencyrecordDescStatus.Validators[0].(func(string) error)
-	// idempotencyrecordDescErrorReason is the schema descriptor for error_reason field.
-	idempotencyrecordDescErrorReason := idempotencyrecordFields[6].Descriptor()
-	// idempotencyrecord.ErrorReasonValidator is a validator for the "error_reason" field. It is called by the builders before save.
-	idempotencyrecord.ErrorReasonValidator = idempotencyrecordDescErrorReason.Validators[0].(func(string) error)
-	promocodeFields := schema.PromoCode{}.Fields()
-	_ = promocodeFields
-	// promocodeDescCode is the schema descriptor for code field.
-	promocodeDescCode := promocodeFields[0].Descriptor()
-	// promocode.CodeValidator is a validator for the "code" field. It is called by the builders before save.
-	promocode.CodeValidator = func() func(string) error {
-		validators := promocodeDescCode.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(code string) error {
-			for _, fn := range fns {
-				if err := fn(code); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// promocodeDescBonusAmount is the schema descriptor for bonus_amount field.
-	promocodeDescBonusAmount := promocodeFields[1].Descriptor()
-	// promocode.DefaultBonusAmount holds the default value on creation for the bonus_amount field.
-	promocode.DefaultBonusAmount = promocodeDescBonusAmount.Default.(float64)
-	// promocodeDescMaxUses is the schema descriptor for max_uses field.
-	promocodeDescMaxUses := promocodeFields[2].Descriptor()
-	// promocode.DefaultMaxUses holds the default value on creation for the max_uses field.
-	promocode.DefaultMaxUses = promocodeDescMaxUses.Default.(int)
-	// promocodeDescUsedCount is the schema descriptor for used_count field.
-	promocodeDescUsedCount := promocodeFields[3].Descriptor()
-	// promocode.DefaultUsedCount holds the default value on creation for the used_count field.
-	promocode.DefaultUsedCount = promocodeDescUsedCount.Default.(int)
-	// promocodeDescStatus is the schema descriptor for status field.
-	promocodeDescStatus := promocodeFields[4].Descriptor()
-	// promocode.DefaultStatus holds the default value on creation for the status field.
-	promocode.DefaultStatus = promocodeDescStatus.Default.(string)
-	// promocode.StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	promocode.StatusValidator = promocodeDescStatus.Validators[0].(func(string) error)
-	// promocodeDescCreatedAt is the schema descriptor for created_at field.
-	promocodeDescCreatedAt := promocodeFields[7].Descriptor()
-	// promocode.DefaultCreatedAt holds the default value on creation for the created_at field.
-	promocode.DefaultCreatedAt = promocodeDescCreatedAt.Default.(func() time.Time)
-	// promocodeDescUpdatedAt is the schema descriptor for updated_at field.
-	promocodeDescUpdatedAt := promocodeFields[8].Descriptor()
-	// promocode.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	promocode.DefaultUpdatedAt = promocodeDescUpdatedAt.Default.(func() time.Time)
-	// promocode.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	promocode.UpdateDefaultUpdatedAt = promocodeDescUpdatedAt.UpdateDefault.(func() time.Time)
-	promocodeusageFields := schema.PromoCodeUsage{}.Fields()
-	_ = promocodeusageFields
-	// promocodeusageDescUsedAt is the schema descriptor for used_at field.
-	promocodeusageDescUsedAt := promocodeusageFields[3].Descriptor()
-	// promocodeusage.DefaultUsedAt holds the default value on creation for the used_at field.
-	promocodeusage.DefaultUsedAt = promocodeusageDescUsedAt.Default.(func() time.Time)
 	proxyMixin := schema.Proxy{}.Mixin()
 	proxyMixinHooks1 := proxyMixin[1].Hooks()
 	proxy.Hooks[0] = proxyMixinHooks1[0]
@@ -683,43 +395,6 @@ func init() {
 	redeemcodeDescValidityDays := redeemcodeFields[9].Descriptor()
 	// redeemcode.DefaultValidityDays holds the default value on creation for the validity_days field.
 	redeemcode.DefaultValidityDays = redeemcodeDescValidityDays.Default.(int)
-	securitysecretMixin := schema.SecuritySecret{}.Mixin()
-	securitysecretMixinFields0 := securitysecretMixin[0].Fields()
-	_ = securitysecretMixinFields0
-	securitysecretFields := schema.SecuritySecret{}.Fields()
-	_ = securitysecretFields
-	// securitysecretDescCreatedAt is the schema descriptor for created_at field.
-	securitysecretDescCreatedAt := securitysecretMixinFields0[0].Descriptor()
-	// securitysecret.DefaultCreatedAt holds the default value on creation for the created_at field.
-	securitysecret.DefaultCreatedAt = securitysecretDescCreatedAt.Default.(func() time.Time)
-	// securitysecretDescUpdatedAt is the schema descriptor for updated_at field.
-	securitysecretDescUpdatedAt := securitysecretMixinFields0[1].Descriptor()
-	// securitysecret.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	securitysecret.DefaultUpdatedAt = securitysecretDescUpdatedAt.Default.(func() time.Time)
-	// securitysecret.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	securitysecret.UpdateDefaultUpdatedAt = securitysecretDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// securitysecretDescKey is the schema descriptor for key field.
-	securitysecretDescKey := securitysecretFields[0].Descriptor()
-	// securitysecret.KeyValidator is a validator for the "key" field. It is called by the builders before save.
-	securitysecret.KeyValidator = func() func(string) error {
-		validators := securitysecretDescKey.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(key string) error {
-			for _, fn := range fns {
-				if err := fn(key); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// securitysecretDescValue is the schema descriptor for value field.
-	securitysecretDescValue := securitysecretFields[1].Descriptor()
-	// securitysecret.ValueValidator is a validator for the "value" field. It is called by the builders before save.
-	securitysecret.ValueValidator = securitysecretDescValue.Validators[0].(func(string) error)
 	settingFields := schema.Setting{}.Fields()
 	_ = settingFields
 	// settingDescKey is the schema descriptor for key field.
@@ -746,43 +421,6 @@ func init() {
 	setting.DefaultUpdatedAt = settingDescUpdatedAt.Default.(func() time.Time)
 	// setting.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
 	setting.UpdateDefaultUpdatedAt = settingDescUpdatedAt.UpdateDefault.(func() time.Time)
-	usagecleanuptaskMixin := schema.UsageCleanupTask{}.Mixin()
-	usagecleanuptaskMixinFields0 := usagecleanuptaskMixin[0].Fields()
-	_ = usagecleanuptaskMixinFields0
-	usagecleanuptaskFields := schema.UsageCleanupTask{}.Fields()
-	_ = usagecleanuptaskFields
-	// usagecleanuptaskDescCreatedAt is the schema descriptor for created_at field.
-	usagecleanuptaskDescCreatedAt := usagecleanuptaskMixinFields0[0].Descriptor()
-	// usagecleanuptask.DefaultCreatedAt holds the default value on creation for the created_at field.
-	usagecleanuptask.DefaultCreatedAt = usagecleanuptaskDescCreatedAt.Default.(func() time.Time)
-	// usagecleanuptaskDescUpdatedAt is the schema descriptor for updated_at field.
-	usagecleanuptaskDescUpdatedAt := usagecleanuptaskMixinFields0[1].Descriptor()
-	// usagecleanuptask.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	usagecleanuptask.DefaultUpdatedAt = usagecleanuptaskDescUpdatedAt.Default.(func() time.Time)
-	// usagecleanuptask.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	usagecleanuptask.UpdateDefaultUpdatedAt = usagecleanuptaskDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// usagecleanuptaskDescStatus is the schema descriptor for status field.
-	usagecleanuptaskDescStatus := usagecleanuptaskFields[0].Descriptor()
-	// usagecleanuptask.StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	usagecleanuptask.StatusValidator = func() func(string) error {
-		validators := usagecleanuptaskDescStatus.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(status string) error {
-			for _, fn := range fns {
-				if err := fn(status); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// usagecleanuptaskDescDeletedRows is the schema descriptor for deleted_rows field.
-	usagecleanuptaskDescDeletedRows := usagecleanuptaskFields[3].Descriptor()
-	// usagecleanuptask.DefaultDeletedRows holds the default value on creation for the deleted_rows field.
-	usagecleanuptask.DefaultDeletedRows = usagecleanuptaskDescDeletedRows.Default.(int64)
 	usagelogFields := schema.UsageLog{}.Fields()
 	_ = usagelogFields
 	// usagelogDescRequestID is the schema descriptor for request_id field.
@@ -874,39 +512,15 @@ func init() {
 	// usagelog.DefaultRateMultiplier holds the default value on creation for the rate_multiplier field.
 	usagelog.DefaultRateMultiplier = usagelogDescRateMultiplier.Default.(float64)
 	// usagelogDescBillingType is the schema descriptor for billing_type field.
-	usagelogDescBillingType := usagelogFields[21].Descriptor()
+	usagelogDescBillingType := usagelogFields[20].Descriptor()
 	// usagelog.DefaultBillingType holds the default value on creation for the billing_type field.
 	usagelog.DefaultBillingType = usagelogDescBillingType.Default.(int8)
 	// usagelogDescStream is the schema descriptor for stream field.
-	usagelogDescStream := usagelogFields[22].Descriptor()
+	usagelogDescStream := usagelogFields[21].Descriptor()
 	// usagelog.DefaultStream holds the default value on creation for the stream field.
 	usagelog.DefaultStream = usagelogDescStream.Default.(bool)
-	// usagelogDescUserAgent is the schema descriptor for user_agent field.
-	usagelogDescUserAgent := usagelogFields[25].Descriptor()
-	// usagelog.UserAgentValidator is a validator for the "user_agent" field. It is called by the builders before save.
-	usagelog.UserAgentValidator = usagelogDescUserAgent.Validators[0].(func(string) error)
-	// usagelogDescIPAddress is the schema descriptor for ip_address field.
-	usagelogDescIPAddress := usagelogFields[26].Descriptor()
-	// usagelog.IPAddressValidator is a validator for the "ip_address" field. It is called by the builders before save.
-	usagelog.IPAddressValidator = usagelogDescIPAddress.Validators[0].(func(string) error)
-	// usagelogDescImageCount is the schema descriptor for image_count field.
-	usagelogDescImageCount := usagelogFields[27].Descriptor()
-	// usagelog.DefaultImageCount holds the default value on creation for the image_count field.
-	usagelog.DefaultImageCount = usagelogDescImageCount.Default.(int)
-	// usagelogDescImageSize is the schema descriptor for image_size field.
-	usagelogDescImageSize := usagelogFields[28].Descriptor()
-	// usagelog.ImageSizeValidator is a validator for the "image_size" field. It is called by the builders before save.
-	usagelog.ImageSizeValidator = usagelogDescImageSize.Validators[0].(func(string) error)
-	// usagelogDescMediaType is the schema descriptor for media_type field.
-	usagelogDescMediaType := usagelogFields[29].Descriptor()
-	// usagelog.MediaTypeValidator is a validator for the "media_type" field. It is called by the builders before save.
-	usagelog.MediaTypeValidator = usagelogDescMediaType.Validators[0].(func(string) error)
-	// usagelogDescCacheTTLOverridden is the schema descriptor for cache_ttl_overridden field.
-	usagelogDescCacheTTLOverridden := usagelogFields[30].Descriptor()
-	// usagelog.DefaultCacheTTLOverridden holds the default value on creation for the cache_ttl_overridden field.
-	usagelog.DefaultCacheTTLOverridden = usagelogDescCacheTTLOverridden.Default.(bool)
 	// usagelogDescCreatedAt is the schema descriptor for created_at field.
-	usagelogDescCreatedAt := usagelogFields[31].Descriptor()
+	usagelogDescCreatedAt := usagelogFields[24].Descriptor()
 	// usagelog.DefaultCreatedAt holds the default value on creation for the created_at field.
 	usagelog.DefaultCreatedAt = usagelogDescCreatedAt.Default.(func() time.Time)
 	userMixin := schema.User{}.Mixin()
@@ -990,150 +604,22 @@ func init() {
 	user.DefaultUsername = userDescUsername.Default.(string)
 	// user.UsernameValidator is a validator for the "username" field. It is called by the builders before save.
 	user.UsernameValidator = userDescUsername.Validators[0].(func(string) error)
+	// userDescWechat is the schema descriptor for wechat field.
+	userDescWechat := userFields[7].Descriptor()
+	// user.DefaultWechat holds the default value on creation for the wechat field.
+	user.DefaultWechat = userDescWechat.Default.(string)
+	// user.WechatValidator is a validator for the "wechat" field. It is called by the builders before save.
+	user.WechatValidator = userDescWechat.Validators[0].(func(string) error)
 	// userDescNotes is the schema descriptor for notes field.
-	userDescNotes := userFields[7].Descriptor()
+	userDescNotes := userFields[8].Descriptor()
 	// user.DefaultNotes holds the default value on creation for the notes field.
 	user.DefaultNotes = userDescNotes.Default.(string)
-	// userDescTotpEnabled is the schema descriptor for totp_enabled field.
-	userDescTotpEnabled := userFields[9].Descriptor()
-	// user.DefaultTotpEnabled holds the default value on creation for the totp_enabled field.
-	user.DefaultTotpEnabled = userDescTotpEnabled.Default.(bool)
-	// userDescSoraStorageQuotaBytes is the schema descriptor for sora_storage_quota_bytes field.
-	userDescSoraStorageQuotaBytes := userFields[11].Descriptor()
-	// user.DefaultSoraStorageQuotaBytes holds the default value on creation for the sora_storage_quota_bytes field.
-	user.DefaultSoraStorageQuotaBytes = userDescSoraStorageQuotaBytes.Default.(int64)
-	// userDescSoraStorageUsedBytes is the schema descriptor for sora_storage_used_bytes field.
-	userDescSoraStorageUsedBytes := userFields[12].Descriptor()
-	// user.DefaultSoraStorageUsedBytes holds the default value on creation for the sora_storage_used_bytes field.
-	user.DefaultSoraStorageUsedBytes = userDescSoraStorageUsedBytes.Default.(int64)
 	userallowedgroupFields := schema.UserAllowedGroup{}.Fields()
 	_ = userallowedgroupFields
 	// userallowedgroupDescCreatedAt is the schema descriptor for created_at field.
 	userallowedgroupDescCreatedAt := userallowedgroupFields[2].Descriptor()
 	// userallowedgroup.DefaultCreatedAt holds the default value on creation for the created_at field.
 	userallowedgroup.DefaultCreatedAt = userallowedgroupDescCreatedAt.Default.(func() time.Time)
-	userattributedefinitionMixin := schema.UserAttributeDefinition{}.Mixin()
-	userattributedefinitionMixinHooks1 := userattributedefinitionMixin[1].Hooks()
-	userattributedefinition.Hooks[0] = userattributedefinitionMixinHooks1[0]
-	userattributedefinitionMixinInters1 := userattributedefinitionMixin[1].Interceptors()
-	userattributedefinition.Interceptors[0] = userattributedefinitionMixinInters1[0]
-	userattributedefinitionMixinFields0 := userattributedefinitionMixin[0].Fields()
-	_ = userattributedefinitionMixinFields0
-	userattributedefinitionFields := schema.UserAttributeDefinition{}.Fields()
-	_ = userattributedefinitionFields
-	// userattributedefinitionDescCreatedAt is the schema descriptor for created_at field.
-	userattributedefinitionDescCreatedAt := userattributedefinitionMixinFields0[0].Descriptor()
-	// userattributedefinition.DefaultCreatedAt holds the default value on creation for the created_at field.
-	userattributedefinition.DefaultCreatedAt = userattributedefinitionDescCreatedAt.Default.(func() time.Time)
-	// userattributedefinitionDescUpdatedAt is the schema descriptor for updated_at field.
-	userattributedefinitionDescUpdatedAt := userattributedefinitionMixinFields0[1].Descriptor()
-	// userattributedefinition.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	userattributedefinition.DefaultUpdatedAt = userattributedefinitionDescUpdatedAt.Default.(func() time.Time)
-	// userattributedefinition.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	userattributedefinition.UpdateDefaultUpdatedAt = userattributedefinitionDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// userattributedefinitionDescKey is the schema descriptor for key field.
-	userattributedefinitionDescKey := userattributedefinitionFields[0].Descriptor()
-	// userattributedefinition.KeyValidator is a validator for the "key" field. It is called by the builders before save.
-	userattributedefinition.KeyValidator = func() func(string) error {
-		validators := userattributedefinitionDescKey.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(key string) error {
-			for _, fn := range fns {
-				if err := fn(key); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// userattributedefinitionDescName is the schema descriptor for name field.
-	userattributedefinitionDescName := userattributedefinitionFields[1].Descriptor()
-	// userattributedefinition.NameValidator is a validator for the "name" field. It is called by the builders before save.
-	userattributedefinition.NameValidator = func() func(string) error {
-		validators := userattributedefinitionDescName.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(name string) error {
-			for _, fn := range fns {
-				if err := fn(name); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// userattributedefinitionDescDescription is the schema descriptor for description field.
-	userattributedefinitionDescDescription := userattributedefinitionFields[2].Descriptor()
-	// userattributedefinition.DefaultDescription holds the default value on creation for the description field.
-	userattributedefinition.DefaultDescription = userattributedefinitionDescDescription.Default.(string)
-	// userattributedefinitionDescType is the schema descriptor for type field.
-	userattributedefinitionDescType := userattributedefinitionFields[3].Descriptor()
-	// userattributedefinition.TypeValidator is a validator for the "type" field. It is called by the builders before save.
-	userattributedefinition.TypeValidator = func() func(string) error {
-		validators := userattributedefinitionDescType.Validators
-		fns := [...]func(string) error{
-			validators[0].(func(string) error),
-			validators[1].(func(string) error),
-		}
-		return func(_type string) error {
-			for _, fn := range fns {
-				if err := fn(_type); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	}()
-	// userattributedefinitionDescOptions is the schema descriptor for options field.
-	userattributedefinitionDescOptions := userattributedefinitionFields[4].Descriptor()
-	// userattributedefinition.DefaultOptions holds the default value on creation for the options field.
-	userattributedefinition.DefaultOptions = userattributedefinitionDescOptions.Default.([]map[string]interface{})
-	// userattributedefinitionDescRequired is the schema descriptor for required field.
-	userattributedefinitionDescRequired := userattributedefinitionFields[5].Descriptor()
-	// userattributedefinition.DefaultRequired holds the default value on creation for the required field.
-	userattributedefinition.DefaultRequired = userattributedefinitionDescRequired.Default.(bool)
-	// userattributedefinitionDescValidation is the schema descriptor for validation field.
-	userattributedefinitionDescValidation := userattributedefinitionFields[6].Descriptor()
-	// userattributedefinition.DefaultValidation holds the default value on creation for the validation field.
-	userattributedefinition.DefaultValidation = userattributedefinitionDescValidation.Default.(map[string]interface{})
-	// userattributedefinitionDescPlaceholder is the schema descriptor for placeholder field.
-	userattributedefinitionDescPlaceholder := userattributedefinitionFields[7].Descriptor()
-	// userattributedefinition.DefaultPlaceholder holds the default value on creation for the placeholder field.
-	userattributedefinition.DefaultPlaceholder = userattributedefinitionDescPlaceholder.Default.(string)
-	// userattributedefinition.PlaceholderValidator is a validator for the "placeholder" field. It is called by the builders before save.
-	userattributedefinition.PlaceholderValidator = userattributedefinitionDescPlaceholder.Validators[0].(func(string) error)
-	// userattributedefinitionDescDisplayOrder is the schema descriptor for display_order field.
-	userattributedefinitionDescDisplayOrder := userattributedefinitionFields[8].Descriptor()
-	// userattributedefinition.DefaultDisplayOrder holds the default value on creation for the display_order field.
-	userattributedefinition.DefaultDisplayOrder = userattributedefinitionDescDisplayOrder.Default.(int)
-	// userattributedefinitionDescEnabled is the schema descriptor for enabled field.
-	userattributedefinitionDescEnabled := userattributedefinitionFields[9].Descriptor()
-	// userattributedefinition.DefaultEnabled holds the default value on creation for the enabled field.
-	userattributedefinition.DefaultEnabled = userattributedefinitionDescEnabled.Default.(bool)
-	userattributevalueMixin := schema.UserAttributeValue{}.Mixin()
-	userattributevalueMixinFields0 := userattributevalueMixin[0].Fields()
-	_ = userattributevalueMixinFields0
-	userattributevalueFields := schema.UserAttributeValue{}.Fields()
-	_ = userattributevalueFields
-	// userattributevalueDescCreatedAt is the schema descriptor for created_at field.
-	userattributevalueDescCreatedAt := userattributevalueMixinFields0[0].Descriptor()
-	// userattributevalue.DefaultCreatedAt holds the default value on creation for the created_at field.
-	userattributevalue.DefaultCreatedAt = userattributevalueDescCreatedAt.Default.(func() time.Time)
-	// userattributevalueDescUpdatedAt is the schema descriptor for updated_at field.
-	userattributevalueDescUpdatedAt := userattributevalueMixinFields0[1].Descriptor()
-	// userattributevalue.DefaultUpdatedAt holds the default value on creation for the updated_at field.
-	userattributevalue.DefaultUpdatedAt = userattributevalueDescUpdatedAt.Default.(func() time.Time)
-	// userattributevalue.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
-	userattributevalue.UpdateDefaultUpdatedAt = userattributevalueDescUpdatedAt.UpdateDefault.(func() time.Time)
-	// userattributevalueDescValue is the schema descriptor for value field.
-	userattributevalueDescValue := userattributevalueFields[2].Descriptor()
-	// userattributevalue.DefaultValue holds the default value on creation for the value field.
-	userattributevalue.DefaultValue = userattributevalueDescValue.Default.(string)
 	usersubscriptionMixin := schema.UserSubscription{}.Mixin()
 	usersubscriptionMixinHooks1 := usersubscriptionMixin[1].Hooks()
 	usersubscription.Hooks[0] = usersubscriptionMixinHooks1[0]

backend/ent/schema/account.go

@@ -4,7 +4,7 @@ package schema
 
 import (
 	"github.com/Wei-Shaw/sub2api/ent/schema/mixins"
-	"github.com/Wei-Shaw/sub2api/internal/domain"
+	"github.com/Wei-Shaw/sub2api/internal/service"
 
 	"entgo.io/ent"
 	"entgo.io/ent/dialect"
@@ -54,11 +54,6 @@ func (Account) Fields() []ent.Field {
 		field.String("name").
 			MaxLen(100).
 			NotEmpty(),
-		// notes: 管理员备注（可为空）
-		field.String("notes").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "text"}),
 
 		// platform: 所属平台，如 "claude", "gemini", "openai" 等
 		field.String("platform").
@@ -97,23 +92,15 @@ func (Account) Fields() []ent.Field {
 		field.Int("concurrency").
 			Default(3),
 
-		field.Int("load_factor").Optional().Nillable(),
-
 		// priority: 账户优先级，数值越小优先级越高
 		// 调度器会优先使用高优先级的账户
 		field.Int("priority").
 			Default(50),
 
-		// rate_multiplier: 账号计费倍率（>=0，允许 0 表示该账号计费为 0）
-		// 仅影响账号维度计费口径，不影响用户/API Key 扣费（分组倍率）
-		field.Float("rate_multiplier").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(10,4)"}).
-			Default(1.0),
-
 		// status: 账户状态，如 "active", "error", "disabled"
 		field.String("status").
 			MaxLen(20).
-			Default(domain.StatusActive),
+			Default(service.StatusActive),
 
 		// error_message: 错误信息，记录账户异常时的详细信息
 		field.String("error_message").
@@ -126,16 +113,6 @@ func (Account) Fields() []ent.Field {
 			Optional().
 			Nillable().
 			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}),
-		// expires_at: 账户过期时间（可为空）
-		field.Time("expires_at").
-			Optional().
-			Nillable().
-			Comment("Account expiration time (NULL means no expiration).").
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}),
-		// auto_pause_on_expired: 过期后自动暂停调度
-		field.Bool("auto_pause_on_expired").
-			Default(true).
-			Comment("Auto pause scheduling when account expires."),
 
 		// ========== 调度和速率限制相关字段 ==========
 		// 这些字段在 migrations/005_schema_parity.sql 中添加
@@ -166,19 +143,6 @@ func (Account) Fields() []ent.Field {
 			Nillable().
 			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}),
 
-		// temp_unschedulable_until: 临时不可调度状态解除时间
-		// 当命中临时不可调度规则时设置，在此时间前调度器应跳过该账号
-		field.Time("temp_unschedulable_until").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}),
-
-		// temp_unschedulable_reason: 临时不可调度原因，便于排障审计
-		field.String("temp_unschedulable_reason").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "text"}),
-
 		// session_window_*: 会话窗口相关字段
 		// 用于管理某些需要会话时间窗口的 API（如 Claude Pro）
 		field.Time("session_window_start").
@@ -228,9 +192,6 @@ func (Account) Indexes() []ent.Index {
 		index.Fields("rate_limited_at"),     // 筛选速率限制账户
 		index.Fields("rate_limit_reset_at"), // 筛选速率限制解除时间
 		index.Fields("overload_until"),      // 筛选过载账户
-		// 调度热路径复合索引（线上由 SQL 迁移创建部分索引，schema 仅用于模型可读性对齐）
-		index.Fields("platform", "priority"),
-		index.Fields("priority", "status"),
-		index.Fields("deleted_at"), // 软删除查询优化
+		index.Fields("deleted_at"),          // 软删除查询优化
 	}
 }

backend/ent/schema/announcement.go

@@ -1,94 +0,0 @@
-package schema
-
-import (
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/domain"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/entsql"
-	"entgo.io/ent/schema"
-	"entgo.io/ent/schema/edge"
-	"entgo.io/ent/schema/field"
-	"entgo.io/ent/schema/index"
-)
-
-// Announcement holds the schema definition for the Announcement entity.
-//
-// 删除策略：硬删除（已读记录通过外键级联删除）
-type Announcement struct {
-	ent.Schema
-}
-
-func (Announcement) Annotations() []schema.Annotation {
-	return []schema.Annotation{
-		entsql.Annotation{Table: "announcements"},
-	}
-}
-
-func (Announcement) Fields() []ent.Field {
-	return []ent.Field{
-		field.String("title").
-			MaxLen(200).
-			NotEmpty().
-			Comment("公告标题"),
-		field.String("content").
-			SchemaType(map[string]string{dialect.Postgres: "text"}).
-			NotEmpty().
-			Comment("公告内容（支持 Markdown）"),
-		field.String("status").
-			MaxLen(20).
-			Default(domain.AnnouncementStatusDraft).
-			Comment("状态: draft, active, archived"),
-		field.String("notify_mode").
-			MaxLen(20).
-			Default(domain.AnnouncementNotifyModeSilent).
-			Comment("通知模式: silent(仅铃铛), popup(弹窗提醒)"),
-		field.JSON("targeting", domain.AnnouncementTargeting{}).
-			Optional().
-			SchemaType(map[string]string{dialect.Postgres: "jsonb"}).
-			Comment("展示条件（JSON 规则）"),
-		field.Time("starts_at").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}).
-			Comment("开始展示时间（为空表示立即生效）"),
-		field.Time("ends_at").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}).
-			Comment("结束展示时间（为空表示永久生效）"),
-		field.Int64("created_by").
-			Optional().
-			Nillable().
-			Comment("创建人用户ID（管理员）"),
-		field.Int64("updated_by").
-			Optional().
-			Nillable().
-			Comment("更新人用户ID（管理员）"),
-		field.Time("created_at").
-			Immutable().
-			Default(time.Now).
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}),
-		field.Time("updated_at").
-			Default(time.Now).
-			UpdateDefault(time.Now).
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}),
-	}
-}
-
-func (Announcement) Edges() []ent.Edge {
-	return []ent.Edge{
-		edge.To("reads", AnnouncementRead.Type),
-	}
-}
-
-func (Announcement) Indexes() []ent.Index {
-	return []ent.Index{
-		index.Fields("status"),
-		index.Fields("created_at"),
-		index.Fields("starts_at"),
-		index.Fields("ends_at"),
-	}
-}

backend/ent/schema/announcement_read.go

@@ -1,65 +0,0 @@
-package schema
-
-import (
-	"time"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/entsql"
-	"entgo.io/ent/schema"
-	"entgo.io/ent/schema/edge"
-	"entgo.io/ent/schema/field"
-	"entgo.io/ent/schema/index"
-)
-
-// AnnouncementRead holds the schema definition for the AnnouncementRead entity.
-//
-// 记录用户对公告的已读状态（首次已读时间）。
-type AnnouncementRead struct {
-	ent.Schema
-}
-
-func (AnnouncementRead) Annotations() []schema.Annotation {
-	return []schema.Annotation{
-		entsql.Annotation{Table: "announcement_reads"},
-	}
-}
-
-func (AnnouncementRead) Fields() []ent.Field {
-	return []ent.Field{
-		field.Int64("announcement_id"),
-		field.Int64("user_id"),
-		field.Time("read_at").
-			Default(time.Now).
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}).
-			Comment("用户首次已读时间"),
-		field.Time("created_at").
-			Immutable().
-			Default(time.Now).
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}),
-	}
-}
-
-func (AnnouncementRead) Edges() []ent.Edge {
-	return []ent.Edge{
-		edge.From("announcement", Announcement.Type).
-			Ref("reads").
-			Field("announcement_id").
-			Unique().
-			Required(),
-		edge.From("user", User.Type).
-			Ref("announcement_reads").
-			Field("user_id").
-			Unique().
-			Required(),
-	}
-}
-
-func (AnnouncementRead) Indexes() []ent.Index {
-	return []ent.Index{
-		index.Fields("announcement_id"),
-		index.Fields("user_id"),
-		index.Fields("read_at"),
-		index.Fields("announcement_id", "user_id").Unique(),
-	}
-}

backend/ent/schema/api_key.go

@@ -2,10 +2,9 @@ package schema
 
 import (
 	"github.com/Wei-Shaw/sub2api/ent/schema/mixins"
-	"github.com/Wei-Shaw/sub2api/internal/domain"
+	"github.com/Wei-Shaw/sub2api/internal/service"
 
 	"entgo.io/ent"
-	"entgo.io/ent/dialect"
 	"entgo.io/ent/dialect/entsql"
 	"entgo.io/ent/schema"
 	"entgo.io/ent/schema/edge"
@@ -13,25 +12,25 @@ import (
 	"entgo.io/ent/schema/index"
 )
 
-// APIKey holds the schema definition for the APIKey entity.
-type APIKey struct {
+// ApiKey holds the schema definition for the ApiKey entity.
+type ApiKey struct {
 	ent.Schema
 }
 
-func (APIKey) Annotations() []schema.Annotation {
+func (ApiKey) Annotations() []schema.Annotation {
 	return []schema.Annotation{
 		entsql.Annotation{Table: "api_keys"},
 	}
 }
 
-func (APIKey) Mixin() []ent.Mixin {
+func (ApiKey) Mixin() []ent.Mixin {
 	return []ent.Mixin{
 		mixins.TimeMixin{},
 		mixins.SoftDeleteMixin{},
 	}
 }
 
-func (APIKey) Fields() []ent.Field {
+func (ApiKey) Fields() []ent.Field {
 	return []ent.Field{
 		field.Int64("user_id"),
 		field.String("key").
@@ -46,79 +45,11 @@ func (APIKey) Fields() []ent.Field {
 			Nillable(),
 		field.String("status").
 			MaxLen(20).
-			Default(domain.StatusActive),
-		field.Time("last_used_at").
-			Optional().
-			Nillable().
-			Comment("Last usage time of this API key"),
-		field.JSON("ip_whitelist", []string{}).
-			Optional().
-			Comment("Allowed IPs/CIDRs, e.g. [\"192.168.1.100\", \"10.0.0.0/8\"]"),
-		field.JSON("ip_blacklist", []string{}).
-			Optional().
-			Comment("Blocked IPs/CIDRs"),
-
-		// ========== Quota fields ==========
-		// Quota limit in USD (0 = unlimited)
-		field.Float("quota").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Quota limit in USD for this API key (0 = unlimited)"),
-		// Used quota amount
-		field.Float("quota_used").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Used quota amount in USD"),
-		// Expiration time (nil = never expires)
-		field.Time("expires_at").
-			Optional().
-			Nillable().
-			Comment("Expiration time for this API key (null = never expires)"),
-
-		// ========== Rate limit fields ==========
-		// Rate limit configuration (0 = unlimited)
-		field.Float("rate_limit_5h").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Rate limit in USD per 5 hours (0 = unlimited)"),
-		field.Float("rate_limit_1d").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Rate limit in USD per day (0 = unlimited)"),
-		field.Float("rate_limit_7d").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Rate limit in USD per 7 days (0 = unlimited)"),
-		// Rate limit usage tracking
-		field.Float("usage_5h").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Used amount in USD for the current 5h window"),
-		field.Float("usage_1d").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Used amount in USD for the current 1d window"),
-		field.Float("usage_7d").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("Used amount in USD for the current 7d window"),
-		// Window start times
-		field.Time("window_5h_start").
-			Optional().
-			Nillable().
-			Comment("Start time of the current 5h rate limit window"),
-		field.Time("window_1d_start").
-			Optional().
-			Nillable().
-			Comment("Start time of the current 1d rate limit window"),
-		field.Time("window_7d_start").
-			Optional().
-			Nillable().
-			Comment("Start time of the current 7d rate limit window"),
+			Default(service.StatusActive),
 	}
 }
 
-func (APIKey) Edges() []ent.Edge {
+func (ApiKey) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.From("user", User.Type).
 			Ref("api_keys").
@@ -133,16 +64,12 @@ func (APIKey) Edges() []ent.Edge {
 	}
 }
 
-func (APIKey) Indexes() []ent.Index {
+func (ApiKey) Indexes() []ent.Index {
 	return []ent.Index{
 		// key 字段已在 Fields() 中声明 Unique()，无需重复索引
 		index.Fields("user_id"),
 		index.Fields("group_id"),
 		index.Fields("status"),
 		index.Fields("deleted_at"),
-		index.Fields("last_used_at"),
-		// Index for quota queries
-		index.Fields("quota", "quota_used"),
-		index.Fields("expires_at"),
 	}
 }