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

This reverts commit 8d252303fc.

.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

@@ -15,11 +15,8 @@ jobs:
       - 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.25.5'
       - name: Unit tests
         working-directory: backend
         run: make test-unit
@@ -34,11 +31,8 @@ jobs:
       - 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.25.5'
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v9
         with:

.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
@@ -35,12 +19,7 @@ jobs:
 
       - 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"
 
@@ -57,24 +36,19 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
       - name: Setup Node.js
         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
@@ -92,7 +66,6 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          ref: ${{ github.event.inputs.tag || github.ref }}
 
       - name: Download VERSION artifact
         uses: actions/download-artifact@v4
@@ -109,14 +82,9 @@ jobs:
       - name: Setup Go
         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.25.5'
-
       # 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（跳过第一行标题）
@@ -176,21 +137,18 @@ jobs:
         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@v4
-        env:
-          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
         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,13 +169,10 @@ 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 内容
@@ -241,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,62 +0,0 @@
-name: Security Scan
-
-on:
-  push:
-  pull_request:
-  schedule:
-    - cron: '0 3 * * 1'
-
-permissions:
-  contents: read
-
-jobs:
-  backend-security:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        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.25.5'
-      - name: Run govulncheck
-        working-directory: backend
-        run: |
-          go install golang.org/x/vuln/cmd/govulncheck@latest
-          govulncheck ./...
-      - name: Run gosec
-        working-directory: backend
-        run: |
-          go install github.com/securego/gosec/v2/cmd/gosec@latest
-          gosec -severity high -confidence high ./...
-
-  frontend-security:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        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/
 
 # ===================
 # 构建产物
@@ -125,8 +117,3 @@ docs/
 code-reviews/
 AGENTS.md
 backend/cmd/server/server
-deploy/docker-compose.override.yml
-.gocache/
-vite.config.js
-docs/*
-.serena/

.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 }}
     ```

Dockerfile

@@ -7,8 +7,8 @@
 # =============================================================================
 
 ARG NODE_IMAGE=node:24-alpine
-ARG GOLANG_IMAGE=golang:1.25.5-alpine
-ARG ALPINE_IMAGE=alpine:3.20
+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

Linux DO Connect.md

@@ -1,368 +0,0 @@
-# Linux DO Connect
-
-OAuth（Open Authorization）是一个开放的网络授权标准，目前最新版本为 OAuth 2.0。我们日常使用的第三方登录（如 Google 账号登录）就采用了该标准。OAuth 允许用户授权第三方应用访问存储在其他服务提供商（如 Google）上的信息，无需在不同平台上重复填写注册信息。用户授权后，平台可以直接访问用户的账户信息进行身份验证，而用户无需向第三方应用提供密码。
-
-目前系统已实现完整的 OAuth2 授权码（code）方式鉴权，但界面等配套功能还在持续完善中。让我们一起打造一个更完善的共享方案。
-
-## 基本介绍
-
-这是一套标准的 OAuth2 鉴权系统，可以让开发者共享论坛的用户基本信息。
-
-- 可获取字段：
-
-| 参数              | 说明                            |
-| ----------------- | ------------------------------- |
-| `id`              | 用户唯一标识（不可变）          |
-| `username`        | 论坛用户名                      |
-| `name`            | 论坛用户昵称（可变）            |
-| `avatar_template` | 用户头像模板URL（支持多种尺寸） |
-| `active`          | 账号活跃状态                    |
-| `trust_level`     | 信任等级（0-4）                 |
-| `silenced`        | 禁言状态                        |
-| `external_ids`    | 外部ID关联信息                  |
-| `api_key`         | API访问密钥                     |
-
-通过这些信息，公益网站/接口可以实现：
-
-1. 基于 `id` 的服务频率限制
-2. 基于 `trust_level` 的服务额度分配
-3. 基于用户信息的滥用举报机制
-
-## 相关端点
-
-- Authorize 端点： `https://connect.linux.do/oauth2/authorize`
-- Token 端点：`https://connect.linux.do/oauth2/token`
-- 用户信息 端点：`https://connect.linux.do/api/user`
-
-## 申请使用
-
-- 访问 [Connect.Linux.Do](https://connect.linux.do/) 申请接入你的应用。
-
-![linuxdoconnect_1](https://wiki.linux.do/_next/image?url=%2Flinuxdoconnect_1.png&w=1080&q=75)
-
-- 点击 **`我的应用接入`** - **`申请新接入`**，填写相关信息。其中 **`回调地址`** 是你的应用接收用户信息的地址。
-
-![linuxdoconnect_2](https://wiki.linux.do/_next/image?url=%2Flinuxdoconnect_2.png&w=1080&q=75)
-
-- 申请成功后，你将获得 **`Client Id`** 和 **`Client Secret`**，这是你应用的唯一身份凭证。
-
-![linuxdoconnect_3](https://wiki.linux.do/_next/image?url=%2Flinuxdoconnect_3.png&w=1080&q=75)
-
-## 接入 Linux Do
-
-JavaScript
-```JavaScript
-// 安装第三方请求库（或使用原生的 Fetch API），本例中使用 axios
-// npm install axios
-
-// 通过 OAuth2 获取 Linux Do 用户信息的参考流程
-const axios = require('axios');
-const readline = require('readline');
-
-// 配置信息（建议通过环境变量配置，避免使用硬编码）
-const CLIENT_ID = '你的 Client ID';
-const CLIENT_SECRET = '你的 Client Secret';
-const REDIRECT_URI = '你的回调地址';
-const AUTH_URL = 'https://connect.linux.do/oauth2/authorize';
-const TOKEN_URL = 'https://connect.linux.do/oauth2/token';
-const USER_INFO_URL = 'https://connect.linux.do/api/user';
-
-// 第一步：生成授权 URL
-function getAuthUrl() {
-  const params = new URLSearchParams({
-    client_id: CLIENT_ID,
-    redirect_uri: REDIRECT_URI,
-    response_type: 'code',
-    scope: 'user'
-  });
-
-  return `${AUTH_URL}?${params.toString()}`;
-}
-
-// 第二步：获取 code 参数
-function getCode() {
-  return new Promise((resolve) => {
-    // 本例中使用终端输入来模拟流程，仅供本地测试
-    // 请在实际应用中替换为真实的处理逻辑
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question('从回调 URL 中提取出 code，粘贴到此处并按回车：', (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-// 第三步：使用 code 参数获取访问令牌
-async function getAccessToken(code) {
-  try {
-    const form = new URLSearchParams({
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-      code: code,
-      redirect_uri: REDIRECT_URI,
-      grant_type: 'authorization_code'
-    }).toString();
-
-    const response = await axios.post(TOKEN_URL, form, {
-      // 提醒：需正确配置请求头，否则无法正常获取访问令牌
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        'Accept': 'application/json'
-      }
-    });
-
-    return response.data;
-  } catch (error) {
-    console.error(`获取访问令牌失败：${error.response ? JSON.stringify(error.response.data) : error.message}`);
-    throw error;
-  }
-}
-
-// 第四步：使用访问令牌获取用户信息
-async function getUserInfo(accessToken) {
-  try {
-    const response = await axios.get(USER_INFO_URL, {
-      headers: {
-        Authorization: `Bearer ${accessToken}`
-      }
-    });
-
-    return response.data;
-  } catch (error) {
-    console.error(`获取用户信息失败：${error.response ? JSON.stringify(error.response.data) : error.message}`);
-    throw error;
-  }
-}
-
-// 主流程
-async function main() {
-  // 1. 生成授权 URL，前端引导用户访问授权页
-  const authUrl = getAuthUrl();
-  console.log(`请访问此 URL 授权：${authUrl}
-`);
-
-  // 2. 用户授权后，从回调 URL 获取 code 参数
-  const code = await getCode();
-
-  try {
-    // 3. 使用 code 参数获取访问令牌
-    const tokenData = await getAccessToken(code);
-    const accessToken = tokenData.access_token;
-
-    // 4. 使用访问令牌获取用户信息
-    if (accessToken) {
-      const userInfo = await getUserInfo(accessToken);
-      console.log(`
-获取用户信息成功：${JSON.stringify(userInfo, null, 2)}`);
-    } else {
-      console.log(`
-获取访问令牌失败：${JSON.stringify(tokenData)}`);
-    }
-  } catch (error) {
-    console.error('发生错误：', error);
-  }
-}
-```
-Python
-```python
-# 安装第三方请求库，本例中使用 requests
-# pip install requests
-
-# 通过 OAuth2 获取 Linux Do 用户信息的参考流程
-import requests
-import json
-
-# 配置信息（建议通过环境变量配置，避免使用硬编码）
-CLIENT_ID = '你的 Client ID'
-CLIENT_SECRET = '你的 Client Secret'
-REDIRECT_URI = '你的回调地址'
-AUTH_URL = 'https://connect.linux.do/oauth2/authorize'
-TOKEN_URL = 'https://connect.linux.do/oauth2/token'
-USER_INFO_URL = 'https://connect.linux.do/api/user'
-
-# 第一步：生成授权 URL
-def get_auth_url():
-    params = {
-        'client_id': CLIENT_ID,
-        'redirect_uri': REDIRECT_URI,
-        'response_type': 'code',
-        'scope': 'user'
-    }
-    auth_url = f"{AUTH_URL}?{'&'.join(f'{k}={v}' for k, v in params.items())}"
-    return auth_url
-
-# 第二步：获取 code 参数
-def get_code():
-    # 本例中使用终端输入来模拟流程，仅供本地测试
-    # 请在实际应用中替换为真实的处理逻辑
-    return input('从回调 URL 中提取出 code，粘贴到此处并按回车：').strip()
-
-# 第三步：使用 code 参数获取访问令牌
-def get_access_token(code):
-    try:
-        data = {
-            'client_id': CLIENT_ID,
-            'client_secret': CLIENT_SECRET,
-            'code': code,
-            'redirect_uri': REDIRECT_URI,
-            'grant_type': 'authorization_code'
-        }
-        # 提醒：需正确配置请求头，否则无法正常获取访问令牌
-        headers = {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'Accept': 'application/json'
-        }
-        response = requests.post(TOKEN_URL, data=data, headers=headers)
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        print(f"获取访问令牌失败：{e}")
-        return None
-
-# 第四步：使用访问令牌获取用户信息
-def get_user_info(access_token):
-    try:
-        headers = {
-            'Authorization': f'Bearer {access_token}'
-        }
-        response = requests.get(USER_INFO_URL, headers=headers)
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        print(f"获取用户信息失败：{e}")
-        return None
-
-# 主流程
-if __name__ == '__main__':
-    # 1. 生成授权 URL，前端引导用户访问授权页
-    auth_url = get_auth_url()
-    print(f'请访问此 URL 授权：{auth_url}
-')
-
-    # 2. 用户授权后，从回调 URL 获取 code 参数
-    code = get_code()
-
-    # 3. 使用 code 参数获取访问令牌
-    token_data = get_access_token(code)
-    if token_data:
-        access_token = token_data.get('access_token')
-
-        # 4. 使用访问令牌获取用户信息
-        if access_token:
-            user_info = get_user_info(access_token)
-            if user_info:
-                print(f"
-获取用户信息成功：{json.dumps(user_info, indent=2)}")
-            else:
-                print("
-获取用户信息失败")
-        else:
-            print(f"
-获取访问令牌失败：{json.dumps(token_data, indent=2)}")
-    else:
-        print("
-获取访问令牌失败")
-```
-PHP
-```php
-// 通过 OAuth2 获取 Linux Do 用户信息的参考流程
-
-// 配置信息
-$CLIENT_ID = '你的 Client ID';
-$CLIENT_SECRET = '你的 Client Secret';
-$REDIRECT_URI = '你的回调地址';
-$AUTH_URL = 'https://connect.linux.do/oauth2/authorize';
-$TOKEN_URL = 'https://connect.linux.do/oauth2/token';
-$USER_INFO_URL = 'https://connect.linux.do/api/user';
-
-// 生成授权 URL
-function getAuthUrl($clientId, $redirectUri) {
-    global $AUTH_URL;
-    return $AUTH_URL . '?' . http_build_query([
-        'client_id' => $clientId,
-        'redirect_uri' => $redirectUri,
-        'response_type' => 'code',
-        'scope' => 'user'
-    ]);
-}
-
-// 使用 code 参数获取用户信息（合并获取令牌和获取用户信息的步骤）
-function getUserInfoWithCode($code, $clientId, $clientSecret, $redirectUri) {
-    global $TOKEN_URL, $USER_INFO_URL;
-
-    // 1. 获取访问令牌
-    $ch = curl_init($TOKEN_URL);
-    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
-    curl_setopt($ch, CURLOPT_POST, true);
-    curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query([
-        'client_id' => $clientId,
-        'client_secret' => $clientSecret,
-        'code' => $code,
-        'redirect_uri' => $redirectUri,
-        'grant_type' => 'authorization_code'
-    ]));
-    curl_setopt($ch, CURLOPT_HTTPHEADER, [
-        'Content-Type: application/x-www-form-urlencoded',
-        'Accept: application/json'
-    ]);
-
-    $tokenResponse = curl_exec($ch);
-    curl_close($ch);
-
-    $tokenData = json_decode($tokenResponse, true);
-    if (!isset($tokenData['access_token'])) {
-        return ['error' => '获取访问令牌失败', 'details' => $tokenData];
-    }
-
-    // 2. 获取用户信息
-    $ch = curl_init($USER_INFO_URL);
-    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
-    curl_setopt($ch, CURLOPT_HTTPHEADER, [
-        'Authorization: Bearer ' . $tokenData['access_token']
-    ]);
-
-    $userResponse = curl_exec($ch);
-    curl_close($ch);
-
-    return json_decode($userResponse, true);
-}
-
-// 主流程
-// 1. 生成授权 URL
-$authUrl = getAuthUrl($CLIENT_ID, $REDIRECT_URI);
-echo "<a href='$authUrl'>使用 Linux Do 登录</a>";
-
-// 2. 处理回调并获取用户信息
-if (isset($_GET['code'])) {
-    $userInfo = getUserInfoWithCode(
-        $_GET['code'],
-        $CLIENT_ID,
-        $CLIENT_SECRET,
-        $REDIRECT_URI
-    );
-
-    if (isset($userInfo['error'])) {
-        echo '错误: ' . $userInfo['error'];
-    } else {
-        echo '欢迎, ' . $userInfo['name'] . '!';
-        // 处理用户登录逻辑...
-    }
-}
-```
-
-## 使用说明
-
-### 授权流程
-
-1. 用户点击应用中的’使用 Linux Do 登录’按钮
-2. 系统将用户重定向至 Linux Do 的授权页面
-3. 用户完成授权后，系统自动重定向回应用并携带授权码
-4. 应用使用授权码获取访问令牌
-5. 使用访问令牌获取用户信息
-
-### 安全建议
-
-- 切勿在前端代码中暴露 Client Secret
-- 对所有用户输入数据进行严格验证
-- 确保使用 HTTPS 协议传输数据
-- 定期更新并妥善保管 Client Secret

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build build-backend build-frontend test test-backend test-frontend
+.PHONY: build build-backend build-frontend
 
 # 一键编译前后端
 build: build-backend build-frontend
@@ -9,14 +9,4 @@ build-backend:
 
 # 编译前端（需要已安装依赖）
 build-frontend:
-	@pnpm --dir frontend run build
-
-# 运行测试（后端 + 前端）
-test: test-backend test-frontend
-
-test-backend:
-	@$(MAKE) -C backend test
-
-test-frontend:
-	@pnpm --dir frontend run lint:check
-	@pnpm --dir frontend run typecheck
+	@npm --prefix frontend run build

PR_DESCRIPTION.md

@@ -1,164 +0,0 @@
-## 概述
-
-全面增强运维监控系统（Ops）的错误日志管理和告警静默功能，优化前端 UI 组件代码质量和用户体验。本次更新重构了核心服务层和数据访问层，提升系统可维护性和运维效率。
-
-## 主要改动
-
-### 1. 错误日志查询优化
-
-**功能特性：**
-- 新增 GetErrorLogByID 接口，支持按 ID 精确查询错误详情
-- 优化错误日志过滤逻辑，支持多维度筛选（平台、阶段、来源、所有者等）
-- 改进查询参数处理，简化代码结构
-- 增强错误分类和标准化处理
-- 支持错误解决状态追踪（resolved 字段）
-
-**技术实现：**
-- `ops_handler.go` - 新增单条错误日志查询接口
-- `ops_repo.go` - 优化数据查询和过滤条件构建
-- `ops_models.go` - 扩展错误日志数据模型
-- 前端 API 接口同步更新
-
-### 2. 告警静默功能
-
-**功能特性：**
-- 支持按规则、平台、分组、区域等维度静默告警
-- 可设置静默时长和原因说明
-- 静默记录可追溯，记录创建人和创建时间
-- 自动过期机制，避免永久静默
-
-**技术实现：**
-- `037_ops_alert_silences.sql` - 新增告警静默表
-- `ops_alerts.go` - 告警静默逻辑实现
-- `ops_alerts_handler.go` - 告警静默 API 接口
-- `OpsAlertEventsCard.vue` - 前端告警静默操作界面
-
-**数据库结构：**
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| rule_id | BIGINT | 告警规则 ID |
-| platform | VARCHAR(64) | 平台标识 |
-| group_id | BIGINT | 分组 ID（可选） |
-| region | VARCHAR(64) | 区域（可选） |
-| until | TIMESTAMPTZ | 静默截止时间 |
-| reason | TEXT | 静默原因 |
-| created_by | BIGINT | 创建人 ID |
-
-### 3. 错误分类标准化
-
-**功能特性：**
-- 统一错误阶段分类（request|auth|routing|upstream|network|internal）
-- 规范错误归属分类（client|provider|platform）
-- 标准化错误来源分类（client_request|upstream_http|gateway）
-- 自动迁移历史数据到新分类体系
-
-**技术实现：**
-- `038_ops_errors_resolution_retry_results_and_standardize_classification.sql` - 分类标准化迁移
-- 自动映射历史遗留分类到新标准
-- 自动解决已恢复的上游错误（客户端状态码 < 400）
-
-### 4. Gateway 服务集成
-
-**功能特性：**
-- 完善各 Gateway 服务的 Ops 集成
-- 统一错误日志记录接口
-- 增强上游错误追踪能力
-
-**涉及服务：**
-- `antigravity_gateway_service.go` - Antigravity 网关集成
-- `gateway_service.go` - 通用网关集成
-- `gemini_messages_compat_service.go` - Gemini 兼容层集成
-- `openai_gateway_service.go` - OpenAI 网关集成
-
-### 5. 前端 UI 优化
-
-**代码重构：**
-- 大幅简化错误详情模态框代码（从 828 行优化到 450 行）
-- 优化错误日志表格组件，提升可读性
-- 清理未使用的 i18n 翻译，减少冗余
-- 统一组件代码风格和格式
-- 优化骨架屏组件，更好匹配实际看板布局
-
-**布局改进：**
-- 修复模态框内容溢出和滚动问题
-- 优化表格布局，使用 flex 布局确保正确显示
-- 改进看板头部布局和交互
-- 提升响应式体验
-- 骨架屏支持全屏模式适配
-
-**交互优化：**
-- 优化告警事件卡片功能和展示
-- 改进错误详情展示逻辑
-- 增强请求详情模态框
-- 完善运行时设置卡片
-- 改进加载动画效果
-
-### 6. 国际化完善
-
-**文案补充：**
-- 补充错误日志相关的英文翻译
-- 添加告警静默功能的中英文文案
-- 完善提示文本和错误信息
-- 统一术语翻译标准
-
-## 文件变更
-
-**后端（26 个文件）：**
-- `backend/internal/handler/admin/ops_alerts_handler.go` - 告警接口增强
-- `backend/internal/handler/admin/ops_handler.go` - 错误日志接口优化
-- `backend/internal/handler/ops_error_logger.go` - 错误记录器增强
-- `backend/internal/repository/ops_repo.go` - 数据访问层重构
-- `backend/internal/repository/ops_repo_alerts.go` - 告警数据访问增强
-- `backend/internal/service/ops_*.go` - 核心服务层重构（10 个文件）
-- `backend/internal/service/*_gateway_service.go` - Gateway 集成（4 个文件）
-- `backend/internal/server/routes/admin.go` - 路由配置更新
-- `backend/migrations/*.sql` - 数据库迁移（2 个文件）
-- 测试文件更新（5 个文件）
-
-**前端（13 个文件）：**
-- `frontend/src/views/admin/ops/OpsDashboard.vue` - 看板主页优化
-- `frontend/src/views/admin/ops/components/*.vue` - 组件重构（10 个文件）
-- `frontend/src/api/admin/ops.ts` - API 接口扩展
-- `frontend/src/i18n/locales/*.ts` - 国际化文本（2 个文件）
-
-## 代码统计
-
-- 44 个文件修改
-- 3733 行新增
-- 995 行删除
-- 净增加 2738 行
-
-## 核心改进
-
-**可维护性提升：**
-- 重构核心服务层，职责更清晰
-- 简化前端组件代码，降低复杂度
-- 统一代码风格和命名规范
-- 清理冗余代码和未使用的翻译
-- 标准化错误分类体系
-
-**功能完善：**
-- 告警静默功能，减少告警噪音
-- 错误日志查询优化，提升运维效率
-- Gateway 服务集成完善，统一监控能力
-- 错误解决状态追踪，便于问题管理
-
-**用户体验优化：**
-- 修复多个 UI 布局问题
-- 优化交互流程
-- 完善国际化支持
-- 提升响应式体验
-- 改进加载状态展示
-
-## 测试验证
-
-- ✅ 错误日志查询和过滤功能
-- ✅ 告警静默创建和自动过期
-- ✅ 错误分类标准化迁移
-- ✅ Gateway 服务错误日志记录
-- ✅ 前端组件布局和交互
-- ✅ 骨架屏全屏模式适配
-- ✅ 国际化文本完整性
-- ✅ API 接口功能正确性
-- ✅ 数据库迁移执行成功

README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Go](https://img.shields.io/badge/Go-1.25.5-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,19 +44,13 @@ Sub2API is an AI API gateway platform designed to distribute and manage API quot
 
 | Component | Technology |
 |-----------|------------|
-| Backend | Go 1.25.5, 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`
-
----
-
 ## Deployment
 
 ### Method 1: Script Installation (Recommended)
@@ -166,22 +160,6 @@ ADMIN_PASSWORD=your_admin_password
 
 # Optional: Custom port
 SERVER_PORT=8080
-
-# Optional: Security configuration
-# Enable URL allowlist validation (false to skip allowlist checks, only basic format validation)
-SECURITY_URL_ALLOWLIST_ENABLED=false
-
-# Allow insecure HTTP URLs when allowlist is disabled (default: false, requires https)
-# ⚠️ WARNING: Enabling this allows HTTP (plaintext) URLs which can expose API keys
-#             Only recommended for:
-#             - Development/testing environments
-#             - Internal networks with trusted endpoints
-#             - When using local test servers (http://localhost)
-# PRODUCTION: Keep this false or use HTTPS URLs only
-SECURITY_URL_ALLOWLIST_ALLOW_INSECURE_HTTP=false
-
-# Allow private IP addresses for upstream/pricing/CRS (for internal deployments)
-SECURITY_URL_ALLOWLIST_ALLOW_PRIVATE_HOSTS=false
 ```
 
 ```bash
@@ -240,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
 ```
 
@@ -293,59 +268,6 @@ default:
   rate_multiplier: 1.0
 ```
 
-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
@@ -360,7 +282,7 @@ go run ./cmd/server
 
 # Frontend (with hot reload)
 cd frontend
-pnpm run dev
+npm run dev
 ```
 
 #### Code Generation
@@ -375,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.
@@ -409,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

README_CN.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Go](https://img.shields.io/badge/Go-1.25.5-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,26 +44,13 @@ Sub2API 是一个 AI API 网关平台，用于分发和管理 AI 产品订阅（
 
 | 组件 | 技术 |
 |------|------|
-| 后端 | Go 1.25.5, 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” 错误。
-
----
-
 ## 部署方式
 
 ### 方式一：脚本安装（推荐）
@@ -173,22 +160,6 @@ ADMIN_PASSWORD=your_admin_password
 
 # 可选：自定义端口
 SERVER_PORT=8080
-
-# 可选：安全配置
-# 启用 URL 白名单验证（false 则跳过白名单检查，仅做基本格式校验）
-SECURITY_URL_ALLOWLIST_ENABLED=false
-
-# 关闭白名单时，是否允许 http:// URL（默认 false，只允许 https://）
-# ⚠️ 警告：允许 HTTP 会暴露 API 密钥（明文传输）
-#          仅建议在以下场景使用：
-#          - 开发/测试环境
-#          - 内部可信网络
-#          - 本地测试服务器（http://localhost）
-# 生产环境：保持 false 或仅使用 HTTPS URL
-SECURITY_URL_ALLOWLIST_ALLOW_INSECURE_HTTP=false
-
-# 是否允许私有 IP 地址用于上游/定价/CRS（内网部署时使用）
-SECURITY_URL_ALLOWLIST_ALLOW_PRIVATE_HOSTS=false
 ```
 
 ```bash
@@ -247,23 +218,20 @@ docker-compose logs -f
 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
 ```
 
@@ -300,59 +268,6 @@ default:
   rate_multiplier: 1.0
 ```
 
-`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
-
-**⚠️ 安全警告：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
@@ -367,7 +282,7 @@ go run ./cmd/server
 
 # 前端（支持热重载）
 cd frontend
-pnpm run dev
+npm run dev
 ```
 
 #### 代码生成
@@ -416,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
 ---
 
 ## 项目结构

backend/.dockerignore

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

backend/.golangci.yml

@@ -18,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"
@@ -89,14 +83,7 @@ linters:
       # 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"]
-      # Temporarily disable style checks to allow CI to pass
       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
@@ -382,7 +369,15 @@ linters:
         # Ineffectual Go compiler directive.
         # https://staticcheck.dev/docs/checks/#SA9009
         - SA9009
-        # NOTE: ST1000, ST1001, ST1003, ST1020, ST1021, ST1022 are disabled above
+        # 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
@@ -416,7 +411,15 @@ linters:
         # Importing the same package multiple times.
         # https://staticcheck.dev/docs/checks/#ST1019
         - ST1019
-        # NOTE: ST1020, ST1021, ST1022 removed (disabled above)
+        # 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

backend/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.25.5-alpine
+FROM golang:1.21-alpine
 
 WORKDIR /app
 

backend/Makefile

@@ -1,12 +1,8 @@
-.PHONY: build test test-unit test-integration test-e2e
+.PHONY: build test-unit test-integration test-e2e
 
 build:
 	go build -o bin/server ./cmd/server
 
-test:
-	go test ./...
-	golangci-lint run ./...
-
 test-unit:
 	go test -tags=unit ./...
 

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.Load()
-	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(userRepo, cfg, 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.46
+0.1.1

backend/cmd/server/main.go

@@ -8,7 +8,6 @@ import (
 	"errors"
 	"flag"
 	"log"
-	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
@@ -45,25 +44,7 @@ func init() {
 	}
 }
 
-// initLogger configures the default slog handler based on gin.Mode().
-// In non-release mode, Debug level logs are enabled.
-func initLogger() {
-	var level slog.Level
-	if gin.Mode() == gin.ReleaseMode {
-		level = slog.LevelInfo
-	} else {
-		level = slog.LevelDebug
-	}
-	handler := slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
-		Level: level,
-	})
-	slog.SetDefault(slog.New(handler))
-}
-
 func main() {
-	// Initialize slog logger based on gin mode
-	initLogger()
-
 	// Parse command line flags
 	setupMode := flag.Bool("setup", false, "Run setup wizard in CLI mode")
 	showVersion := flag.Bool("version", false, "Show version information")
@@ -105,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}))
+	r.Use(middleware.CORS())
 
 	// Register setup routes
 	setup.RegisterRoutes(r)

backend/cmd/server/wire.go

@@ -62,15 +62,7 @@ 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,
-	schedulerSnapshot *service.SchedulerSnapshotService,
 	tokenRefresh *service.TokenRefreshService,
-	accountExpiry *service.AccountExpiryService,
-	usageCleanup *service.UsageCleanupService,
 	pricing *service.PricingService,
 	emailQueue *service.EmailQueueService,
 	billingCache *service.BillingCacheService,
@@ -78,6 +70,7 @@ func provideCleanup(
 	openaiOAuth *service.OpenAIOAuthService,
 	geminiOAuth *service.GeminiOAuthService,
 	antigravityOAuth *service.AntigravityOAuthService,
+	antigravityQuota *service.AntigravityQuotaRefresher,
 ) func() {
 	return func() {
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@@ -88,56 +81,10 @@ func provideCleanup(
 			name string
 			fn   func() error
 		}{
-			{"OpsScheduledReportService", func() error {
-				if opsScheduledReport != nil {
-					opsScheduledReport.Stop()
-				}
-				return nil
-			}},
-			{"OpsCleanupService", func() error {
-				if opsCleanup != nil {
-					opsCleanup.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
-			}},
 			{"TokenRefreshService", func() error {
 				tokenRefresh.Stop()
 				return nil
 			}},
-			{"AccountExpiryService", func() error {
-				accountExpiry.Stop()
-				return nil
-			}},
 			{"PricingService", func() error {
 				pricing.Stop()
 				return nil
@@ -166,6 +113,10 @@ func provideCleanup(
 				antigravityOAuth.Stop()
 				return nil
 			}},
+			{"AntigravityQuotaRefresher", func() error {
+				antigravityQuota.Stop()
+				return nil
+			}},
 			{"Redis", func() error {
 				return rdb.Close()
 			}},

backend/cmd/server/wire_gen.go

@@ -51,45 +51,33 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	turnstileVerifier := repository.NewTurnstileVerifier()
 	turnstileService := service.NewTurnstileService(settingService, turnstileVerifier)
 	emailQueueService := service.ProvideEmailQueueService(emailService)
-	promoCodeRepository := repository.NewPromoCodeRepository(client)
-	billingCache := repository.NewBillingCache(redisClient)
-	userSubscriptionRepository := repository.NewUserSubscriptionRepository(client)
-	billingCacheService := service.NewBillingCacheService(billingCache, userRepository, userSubscriptionRepository, configConfig)
-	apiKeyRepository := repository.NewAPIKeyRepository(client)
-	groupRepository := repository.NewGroupRepository(client, db)
-	apiKeyCache := repository.NewAPIKeyCache(redisClient)
-	apiKeyService := service.NewAPIKeyService(apiKeyRepository, userRepository, groupRepository, userSubscriptionRepository, apiKeyCache, configConfig)
-	apiKeyAuthCacheInvalidator := service.ProvideAPIKeyAuthCacheInvalidator(apiKeyService)
-	promoService := service.NewPromoService(promoCodeRepository, userRepository, billingCacheService, client, apiKeyAuthCacheInvalidator)
-	authService := service.NewAuthService(userRepository, configConfig, settingService, emailService, turnstileService, emailQueueService, promoService)
-	userService := service.NewUserService(userRepository, apiKeyAuthCacheInvalidator)
-	authHandler := handler.NewAuthHandler(configConfig, authService, userService, settingService, promoService)
+	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, apiKeyAuthCacheInvalidator)
+	redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client)
 	redeemHandler := handler.NewRedeemHandler(redeemService)
 	subscriptionHandler := handler.NewSubscriptionHandler(subscriptionService)
-	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)
+	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, proxyRepository, apiKeyRepository, redeemCodeRepository, billingCacheService, proxyExitInfoProber, proxyLatencyCache, apiKeyAuthCacheInvalidator)
+	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()
@@ -99,86 +87,61 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	geminiOAuthClient := repository.NewGeminiOAuthClient(configConfig)
 	geminiCliCodeAssistClient := repository.NewGeminiCliCodeAssistClient()
 	geminiOAuthService := service.NewGeminiOAuthService(proxyRepository, geminiOAuthClient, geminiCliCodeAssistClient, configConfig)
-	antigravityOAuthService := service.NewAntigravityOAuthService(proxyRepository)
-	geminiQuotaService := service.NewGeminiQuotaService(configConfig, settingRepository)
-	tempUnschedCache := repository.NewTempUnschedCache(redisClient)
-	timeoutCounterCache := repository.NewTimeoutCounterCache(redisClient)
+	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)
+	antigravityOAuthService := service.NewAntigravityOAuthService(proxyRepository)
 	antigravityTokenProvider := service.NewAntigravityTokenProvider(accountRepository, geminiTokenCache, antigravityOAuthService)
-	antigravityGatewayService := service.NewAntigravityGatewayService(accountRepository, gatewayCache, antigravityTokenProvider, rateLimitService, httpUpstream, settingService)
-	accountTestService := service.NewAccountTestService(accountRepository, geminiTokenProvider, antigravityGatewayService, httpUpstream, configConfig)
+	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.ProvideConcurrencyService(concurrencyCache, accountRepository, configConfig)
-	crsSyncService := service.NewCRSSyncService(accountRepository, proxyRepository, oAuthService, openAIOAuthService, geminiOAuthService, configConfig)
-	sessionLimitCache := repository.ProvideSessionLimitCache(redisClient, configConfig)
-	accountHandler := admin.NewAccountHandler(adminService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, rateLimitService, accountUsageService, accountTestService, concurrencyService, crsSyncService, sessionLimitCache, compositeTokenCacheInvalidator)
+	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)
-	promoHandler := admin.NewPromoHandler(promoService)
-	opsRepository := repository.NewOpsRepository(db)
-	schedulerOutboxRepository := repository.NewSchedulerOutboxRepository(db)
-	schedulerSnapshotService := service.ProvideSchedulerSnapshotService(schedulerCache, schedulerOutboxRepository, accountRepository, groupRepository, configConfig)
-	pricingRemoteClient := repository.ProvidePricingRemoteClient(configConfig)
+	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)
-	gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService, claudeTokenProvider, sessionLimitCache)
-	openAITokenProvider := service.NewOpenAITokenProvider(accountRepository, geminiTokenCache, openAIOAuthService)
-	openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService, openAITokenProvider)
-	geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, schedulerSnapshotService, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService, configConfig)
-	opsService := service.NewOpsService(opsRepository, settingRepository, configConfig, accountRepository, concurrencyService, gatewayService, openAIGatewayService, geminiMessagesCompatService, antigravityGatewayService)
-	settingHandler := admin.NewSettingHandler(settingService, emailService, turnstileService, opsService)
-	opsHandler := admin.NewOpsHandler(opsService)
-	updateCache := repository.NewUpdateCache(redisClient)
-	gitHubReleaseClient := repository.ProvideGitHubReleaseClient(configConfig)
-	serviceBuildInfo := provideServiceBuildInfo(buildInfo)
-	updateService := service.ProvideUpdateService(updateCache, gitHubReleaseClient, serviceBuildInfo)
-	systemHandler := handler.ProvideSystemHandler(updateService)
-	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)
-	adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, promoHandler, settingHandler, opsHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler, userAttributeHandler)
-	gatewayHandler := handler.NewGatewayHandler(gatewayService, geminiMessagesCompatService, antigravityGatewayService, userService, concurrencyService, billingCacheService, configConfig)
-	openAIGatewayHandler := handler.NewOpenAIGatewayHandler(openAIGatewayService, concurrencyService, billingCacheService, 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)
 	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)
-	tokenRefreshService := service.ProvideTokenRefreshService(accountRepository, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, compositeTokenCacheInvalidator, configConfig)
-	accountExpiryService := service.ProvideAccountExpiryService(accountRepository)
-	v := provideCleanup(client, redisClient, opsMetricsCollector, opsAggregationService, opsAlertEvaluatorService, opsCleanupService, opsScheduledReportService, schedulerSnapshotService, tokenRefreshService, accountExpiryService, usageCleanupService, pricingService, emailQueueService, billingCacheService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService)
+	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,
@@ -203,15 +166,7 @@ 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,
-	schedulerSnapshot *service.SchedulerSnapshotService,
 	tokenRefresh *service.TokenRefreshService,
-	accountExpiry *service.AccountExpiryService,
-	usageCleanup *service.UsageCleanupService,
 	pricing *service.PricingService,
 	emailQueue *service.EmailQueueService,
 	billingCache *service.BillingCacheService,
@@ -219,6 +174,7 @@ func provideCleanup(
 	openaiOAuth *service.OpenAIOAuthService,
 	geminiOAuth *service.GeminiOAuthService,
 	antigravityOAuth *service.AntigravityOAuthService,
+	antigravityQuota *service.AntigravityQuotaRefresher,
 ) func() {
 	return func() {
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@@ -228,56 +184,10 @@ func provideCleanup(
 			name string
 			fn   func() error
 		}{
-			{"OpsScheduledReportService", func() error {
-				if opsScheduledReport != nil {
-					opsScheduledReport.Stop()
-				}
-				return nil
-			}},
-			{"OpsCleanupService", func() error {
-				if opsCleanup != nil {
-					opsCleanup.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
-			}},
 			{"TokenRefreshService", func() error {
 				tokenRefresh.Stop()
 				return nil
 			}},
-			{"AccountExpiryService", func() error {
-				accountExpiry.Stop()
-				return nil
-			}},
 			{"PricingService", func() error {
 				pricing.Stop()
 				return nil
@@ -306,6 +216,10 @@ func provideCleanup(
 				antigravityOAuth.Stop()
 				return nil
 			}},
+			{"AntigravityQuotaRefresher", func() error {
+				antigravityQuota.Stop()
+				return nil
+			}},
 			{"Redis", func() error {
 				return rdb.Close()
 			}},

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.
@@ -43,18 +41,12 @@ type Account struct {
 	Concurrency int `json:"concurrency,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.
@@ -135,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.FieldPriority:
 			values[i] = new(sql.NullInt64)
-		case account.FieldName, account.FieldNotes, account.FieldPlatform, account.FieldType, account.FieldStatus, account.FieldErrorMessage, 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.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)
@@ -191,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,12 +228,6 @@ func (_m *Account) assignValues(columns []string, values []any) error {
 			} 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])
@@ -271,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])
@@ -402,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(", ")
@@ -430,9 +389,6 @@ func (_m *Account) String() string {
 	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(", ")
@@ -446,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(", ")

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.
@@ -39,18 +37,12 @@ const (
 	FieldConcurrency = "concurrency"
 	// 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.
@@ -110,7 +102,6 @@ var Columns = []string{
 	FieldUpdatedAt,
 	FieldDeletedAt,
 	FieldName,
-	FieldNotes,
 	FieldPlatform,
 	FieldType,
 	FieldCredentials,
@@ -118,12 +109,9 @@ var Columns = []string{
 	FieldProxyID,
 	FieldConcurrency,
 	FieldPriority,
-	FieldRateMultiplier,
 	FieldStatus,
 	FieldErrorMessage,
 	FieldLastUsedAt,
-	FieldExpiresAt,
-	FieldAutoPauseOnExpired,
 	FieldSchedulable,
 	FieldRateLimitedAt,
 	FieldRateLimitResetAt,
@@ -177,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.
@@ -219,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()
@@ -249,11 +228,6 @@ 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()
@@ -269,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()

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))
@@ -105,11 +100,6 @@ 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))
@@ -125,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))
@@ -365,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))
@@ -680,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))
@@ -910,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))

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)
@@ -153,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)
@@ -209,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)
@@ -443,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)
@@ -506,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"`)}
 	}
@@ -517,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"`)}
 	}
@@ -571,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
@@ -599,10 +525,6 @@ func (_c *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_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
@@ -615,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
@@ -798,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)
@@ -918,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)
@@ -984,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)
@@ -1228,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) {
@@ -1368,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) {
@@ -1445,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) {
@@ -1880,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) {
@@ -2020,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) {
@@ -2097,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) {

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)
@@ -193,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)
@@ -268,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)
@@ -620,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)
 	}
@@ -650,12 +569,6 @@ func (_u *AccountUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	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)
 	}
@@ -671,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)
 	}
@@ -910,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)
@@ -1032,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)
@@ -1107,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)
@@ -1489,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)
 	}
@@ -1519,12 +1342,6 @@ func (_u *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err er
 	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)
 	}
@@ -1540,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)
 	}

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/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,18 +35,14 @@ type APIKey struct {
 	GroupID *int64 `json:"group_id,omitempty"`
 	// Status holds the value of the "status" field.
 	Status string `json:"status,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"`
 	// 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.
@@ -61,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] {
@@ -72,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] {
@@ -83,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
 	}
@@ -91,12 +86,10 @@ 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.FieldID, apikey.FieldUserID, apikey.FieldGroupID:
 			values[i] = new(sql.NullInt64)
 		case apikey.FieldKey, apikey.FieldName, apikey.FieldStatus:
@@ -111,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)
 	}
@@ -174,22 +167,6 @@ func (_m *APIKey) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.Status = value.String
 			}
-		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)
-				}
-			}
 		default:
 			_m.selectValues.Set(columns[i], values[i])
 		}
@@ -197,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))
@@ -268,15 +245,9 @@ func (_m *APIKey) String() string {
 	builder.WriteString(", ")
 	builder.WriteString("status=")
 	builder.WriteString(_m.Status)
-	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.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,10 +31,6 @@ const (
 	FieldGroupID = "group_id"
 	// FieldStatus holds the string denoting the status field in the database.
 	FieldStatus = "status"
-	// 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"
 	// EdgeUser holds the string denoting the user edge name in mutations.
 	EdgeUser = "user"
 	// EdgeGroup holds the string denoting the group edge name in mutations.
@@ -77,8 +73,6 @@ var Columns = []string{
 	FieldName,
 	FieldGroupID,
 	FieldStatus,
-	FieldIPWhitelist,
-	FieldIPBlacklist,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).
@@ -115,7 +109,7 @@ var (
 	StatusValidator func(string) error
 )
 
-// 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.

backend/ent/apikey/where.go

@@ -11,488 +11,468 @@ import (
 )
 
 // ID filters vertices based on their ID field.
-func ID(id int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldID, id))
+func ID(id int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldID, id))
 }
 
 // IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldID, id))
+func IDEQ(id int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldID, id))
 }
 
 // IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldID, id))
+func IDNEQ(id int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldID, id))
 }
 
 // IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldID, ids...))
+func IDIn(ids ...int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldID, ids...))
 }
 
 // IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldID, ids...))
+func IDNotIn(ids ...int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldID, ids...))
 }
 
 // IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGT(FieldID, id))
+func IDGT(id int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGT(FieldID, id))
 }
 
 // IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGTE(FieldID, id))
+func IDGTE(id int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGTE(FieldID, id))
 }
 
 // IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLT(FieldID, id))
+func IDLT(id int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLT(FieldID, id))
 }
 
 // IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLTE(FieldID, id))
+func IDLTE(id int64) predicate.ApiKey {
+	return predicate.ApiKey(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.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldCreatedAt, v))
+func CreatedAt(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(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.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldUpdatedAt, v))
+func UpdatedAt(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ.
-func DeletedAt(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldDeletedAt, v))
+func DeletedAt(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldDeletedAt, v))
 }
 
 // UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
-func UserID(v int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldUserID, v))
+func UserID(v int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldUserID, v))
 }
 
 // Key applies equality check predicate on the "key" field. It's identical to KeyEQ.
-func Key(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldKey, v))
+func Key(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldKey, v))
 }
 
 // Name applies equality check predicate on the "name" field. It's identical to NameEQ.
-func Name(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldName, v))
+func Name(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldName, v))
 }
 
 // GroupID applies equality check predicate on the "group_id" field. It's identical to GroupIDEQ.
-func GroupID(v int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldGroupID, v))
+func GroupID(v int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldGroupID, v))
 }
 
 // Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
-func Status(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldStatus, v))
+func Status(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldStatus, v))
 }
 
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldCreatedAt, v))
+func CreatedAtEQ(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldCreatedAt, v))
+func CreatedAtNEQ(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldCreatedAt, v))
 }
 
 // CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldCreatedAt, vs...))
+func CreatedAtIn(vs ...time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldCreatedAt, vs...))
+func CreatedAtNotIn(vs ...time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldCreatedAt, vs...))
 }
 
 // CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGT(FieldCreatedAt, v))
+func CreatedAtGT(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGT(FieldCreatedAt, v))
 }
 
 // CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGTE(FieldCreatedAt, v))
+func CreatedAtGTE(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGTE(FieldCreatedAt, v))
 }
 
 // CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLT(FieldCreatedAt, v))
+func CreatedAtLT(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLT(FieldCreatedAt, v))
 }
 
 // CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLTE(FieldCreatedAt, v))
+func CreatedAtLTE(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLTE(FieldCreatedAt, v))
 }
 
 // UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldUpdatedAt, v))
+func UpdatedAtEQ(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldUpdatedAt, v))
+func UpdatedAtNEQ(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldUpdatedAt, v))
 }
 
 // UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldUpdatedAt, vs...))
+func UpdatedAtIn(vs ...time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldUpdatedAt, vs...))
+func UpdatedAtNotIn(vs ...time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldUpdatedAt, vs...))
 }
 
 // UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGT(FieldUpdatedAt, v))
+func UpdatedAtGT(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGTE(FieldUpdatedAt, v))
+func UpdatedAtGTE(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGTE(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLT(FieldUpdatedAt, v))
+func UpdatedAtLT(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLT(FieldUpdatedAt, v))
 }
 
 // UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLTE(FieldUpdatedAt, v))
+func UpdatedAtLTE(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLTE(FieldUpdatedAt, v))
 }
 
 // DeletedAtEQ applies the EQ predicate on the "deleted_at" field.
-func DeletedAtEQ(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldDeletedAt, v))
+func DeletedAtEQ(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldDeletedAt, v))
 }
 
 // DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field.
-func DeletedAtNEQ(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldDeletedAt, v))
+func DeletedAtNEQ(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldDeletedAt, v))
 }
 
 // DeletedAtIn applies the In predicate on the "deleted_at" field.
-func DeletedAtIn(vs ...time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldDeletedAt, vs...))
+func DeletedAtIn(vs ...time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldDeletedAt, vs...))
 }
 
 // DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field.
-func DeletedAtNotIn(vs ...time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldDeletedAt, vs...))
+func DeletedAtNotIn(vs ...time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldDeletedAt, vs...))
 }
 
 // DeletedAtGT applies the GT predicate on the "deleted_at" field.
-func DeletedAtGT(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGT(FieldDeletedAt, v))
+func DeletedAtGT(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGT(FieldDeletedAt, v))
 }
 
 // DeletedAtGTE applies the GTE predicate on the "deleted_at" field.
-func DeletedAtGTE(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGTE(FieldDeletedAt, v))
+func DeletedAtGTE(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGTE(FieldDeletedAt, v))
 }
 
 // DeletedAtLT applies the LT predicate on the "deleted_at" field.
-func DeletedAtLT(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLT(FieldDeletedAt, v))
+func DeletedAtLT(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLT(FieldDeletedAt, v))
 }
 
 // DeletedAtLTE applies the LTE predicate on the "deleted_at" field.
-func DeletedAtLTE(v time.Time) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLTE(FieldDeletedAt, v))
+func DeletedAtLTE(v time.Time) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLTE(FieldDeletedAt, v))
 }
 
 // DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field.
-func DeletedAtIsNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldIsNull(FieldDeletedAt))
+func DeletedAtIsNil() predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIsNull(FieldDeletedAt))
 }
 
 // DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field.
-func DeletedAtNotNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotNull(FieldDeletedAt))
+func DeletedAtNotNil() predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotNull(FieldDeletedAt))
 }
 
 // UserIDEQ applies the EQ predicate on the "user_id" field.
-func UserIDEQ(v int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldUserID, v))
+func UserIDEQ(v int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldUserID, v))
 }
 
 // UserIDNEQ applies the NEQ predicate on the "user_id" field.
-func UserIDNEQ(v int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldUserID, v))
+func UserIDNEQ(v int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldUserID, v))
 }
 
 // UserIDIn applies the In predicate on the "user_id" field.
-func UserIDIn(vs ...int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldUserID, vs...))
+func UserIDIn(vs ...int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldUserID, vs...))
 }
 
 // UserIDNotIn applies the NotIn predicate on the "user_id" field.
-func UserIDNotIn(vs ...int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldUserID, vs...))
+func UserIDNotIn(vs ...int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldUserID, vs...))
 }
 
 // KeyEQ applies the EQ predicate on the "key" field.
-func KeyEQ(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldKey, v))
+func KeyEQ(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldKey, v))
 }
 
 // KeyNEQ applies the NEQ predicate on the "key" field.
-func KeyNEQ(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldKey, v))
+func KeyNEQ(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldKey, v))
 }
 
 // KeyIn applies the In predicate on the "key" field.
-func KeyIn(vs ...string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldKey, vs...))
+func KeyIn(vs ...string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldKey, vs...))
 }
 
 // KeyNotIn applies the NotIn predicate on the "key" field.
-func KeyNotIn(vs ...string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldKey, vs...))
+func KeyNotIn(vs ...string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldKey, vs...))
 }
 
 // KeyGT applies the GT predicate on the "key" field.
-func KeyGT(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGT(FieldKey, v))
+func KeyGT(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGT(FieldKey, v))
 }
 
 // KeyGTE applies the GTE predicate on the "key" field.
-func KeyGTE(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGTE(FieldKey, v))
+func KeyGTE(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGTE(FieldKey, v))
 }
 
 // KeyLT applies the LT predicate on the "key" field.
-func KeyLT(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLT(FieldKey, v))
+func KeyLT(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLT(FieldKey, v))
 }
 
 // KeyLTE applies the LTE predicate on the "key" field.
-func KeyLTE(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLTE(FieldKey, v))
+func KeyLTE(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLTE(FieldKey, v))
 }
 
 // KeyContains applies the Contains predicate on the "key" field.
-func KeyContains(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldContains(FieldKey, v))
+func KeyContains(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldContains(FieldKey, v))
 }
 
 // KeyHasPrefix applies the HasPrefix predicate on the "key" field.
-func KeyHasPrefix(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldHasPrefix(FieldKey, v))
+func KeyHasPrefix(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldHasPrefix(FieldKey, v))
 }
 
 // KeyHasSuffix applies the HasSuffix predicate on the "key" field.
-func KeyHasSuffix(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldHasSuffix(FieldKey, v))
+func KeyHasSuffix(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldHasSuffix(FieldKey, v))
 }
 
 // KeyEqualFold applies the EqualFold predicate on the "key" field.
-func KeyEqualFold(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEqualFold(FieldKey, v))
+func KeyEqualFold(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEqualFold(FieldKey, v))
 }
 
 // KeyContainsFold applies the ContainsFold predicate on the "key" field.
-func KeyContainsFold(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldContainsFold(FieldKey, v))
+func KeyContainsFold(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldContainsFold(FieldKey, v))
 }
 
 // NameEQ applies the EQ predicate on the "name" field.
-func NameEQ(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldName, v))
+func NameEQ(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldName, v))
 }
 
 // NameNEQ applies the NEQ predicate on the "name" field.
-func NameNEQ(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldName, v))
+func NameNEQ(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldName, v))
 }
 
 // NameIn applies the In predicate on the "name" field.
-func NameIn(vs ...string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldName, vs...))
+func NameIn(vs ...string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldName, vs...))
 }
 
 // NameNotIn applies the NotIn predicate on the "name" field.
-func NameNotIn(vs ...string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldName, vs...))
+func NameNotIn(vs ...string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldName, vs...))
 }
 
 // NameGT applies the GT predicate on the "name" field.
-func NameGT(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGT(FieldName, v))
+func NameGT(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGT(FieldName, v))
 }
 
 // NameGTE applies the GTE predicate on the "name" field.
-func NameGTE(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGTE(FieldName, v))
+func NameGTE(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGTE(FieldName, v))
 }
 
 // NameLT applies the LT predicate on the "name" field.
-func NameLT(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLT(FieldName, v))
+func NameLT(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLT(FieldName, v))
 }
 
 // NameLTE applies the LTE predicate on the "name" field.
-func NameLTE(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLTE(FieldName, v))
+func NameLTE(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLTE(FieldName, v))
 }
 
 // NameContains applies the Contains predicate on the "name" field.
-func NameContains(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldContains(FieldName, v))
+func NameContains(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldContains(FieldName, v))
 }
 
 // NameHasPrefix applies the HasPrefix predicate on the "name" field.
-func NameHasPrefix(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldHasPrefix(FieldName, v))
+func NameHasPrefix(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldHasPrefix(FieldName, v))
 }
 
 // NameHasSuffix applies the HasSuffix predicate on the "name" field.
-func NameHasSuffix(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldHasSuffix(FieldName, v))
+func NameHasSuffix(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldHasSuffix(FieldName, v))
 }
 
 // NameEqualFold applies the EqualFold predicate on the "name" field.
-func NameEqualFold(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEqualFold(FieldName, v))
+func NameEqualFold(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEqualFold(FieldName, v))
 }
 
 // NameContainsFold applies the ContainsFold predicate on the "name" field.
-func NameContainsFold(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldContainsFold(FieldName, v))
+func NameContainsFold(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldContainsFold(FieldName, v))
 }
 
 // GroupIDEQ applies the EQ predicate on the "group_id" field.
-func GroupIDEQ(v int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldGroupID, v))
+func GroupIDEQ(v int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldGroupID, v))
 }
 
 // GroupIDNEQ applies the NEQ predicate on the "group_id" field.
-func GroupIDNEQ(v int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldGroupID, v))
+func GroupIDNEQ(v int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldGroupID, v))
 }
 
 // GroupIDIn applies the In predicate on the "group_id" field.
-func GroupIDIn(vs ...int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldGroupID, vs...))
+func GroupIDIn(vs ...int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldGroupID, vs...))
 }
 
 // GroupIDNotIn applies the NotIn predicate on the "group_id" field.
-func GroupIDNotIn(vs ...int64) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldGroupID, vs...))
+func GroupIDNotIn(vs ...int64) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldGroupID, vs...))
 }
 
 // GroupIDIsNil applies the IsNil predicate on the "group_id" field.
-func GroupIDIsNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldIsNull(FieldGroupID))
+func GroupIDIsNil() predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIsNull(FieldGroupID))
 }
 
 // GroupIDNotNil applies the NotNil predicate on the "group_id" field.
-func GroupIDNotNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotNull(FieldGroupID))
+func GroupIDNotNil() predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotNull(FieldGroupID))
 }
 
 // StatusEQ applies the EQ predicate on the "status" field.
-func StatusEQ(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEQ(FieldStatus, v))
+func StatusEQ(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEQ(FieldStatus, v))
 }
 
 // StatusNEQ applies the NEQ predicate on the "status" field.
-func StatusNEQ(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNEQ(FieldStatus, v))
+func StatusNEQ(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNEQ(FieldStatus, v))
 }
 
 // StatusIn applies the In predicate on the "status" field.
-func StatusIn(vs ...string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldIn(FieldStatus, vs...))
+func StatusIn(vs ...string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldIn(FieldStatus, vs...))
 }
 
 // StatusNotIn applies the NotIn predicate on the "status" field.
-func StatusNotIn(vs ...string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotIn(FieldStatus, vs...))
+func StatusNotIn(vs ...string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldNotIn(FieldStatus, vs...))
 }
 
 // StatusGT applies the GT predicate on the "status" field.
-func StatusGT(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGT(FieldStatus, v))
+func StatusGT(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGT(FieldStatus, v))
 }
 
 // StatusGTE applies the GTE predicate on the "status" field.
-func StatusGTE(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldGTE(FieldStatus, v))
+func StatusGTE(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldGTE(FieldStatus, v))
 }
 
 // StatusLT applies the LT predicate on the "status" field.
-func StatusLT(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLT(FieldStatus, v))
+func StatusLT(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLT(FieldStatus, v))
 }
 
 // StatusLTE applies the LTE predicate on the "status" field.
-func StatusLTE(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldLTE(FieldStatus, v))
+func StatusLTE(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldLTE(FieldStatus, v))
 }
 
 // StatusContains applies the Contains predicate on the "status" field.
-func StatusContains(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldContains(FieldStatus, v))
+func StatusContains(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldContains(FieldStatus, v))
 }
 
 // StatusHasPrefix applies the HasPrefix predicate on the "status" field.
-func StatusHasPrefix(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldHasPrefix(FieldStatus, v))
+func StatusHasPrefix(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldHasPrefix(FieldStatus, v))
 }
 
 // StatusHasSuffix applies the HasSuffix predicate on the "status" field.
-func StatusHasSuffix(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldHasSuffix(FieldStatus, v))
+func StatusHasSuffix(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldHasSuffix(FieldStatus, v))
 }
 
 // StatusEqualFold applies the EqualFold predicate on the "status" field.
-func StatusEqualFold(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldEqualFold(FieldStatus, v))
+func StatusEqualFold(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldEqualFold(FieldStatus, v))
 }
 
 // StatusContainsFold applies the ContainsFold predicate on the "status" field.
-func StatusContainsFold(v string) predicate.APIKey {
-	return predicate.APIKey(sql.FieldContainsFold(FieldStatus, v))
-}
-
-// IPWhitelistIsNil applies the IsNil predicate on the "ip_whitelist" field.
-func IPWhitelistIsNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldIsNull(FieldIPWhitelist))
-}
-
-// IPWhitelistNotNil applies the NotNil predicate on the "ip_whitelist" field.
-func IPWhitelistNotNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotNull(FieldIPWhitelist))
-}
-
-// IPBlacklistIsNil applies the IsNil predicate on the "ip_blacklist" field.
-func IPBlacklistIsNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldIsNull(FieldIPBlacklist))
-}
-
-// IPBlacklistNotNil applies the NotNil predicate on the "ip_blacklist" field.
-func IPBlacklistNotNil() predicate.APIKey {
-	return predicate.APIKey(sql.FieldNotNull(FieldIPBlacklist))
+func StatusContainsFold(v string) predicate.ApiKey {
+	return predicate.ApiKey(sql.FieldContainsFold(FieldStatus, v))
 }
 
 // HasUser applies the HasEdge predicate on the "user" edge.
-func HasUser() predicate.APIKey {
-	return predicate.APIKey(func(s *sql.Selector) {
+func HasUser() predicate.ApiKey {
+	return predicate.ApiKey(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
@@ -502,8 +482,8 @@ func HasUser() predicate.APIKey {
 }
 
 // HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
-func HasUserWith(preds ...predicate.User) predicate.APIKey {
-	return predicate.APIKey(func(s *sql.Selector) {
+func HasUserWith(preds ...predicate.User) predicate.ApiKey {
+	return predicate.ApiKey(func(s *sql.Selector) {
 		step := newUserStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
 			for _, p := range preds {
@@ -514,8 +494,8 @@ func HasUserWith(preds ...predicate.User) predicate.APIKey {
 }
 
 // HasGroup applies the HasEdge predicate on the "group" edge.
-func HasGroup() predicate.APIKey {
-	return predicate.APIKey(func(s *sql.Selector) {
+func HasGroup() predicate.ApiKey {
+	return predicate.ApiKey(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
 			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
@@ -525,8 +505,8 @@ func HasGroup() predicate.APIKey {
 }
 
 // HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
-func HasGroupWith(preds ...predicate.Group) predicate.APIKey {
-	return predicate.APIKey(func(s *sql.Selector) {
+func HasGroupWith(preds ...predicate.Group) predicate.ApiKey {
+	return predicate.ApiKey(func(s *sql.Selector) {
 		step := newGroupStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
 			for _, p := range preds {
@@ -537,8 +517,8 @@ func HasGroupWith(preds ...predicate.Group) predicate.APIKey {
 }
 
 // HasUsageLogs applies the HasEdge predicate on the "usage_logs" edge.
-func HasUsageLogs() predicate.APIKey {
-	return predicate.APIKey(func(s *sql.Selector) {
+func HasUsageLogs() predicate.ApiKey {
+	return predicate.ApiKey(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
 			sqlgraph.Edge(sqlgraph.O2M, false, UsageLogsTable, UsageLogsColumn),
@@ -548,8 +528,8 @@ func HasUsageLogs() predicate.APIKey {
 }
 
 // HasUsageLogsWith applies the HasEdge predicate on the "usage_logs" edge with a given conditions (other predicates).
-func HasUsageLogsWith(preds ...predicate.UsageLog) predicate.APIKey {
-	return predicate.APIKey(func(s *sql.Selector) {
+func HasUsageLogsWith(preds ...predicate.UsageLog) predicate.ApiKey {
+	return predicate.ApiKey(func(s *sql.Selector) {
 		step := newUsageLogsStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
 			for _, p := range preds {
@@ -560,16 +540,16 @@ func HasUsageLogsWith(preds ...predicate.UsageLog) predicate.APIKey {
 }
 
 // And groups predicates with the AND operator between them.
-func And(predicates ...predicate.APIKey) predicate.APIKey {
-	return predicate.APIKey(sql.AndPredicates(predicates...))
+func And(predicates ...predicate.ApiKey) predicate.ApiKey {
+	return predicate.ApiKey(sql.AndPredicates(predicates...))
 }
 
 // Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.APIKey) predicate.APIKey {
-	return predicate.APIKey(sql.OrPredicates(predicates...))
+func Or(predicates ...predicate.ApiKey) predicate.ApiKey {
+	return predicate.ApiKey(sql.OrPredicates(predicates...))
 }
 
 // Not applies the not operator on the given predicate.
-func Not(p predicate.APIKey) predicate.APIKey {
-	return predicate.APIKey(sql.NotPredicates(p))
+func Not(p predicate.ApiKey) predicate.ApiKey {
+	return predicate.ApiKey(sql.NotPredicates(p))
 }

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/apikey_update.go

@@ -10,7 +10,6 @@ import (
 
 	"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/apikey"
 	"github.com/Wei-Shaw/sub2api/ent/group"
@@ -19,33 +18,33 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/user"
 )
 
-// APIKeyUpdate is the builder for updating APIKey entities.
-type APIKeyUpdate struct {
+// ApiKeyUpdate is the builder for updating ApiKey entities.
+type ApiKeyUpdate struct {
 	config
 	hooks    []Hook
-	mutation *APIKeyMutation
+	mutation *ApiKeyMutation
 }
 
-// Where appends a list predicates to the APIKeyUpdate builder.
-func (_u *APIKeyUpdate) Where(ps ...predicate.APIKey) *APIKeyUpdate {
+// Where appends a list predicates to the ApiKeyUpdate builder.
+func (_u *ApiKeyUpdate) Where(ps ...predicate.ApiKey) *ApiKeyUpdate {
 	_u.mutation.Where(ps...)
 	return _u
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (_u *APIKeyUpdate) SetUpdatedAt(v time.Time) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetUpdatedAt(v time.Time) *ApiKeyUpdate {
 	_u.mutation.SetUpdatedAt(v)
 	return _u
 }
 
 // SetDeletedAt sets the "deleted_at" field.
-func (_u *APIKeyUpdate) SetDeletedAt(v time.Time) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetDeletedAt(v time.Time) *ApiKeyUpdate {
 	_u.mutation.SetDeletedAt(v)
 	return _u
 }
 
 // SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
-func (_u *APIKeyUpdate) SetNillableDeletedAt(v *time.Time) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetNillableDeletedAt(v *time.Time) *ApiKeyUpdate {
 	if v != nil {
 		_u.SetDeletedAt(*v)
 	}
@@ -53,19 +52,19 @@ func (_u *APIKeyUpdate) SetNillableDeletedAt(v *time.Time) *APIKeyUpdate {
 }
 
 // ClearDeletedAt clears the value of the "deleted_at" field.
-func (_u *APIKeyUpdate) ClearDeletedAt() *APIKeyUpdate {
+func (_u *ApiKeyUpdate) ClearDeletedAt() *ApiKeyUpdate {
 	_u.mutation.ClearDeletedAt()
 	return _u
 }
 
 // SetUserID sets the "user_id" field.
-func (_u *APIKeyUpdate) SetUserID(v int64) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetUserID(v int64) *ApiKeyUpdate {
 	_u.mutation.SetUserID(v)
 	return _u
 }
 
 // SetNillableUserID sets the "user_id" field if the given value is not nil.
-func (_u *APIKeyUpdate) SetNillableUserID(v *int64) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetNillableUserID(v *int64) *ApiKeyUpdate {
 	if v != nil {
 		_u.SetUserID(*v)
 	}
@@ -73,13 +72,13 @@ func (_u *APIKeyUpdate) SetNillableUserID(v *int64) *APIKeyUpdate {
 }
 
 // SetKey sets the "key" field.
-func (_u *APIKeyUpdate) SetKey(v string) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetKey(v string) *ApiKeyUpdate {
 	_u.mutation.SetKey(v)
 	return _u
 }
 
 // SetNillableKey sets the "key" field if the given value is not nil.
-func (_u *APIKeyUpdate) SetNillableKey(v *string) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetNillableKey(v *string) *ApiKeyUpdate {
 	if v != nil {
 		_u.SetKey(*v)
 	}
@@ -87,13 +86,13 @@ func (_u *APIKeyUpdate) SetNillableKey(v *string) *APIKeyUpdate {
 }
 
 // SetName sets the "name" field.
-func (_u *APIKeyUpdate) SetName(v string) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetName(v string) *ApiKeyUpdate {
 	_u.mutation.SetName(v)
 	return _u
 }
 
 // SetNillableName sets the "name" field if the given value is not nil.
-func (_u *APIKeyUpdate) SetNillableName(v *string) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetNillableName(v *string) *ApiKeyUpdate {
 	if v != nil {
 		_u.SetName(*v)
 	}
@@ -101,13 +100,13 @@ func (_u *APIKeyUpdate) SetNillableName(v *string) *APIKeyUpdate {
 }
 
 // SetGroupID sets the "group_id" field.
-func (_u *APIKeyUpdate) SetGroupID(v int64) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetGroupID(v int64) *ApiKeyUpdate {
 	_u.mutation.SetGroupID(v)
 	return _u
 }
 
 // SetNillableGroupID sets the "group_id" field if the given value is not nil.
-func (_u *APIKeyUpdate) SetNillableGroupID(v *int64) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetNillableGroupID(v *int64) *ApiKeyUpdate {
 	if v != nil {
 		_u.SetGroupID(*v)
 	}
@@ -115,79 +114,43 @@ func (_u *APIKeyUpdate) SetNillableGroupID(v *int64) *APIKeyUpdate {
 }
 
 // ClearGroupID clears the value of the "group_id" field.
-func (_u *APIKeyUpdate) ClearGroupID() *APIKeyUpdate {
+func (_u *ApiKeyUpdate) ClearGroupID() *ApiKeyUpdate {
 	_u.mutation.ClearGroupID()
 	return _u
 }
 
 // SetStatus sets the "status" field.
-func (_u *APIKeyUpdate) SetStatus(v string) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetStatus(v string) *ApiKeyUpdate {
 	_u.mutation.SetStatus(v)
 	return _u
 }
 
 // SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *APIKeyUpdate) SetNillableStatus(v *string) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetNillableStatus(v *string) *ApiKeyUpdate {
 	if v != nil {
 		_u.SetStatus(*v)
 	}
 	return _u
 }
 
-// SetIPWhitelist sets the "ip_whitelist" field.
-func (_u *APIKeyUpdate) SetIPWhitelist(v []string) *APIKeyUpdate {
-	_u.mutation.SetIPWhitelist(v)
-	return _u
-}
-
-// AppendIPWhitelist appends value to the "ip_whitelist" field.
-func (_u *APIKeyUpdate) AppendIPWhitelist(v []string) *APIKeyUpdate {
-	_u.mutation.AppendIPWhitelist(v)
-	return _u
-}
-
-// ClearIPWhitelist clears the value of the "ip_whitelist" field.
-func (_u *APIKeyUpdate) ClearIPWhitelist() *APIKeyUpdate {
-	_u.mutation.ClearIPWhitelist()
-	return _u
-}
-
-// SetIPBlacklist sets the "ip_blacklist" field.
-func (_u *APIKeyUpdate) SetIPBlacklist(v []string) *APIKeyUpdate {
-	_u.mutation.SetIPBlacklist(v)
-	return _u
-}
-
-// AppendIPBlacklist appends value to the "ip_blacklist" field.
-func (_u *APIKeyUpdate) AppendIPBlacklist(v []string) *APIKeyUpdate {
-	_u.mutation.AppendIPBlacklist(v)
-	return _u
-}
-
-// ClearIPBlacklist clears the value of the "ip_blacklist" field.
-func (_u *APIKeyUpdate) ClearIPBlacklist() *APIKeyUpdate {
-	_u.mutation.ClearIPBlacklist()
-	return _u
-}
-
 // SetUser sets the "user" edge to the User entity.
-func (_u *APIKeyUpdate) SetUser(v *User) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetUser(v *User) *ApiKeyUpdate {
 	return _u.SetUserID(v.ID)
 }
 
 // SetGroup sets the "group" edge to the Group entity.
-func (_u *APIKeyUpdate) SetGroup(v *Group) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) SetGroup(v *Group) *ApiKeyUpdate {
 	return _u.SetGroupID(v.ID)
 }
 
 // AddUsageLogIDs adds the "usage_logs" edge to the UsageLog entity by IDs.
-func (_u *APIKeyUpdate) AddUsageLogIDs(ids ...int64) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) AddUsageLogIDs(ids ...int64) *ApiKeyUpdate {
 	_u.mutation.AddUsageLogIDs(ids...)
 	return _u
 }
 
 // AddUsageLogs adds the "usage_logs" edges to the UsageLog entity.
-func (_u *APIKeyUpdate) AddUsageLogs(v ...*UsageLog) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) AddUsageLogs(v ...*UsageLog) *ApiKeyUpdate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -195,37 +158,37 @@ func (_u *APIKeyUpdate) AddUsageLogs(v ...*UsageLog) *APIKeyUpdate {
 	return _u.AddUsageLogIDs(ids...)
 }
 
-// Mutation returns the APIKeyMutation object of the builder.
-func (_u *APIKeyUpdate) Mutation() *APIKeyMutation {
+// Mutation returns the ApiKeyMutation object of the builder.
+func (_u *ApiKeyUpdate) Mutation() *ApiKeyMutation {
 	return _u.mutation
 }
 
 // ClearUser clears the "user" edge to the User entity.
-func (_u *APIKeyUpdate) ClearUser() *APIKeyUpdate {
+func (_u *ApiKeyUpdate) ClearUser() *ApiKeyUpdate {
 	_u.mutation.ClearUser()
 	return _u
 }
 
 // ClearGroup clears the "group" edge to the Group entity.
-func (_u *APIKeyUpdate) ClearGroup() *APIKeyUpdate {
+func (_u *ApiKeyUpdate) ClearGroup() *ApiKeyUpdate {
 	_u.mutation.ClearGroup()
 	return _u
 }
 
 // ClearUsageLogs clears all "usage_logs" edges to the UsageLog entity.
-func (_u *APIKeyUpdate) ClearUsageLogs() *APIKeyUpdate {
+func (_u *ApiKeyUpdate) ClearUsageLogs() *ApiKeyUpdate {
 	_u.mutation.ClearUsageLogs()
 	return _u
 }
 
 // RemoveUsageLogIDs removes the "usage_logs" edge to UsageLog entities by IDs.
-func (_u *APIKeyUpdate) RemoveUsageLogIDs(ids ...int64) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) RemoveUsageLogIDs(ids ...int64) *ApiKeyUpdate {
 	_u.mutation.RemoveUsageLogIDs(ids...)
 	return _u
 }
 
 // RemoveUsageLogs removes "usage_logs" edges to UsageLog entities.
-func (_u *APIKeyUpdate) RemoveUsageLogs(v ...*UsageLog) *APIKeyUpdate {
+func (_u *ApiKeyUpdate) RemoveUsageLogs(v ...*UsageLog) *ApiKeyUpdate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -234,7 +197,7 @@ func (_u *APIKeyUpdate) RemoveUsageLogs(v ...*UsageLog) *APIKeyUpdate {
 }
 
 // Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *APIKeyUpdate) Save(ctx context.Context) (int, error) {
+func (_u *ApiKeyUpdate) Save(ctx context.Context) (int, error) {
 	if err := _u.defaults(); err != nil {
 		return 0, err
 	}
@@ -242,7 +205,7 @@ func (_u *APIKeyUpdate) Save(ctx context.Context) (int, error) {
 }
 
 // SaveX is like Save, but panics if an error occurs.
-func (_u *APIKeyUpdate) SaveX(ctx context.Context) int {
+func (_u *ApiKeyUpdate) SaveX(ctx context.Context) int {
 	affected, err := _u.Save(ctx)
 	if err != nil {
 		panic(err)
@@ -251,20 +214,20 @@ func (_u *APIKeyUpdate) SaveX(ctx context.Context) int {
 }
 
 // Exec executes the query.
-func (_u *APIKeyUpdate) Exec(ctx context.Context) error {
+func (_u *ApiKeyUpdate) Exec(ctx context.Context) error {
 	_, err := _u.Save(ctx)
 	return err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (_u *APIKeyUpdate) ExecX(ctx context.Context) {
+func (_u *ApiKeyUpdate) 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 *APIKeyUpdate) defaults() error {
+func (_u *ApiKeyUpdate) defaults() error {
 	if _, ok := _u.mutation.UpdatedAt(); !ok {
 		if apikey.UpdateDefaultUpdatedAt == nil {
 			return fmt.Errorf("ent: uninitialized apikey.UpdateDefaultUpdatedAt (forgotten import ent/runtime?)")
@@ -276,29 +239,29 @@ func (_u *APIKeyUpdate) defaults() error {
 }
 
 // check runs all checks and user-defined validators on the builder.
-func (_u *APIKeyUpdate) check() error {
+func (_u *ApiKeyUpdate) check() error {
 	if v, ok := _u.mutation.Key(); ok {
 		if err := apikey.KeyValidator(v); err != nil {
-			return &ValidationError{Name: "key", err: fmt.Errorf(`ent: validator failed for field "APIKey.key": %w`, err)}
+			return &ValidationError{Name: "key", err: fmt.Errorf(`ent: validator failed for field "ApiKey.key": %w`, err)}
 		}
 	}
 	if v, ok := _u.mutation.Name(); ok {
 		if err := apikey.NameValidator(v); err != nil {
-			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "APIKey.name": %w`, err)}
+			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "ApiKey.name": %w`, err)}
 		}
 	}
 	if v, ok := _u.mutation.Status(); ok {
 		if err := apikey.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "APIKey.status": %w`, err)}
+			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "ApiKey.status": %w`, err)}
 		}
 	}
 	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "APIKey.user"`)
+		return errors.New(`ent: clearing a required unique edge "ApiKey.user"`)
 	}
 	return nil
 }
 
-func (_u *APIKeyUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+func (_u *ApiKeyUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if err := _u.check(); err != nil {
 		return _node, err
 	}
@@ -328,28 +291,6 @@ func (_u *APIKeyUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.Status(); ok {
 		_spec.SetField(apikey.FieldStatus, field.TypeString, value)
 	}
-	if value, ok := _u.mutation.IPWhitelist(); ok {
-		_spec.SetField(apikey.FieldIPWhitelist, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedIPWhitelist(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, apikey.FieldIPWhitelist, value)
-		})
-	}
-	if _u.mutation.IPWhitelistCleared() {
-		_spec.ClearField(apikey.FieldIPWhitelist, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.IPBlacklist(); ok {
-		_spec.SetField(apikey.FieldIPBlacklist, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedIPBlacklist(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, apikey.FieldIPBlacklist, value)
-		})
-	}
-	if _u.mutation.IPBlacklistCleared() {
-		_spec.ClearField(apikey.FieldIPBlacklist, field.TypeJSON)
-	}
 	if _u.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -465,28 +406,28 @@ func (_u *APIKeyUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	return _node, nil
 }
 
-// APIKeyUpdateOne is the builder for updating a single APIKey entity.
-type APIKeyUpdateOne struct {
+// ApiKeyUpdateOne is the builder for updating a single ApiKey entity.
+type ApiKeyUpdateOne struct {
 	config
 	fields   []string
 	hooks    []Hook
-	mutation *APIKeyMutation
+	mutation *ApiKeyMutation
 }
 
 // SetUpdatedAt sets the "updated_at" field.
-func (_u *APIKeyUpdateOne) SetUpdatedAt(v time.Time) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetUpdatedAt(v time.Time) *ApiKeyUpdateOne {
 	_u.mutation.SetUpdatedAt(v)
 	return _u
 }
 
 // SetDeletedAt sets the "deleted_at" field.
-func (_u *APIKeyUpdateOne) SetDeletedAt(v time.Time) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetDeletedAt(v time.Time) *ApiKeyUpdateOne {
 	_u.mutation.SetDeletedAt(v)
 	return _u
 }
 
 // SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
-func (_u *APIKeyUpdateOne) SetNillableDeletedAt(v *time.Time) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetNillableDeletedAt(v *time.Time) *ApiKeyUpdateOne {
 	if v != nil {
 		_u.SetDeletedAt(*v)
 	}
@@ -494,19 +435,19 @@ func (_u *APIKeyUpdateOne) SetNillableDeletedAt(v *time.Time) *APIKeyUpdateOne {
 }
 
 // ClearDeletedAt clears the value of the "deleted_at" field.
-func (_u *APIKeyUpdateOne) ClearDeletedAt() *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) ClearDeletedAt() *ApiKeyUpdateOne {
 	_u.mutation.ClearDeletedAt()
 	return _u
 }
 
 // SetUserID sets the "user_id" field.
-func (_u *APIKeyUpdateOne) SetUserID(v int64) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetUserID(v int64) *ApiKeyUpdateOne {
 	_u.mutation.SetUserID(v)
 	return _u
 }
 
 // SetNillableUserID sets the "user_id" field if the given value is not nil.
-func (_u *APIKeyUpdateOne) SetNillableUserID(v *int64) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetNillableUserID(v *int64) *ApiKeyUpdateOne {
 	if v != nil {
 		_u.SetUserID(*v)
 	}
@@ -514,13 +455,13 @@ func (_u *APIKeyUpdateOne) SetNillableUserID(v *int64) *APIKeyUpdateOne {
 }
 
 // SetKey sets the "key" field.
-func (_u *APIKeyUpdateOne) SetKey(v string) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetKey(v string) *ApiKeyUpdateOne {
 	_u.mutation.SetKey(v)
 	return _u
 }
 
 // SetNillableKey sets the "key" field if the given value is not nil.
-func (_u *APIKeyUpdateOne) SetNillableKey(v *string) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetNillableKey(v *string) *ApiKeyUpdateOne {
 	if v != nil {
 		_u.SetKey(*v)
 	}
@@ -528,13 +469,13 @@ func (_u *APIKeyUpdateOne) SetNillableKey(v *string) *APIKeyUpdateOne {
 }
 
 // SetName sets the "name" field.
-func (_u *APIKeyUpdateOne) SetName(v string) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetName(v string) *ApiKeyUpdateOne {
 	_u.mutation.SetName(v)
 	return _u
 }
 
 // SetNillableName sets the "name" field if the given value is not nil.
-func (_u *APIKeyUpdateOne) SetNillableName(v *string) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetNillableName(v *string) *ApiKeyUpdateOne {
 	if v != nil {
 		_u.SetName(*v)
 	}
@@ -542,13 +483,13 @@ func (_u *APIKeyUpdateOne) SetNillableName(v *string) *APIKeyUpdateOne {
 }
 
 // SetGroupID sets the "group_id" field.
-func (_u *APIKeyUpdateOne) SetGroupID(v int64) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetGroupID(v int64) *ApiKeyUpdateOne {
 	_u.mutation.SetGroupID(v)
 	return _u
 }
 
 // SetNillableGroupID sets the "group_id" field if the given value is not nil.
-func (_u *APIKeyUpdateOne) SetNillableGroupID(v *int64) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetNillableGroupID(v *int64) *ApiKeyUpdateOne {
 	if v != nil {
 		_u.SetGroupID(*v)
 	}
@@ -556,79 +497,43 @@ func (_u *APIKeyUpdateOne) SetNillableGroupID(v *int64) *APIKeyUpdateOne {
 }
 
 // ClearGroupID clears the value of the "group_id" field.
-func (_u *APIKeyUpdateOne) ClearGroupID() *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) ClearGroupID() *ApiKeyUpdateOne {
 	_u.mutation.ClearGroupID()
 	return _u
 }
 
 // SetStatus sets the "status" field.
-func (_u *APIKeyUpdateOne) SetStatus(v string) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetStatus(v string) *ApiKeyUpdateOne {
 	_u.mutation.SetStatus(v)
 	return _u
 }
 
 // SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *APIKeyUpdateOne) SetNillableStatus(v *string) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetNillableStatus(v *string) *ApiKeyUpdateOne {
 	if v != nil {
 		_u.SetStatus(*v)
 	}
 	return _u
 }
 
-// SetIPWhitelist sets the "ip_whitelist" field.
-func (_u *APIKeyUpdateOne) SetIPWhitelist(v []string) *APIKeyUpdateOne {
-	_u.mutation.SetIPWhitelist(v)
-	return _u
-}
-
-// AppendIPWhitelist appends value to the "ip_whitelist" field.
-func (_u *APIKeyUpdateOne) AppendIPWhitelist(v []string) *APIKeyUpdateOne {
-	_u.mutation.AppendIPWhitelist(v)
-	return _u
-}
-
-// ClearIPWhitelist clears the value of the "ip_whitelist" field.
-func (_u *APIKeyUpdateOne) ClearIPWhitelist() *APIKeyUpdateOne {
-	_u.mutation.ClearIPWhitelist()
-	return _u
-}
-
-// SetIPBlacklist sets the "ip_blacklist" field.
-func (_u *APIKeyUpdateOne) SetIPBlacklist(v []string) *APIKeyUpdateOne {
-	_u.mutation.SetIPBlacklist(v)
-	return _u
-}
-
-// AppendIPBlacklist appends value to the "ip_blacklist" field.
-func (_u *APIKeyUpdateOne) AppendIPBlacklist(v []string) *APIKeyUpdateOne {
-	_u.mutation.AppendIPBlacklist(v)
-	return _u
-}
-
-// ClearIPBlacklist clears the value of the "ip_blacklist" field.
-func (_u *APIKeyUpdateOne) ClearIPBlacklist() *APIKeyUpdateOne {
-	_u.mutation.ClearIPBlacklist()
-	return _u
-}
-
 // SetUser sets the "user" edge to the User entity.
-func (_u *APIKeyUpdateOne) SetUser(v *User) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetUser(v *User) *ApiKeyUpdateOne {
 	return _u.SetUserID(v.ID)
 }
 
 // SetGroup sets the "group" edge to the Group entity.
-func (_u *APIKeyUpdateOne) SetGroup(v *Group) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) SetGroup(v *Group) *ApiKeyUpdateOne {
 	return _u.SetGroupID(v.ID)
 }
 
 // AddUsageLogIDs adds the "usage_logs" edge to the UsageLog entity by IDs.
-func (_u *APIKeyUpdateOne) AddUsageLogIDs(ids ...int64) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) AddUsageLogIDs(ids ...int64) *ApiKeyUpdateOne {
 	_u.mutation.AddUsageLogIDs(ids...)
 	return _u
 }
 
 // AddUsageLogs adds the "usage_logs" edges to the UsageLog entity.
-func (_u *APIKeyUpdateOne) AddUsageLogs(v ...*UsageLog) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) AddUsageLogs(v ...*UsageLog) *ApiKeyUpdateOne {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -636,37 +541,37 @@ func (_u *APIKeyUpdateOne) AddUsageLogs(v ...*UsageLog) *APIKeyUpdateOne {
 	return _u.AddUsageLogIDs(ids...)
 }
 
-// Mutation returns the APIKeyMutation object of the builder.
-func (_u *APIKeyUpdateOne) Mutation() *APIKeyMutation {
+// Mutation returns the ApiKeyMutation object of the builder.
+func (_u *ApiKeyUpdateOne) Mutation() *ApiKeyMutation {
 	return _u.mutation
 }
 
 // ClearUser clears the "user" edge to the User entity.
-func (_u *APIKeyUpdateOne) ClearUser() *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) ClearUser() *ApiKeyUpdateOne {
 	_u.mutation.ClearUser()
 	return _u
 }
 
 // ClearGroup clears the "group" edge to the Group entity.
-func (_u *APIKeyUpdateOne) ClearGroup() *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) ClearGroup() *ApiKeyUpdateOne {
 	_u.mutation.ClearGroup()
 	return _u
 }
 
 // ClearUsageLogs clears all "usage_logs" edges to the UsageLog entity.
-func (_u *APIKeyUpdateOne) ClearUsageLogs() *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) ClearUsageLogs() *ApiKeyUpdateOne {
 	_u.mutation.ClearUsageLogs()
 	return _u
 }
 
 // RemoveUsageLogIDs removes the "usage_logs" edge to UsageLog entities by IDs.
-func (_u *APIKeyUpdateOne) RemoveUsageLogIDs(ids ...int64) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) RemoveUsageLogIDs(ids ...int64) *ApiKeyUpdateOne {
 	_u.mutation.RemoveUsageLogIDs(ids...)
 	return _u
 }
 
 // RemoveUsageLogs removes "usage_logs" edges to UsageLog entities.
-func (_u *APIKeyUpdateOne) RemoveUsageLogs(v ...*UsageLog) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) RemoveUsageLogs(v ...*UsageLog) *ApiKeyUpdateOne {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -674,21 +579,21 @@ func (_u *APIKeyUpdateOne) RemoveUsageLogs(v ...*UsageLog) *APIKeyUpdateOne {
 	return _u.RemoveUsageLogIDs(ids...)
 }
 
-// Where appends a list predicates to the APIKeyUpdate builder.
-func (_u *APIKeyUpdateOne) Where(ps ...predicate.APIKey) *APIKeyUpdateOne {
+// Where appends a list predicates to the ApiKeyUpdate builder.
+func (_u *ApiKeyUpdateOne) Where(ps ...predicate.ApiKey) *ApiKeyUpdateOne {
 	_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 *APIKeyUpdateOne) Select(field string, fields ...string) *APIKeyUpdateOne {
+func (_u *ApiKeyUpdateOne) Select(field string, fields ...string) *ApiKeyUpdateOne {
 	_u.fields = append([]string{field}, fields...)
 	return _u
 }
 
-// Save executes the query and returns the updated APIKey entity.
-func (_u *APIKeyUpdateOne) Save(ctx context.Context) (*APIKey, error) {
+// Save executes the query and returns the updated ApiKey entity.
+func (_u *ApiKeyUpdateOne) Save(ctx context.Context) (*ApiKey, error) {
 	if err := _u.defaults(); err != nil {
 		return nil, err
 	}
@@ -696,7 +601,7 @@ func (_u *APIKeyUpdateOne) Save(ctx context.Context) (*APIKey, error) {
 }
 
 // SaveX is like Save, but panics if an error occurs.
-func (_u *APIKeyUpdateOne) SaveX(ctx context.Context) *APIKey {
+func (_u *ApiKeyUpdateOne) SaveX(ctx context.Context) *ApiKey {
 	node, err := _u.Save(ctx)
 	if err != nil {
 		panic(err)
@@ -705,20 +610,20 @@ func (_u *APIKeyUpdateOne) SaveX(ctx context.Context) *APIKey {
 }
 
 // Exec executes the query on the entity.
-func (_u *APIKeyUpdateOne) Exec(ctx context.Context) error {
+func (_u *ApiKeyUpdateOne) Exec(ctx context.Context) error {
 	_, err := _u.Save(ctx)
 	return err
 }
 
 // ExecX is like Exec, but panics if an error occurs.
-func (_u *APIKeyUpdateOne) ExecX(ctx context.Context) {
+func (_u *ApiKeyUpdateOne) 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 *APIKeyUpdateOne) defaults() error {
+func (_u *ApiKeyUpdateOne) defaults() error {
 	if _, ok := _u.mutation.UpdatedAt(); !ok {
 		if apikey.UpdateDefaultUpdatedAt == nil {
 			return fmt.Errorf("ent: uninitialized apikey.UpdateDefaultUpdatedAt (forgotten import ent/runtime?)")
@@ -730,36 +635,36 @@ func (_u *APIKeyUpdateOne) defaults() error {
 }
 
 // check runs all checks and user-defined validators on the builder.
-func (_u *APIKeyUpdateOne) check() error {
+func (_u *ApiKeyUpdateOne) check() error {
 	if v, ok := _u.mutation.Key(); ok {
 		if err := apikey.KeyValidator(v); err != nil {
-			return &ValidationError{Name: "key", err: fmt.Errorf(`ent: validator failed for field "APIKey.key": %w`, err)}
+			return &ValidationError{Name: "key", err: fmt.Errorf(`ent: validator failed for field "ApiKey.key": %w`, err)}
 		}
 	}
 	if v, ok := _u.mutation.Name(); ok {
 		if err := apikey.NameValidator(v); err != nil {
-			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "APIKey.name": %w`, err)}
+			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "ApiKey.name": %w`, err)}
 		}
 	}
 	if v, ok := _u.mutation.Status(); ok {
 		if err := apikey.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "APIKey.status": %w`, err)}
+			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "ApiKey.status": %w`, err)}
 		}
 	}
 	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
-		return errors.New(`ent: clearing a required unique edge "APIKey.user"`)
+		return errors.New(`ent: clearing a required unique edge "ApiKey.user"`)
 	}
 	return nil
 }
 
-func (_u *APIKeyUpdateOne) sqlSave(ctx context.Context) (_node *APIKey, err error) {
+func (_u *ApiKeyUpdateOne) sqlSave(ctx context.Context) (_node *ApiKey, err error) {
 	if err := _u.check(); err != nil {
 		return _node, err
 	}
 	_spec := sqlgraph.NewUpdateSpec(apikey.Table, apikey.Columns, sqlgraph.NewFieldSpec(apikey.FieldID, field.TypeInt64))
 	id, ok := _u.mutation.ID()
 	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "APIKey.id" for update`)}
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ApiKey.id" for update`)}
 	}
 	_spec.Node.ID.Value = id
 	if fields := _u.fields; len(fields) > 0 {
@@ -799,28 +704,6 @@ func (_u *APIKeyUpdateOne) sqlSave(ctx context.Context) (_node *APIKey, err erro
 	if value, ok := _u.mutation.Status(); ok {
 		_spec.SetField(apikey.FieldStatus, field.TypeString, value)
 	}
-	if value, ok := _u.mutation.IPWhitelist(); ok {
-		_spec.SetField(apikey.FieldIPWhitelist, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedIPWhitelist(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, apikey.FieldIPWhitelist, value)
-		})
-	}
-	if _u.mutation.IPWhitelistCleared() {
-		_spec.ClearField(apikey.FieldIPWhitelist, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.IPBlacklist(); ok {
-		_spec.SetField(apikey.FieldIPBlacklist, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedIPBlacklist(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, apikey.FieldIPBlacklist, value)
-		})
-	}
-	if _u.mutation.IPBlacklistCleared() {
-		_spec.ClearField(apikey.FieldIPBlacklist, field.TypeJSON)
-	}
 	if _u.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -924,7 +807,7 @@ func (_u *APIKeyUpdateOne) sqlSave(ctx context.Context) (_node *APIKey, err erro
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	_node = &APIKey{config: _u.config}
+	_node = &ApiKey{config: _u.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
 	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {

backend/ent/ent.go

@@ -16,17 +16,12 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/accountgroup"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
 	"github.com/Wei-Shaw/sub2api/ent/group"
-	"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/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,22 +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,
-			group.Table:                   group.ValidColumn,
-			promocode.Table:               promocode.ValidColumn,
-			promocodeusage.Table:          promocodeusage.ValidColumn,
-			proxy.Table:                   proxy.ValidColumn,
-			redeemcode.Table:              redeemcode.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/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,20 +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"`
-	// 是否仅允许 Claude Code 客户端
-	ClaudeCodeOnly bool `json:"claude_code_only,omitempty"`
-	// 非 Claude Code 请求降级使用的分组 ID
-	FallbackGroupID *int64 `json:"fallback_group_id,omitempty"`
-	// 模型路由配置：模型模式 -> 优先账号ID列表
-	ModelRouting map[string][]int64 `json:"model_routing,omitempty"`
-	// 是否启用模型路由配置
-	ModelRoutingEnabled bool `json:"model_routing_enabled,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"`
@@ -69,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.
@@ -91,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
 	}
@@ -166,13 +151,11 @@ func (*Group) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case group.FieldModelRouting:
-			values[i] = new([]byte)
-		case group.FieldIsExclusive, group.FieldClaudeCodeOnly, group.FieldModelRoutingEnabled:
+		case group.FieldIsExclusive:
 			values[i] = new(sql.NullBool)
-		case group.FieldRateMultiplier, group.FieldDailyLimitUsd, group.FieldWeeklyLimitUsd, group.FieldMonthlyLimitUsd, group.FieldImagePrice1k, group.FieldImagePrice2k, group.FieldImagePrice4k:
+		case group.FieldRateMultiplier, group.FieldDailyLimitUsd, group.FieldWeeklyLimitUsd, group.FieldMonthlyLimitUsd:
 			values[i] = new(sql.NullFloat64)
-		case group.FieldID, group.FieldDefaultValidityDays, group.FieldFallbackGroupID:
+		case group.FieldID, group.FieldDefaultValidityDays:
 			values[i] = new(sql.NullInt64)
 		case group.FieldName, group.FieldDescription, group.FieldStatus, group.FieldPlatform, group.FieldSubscriptionType:
 			values[i] = new(sql.NullString)
@@ -288,54 +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.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.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
-			}
 		default:
 			_m.selectValues.Set(columns[i], values[i])
 		}
@@ -350,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)
 }
 
@@ -463,35 +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(", ")
-	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(", ")
-	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.WriteByte(')')
 	return builder.String()
 }

backend/ent/group/group.go

@@ -43,20 +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"
-	// 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"
-	// 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"
 	// 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.
@@ -77,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.
@@ -146,13 +132,6 @@ var Columns = []string{
 	FieldWeeklyLimitUsd,
 	FieldMonthlyLimitUsd,
 	FieldDefaultValidityDays,
-	FieldImagePrice1k,
-	FieldImagePrice2k,
-	FieldImagePrice4k,
-	FieldClaudeCodeOnly,
-	FieldFallbackGroupID,
-	FieldModelRouting,
-	FieldModelRoutingEnabled,
 }
 
 var (
@@ -208,10 +187,6 @@ var (
 	SubscriptionTypeValidator func(string) error
 	// DefaultDefaultValidityDays holds the default value on creation for the "default_validity_days" field.
 	DefaultDefaultValidityDays int
-	// 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
 )
 
 // OrderOption defines the ordering options for the Group queries.
@@ -292,36 +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()
-}
-
-// 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()
-}
-
-// ByModelRoutingEnabled orders the results by the model_routing_enabled field.
-func ByModelRoutingEnabled(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldModelRoutingEnabled, 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,36 +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))
-}
-
-// 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))
-}
-
-// 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))
-}
-
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v time.Time) predicate.Group {
 	return predicate.Group(sql.FieldEQ(FieldCreatedAt, v))
@@ -860,236 +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))
-}
-
-// 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))
-}
-
-// 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))
-}
-
 // HasAPIKeys applies the HasEdge predicate on the "api_keys" edge.
 func HasAPIKeys() predicate.Group {
 	return predicate.Group(func(s *sql.Selector) {
@@ -1102,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_create.go

@@ -216,104 +216,14 @@ func (_c *GroupCreate) SetNillableDefaultValidityDays(v *int) *GroupCreate {
 	return _c
 }
 
-// SetImagePrice1k sets the "image_price_1k" field.
-func (_c *GroupCreate) SetImagePrice1k(v float64) *GroupCreate {
-	_c.mutation.SetImagePrice1k(v)
-	return _c
-}
-
-// SetNillableImagePrice1k sets the "image_price_1k" field if the given value is not nil.
-func (_c *GroupCreate) SetNillableImagePrice1k(v *float64) *GroupCreate {
-	if v != nil {
-		_c.SetImagePrice1k(*v)
-	}
-	return _c
-}
-
-// SetImagePrice2k sets the "image_price_2k" field.
-func (_c *GroupCreate) SetImagePrice2k(v float64) *GroupCreate {
-	_c.mutation.SetImagePrice2k(v)
-	return _c
-}
-
-// SetNillableImagePrice2k sets the "image_price_2k" field if the given value is not nil.
-func (_c *GroupCreate) SetNillableImagePrice2k(v *float64) *GroupCreate {
-	if v != nil {
-		_c.SetImagePrice2k(*v)
-	}
-	return _c
-}
-
-// SetImagePrice4k sets the "image_price_4k" field.
-func (_c *GroupCreate) SetImagePrice4k(v float64) *GroupCreate {
-	_c.mutation.SetImagePrice4k(v)
-	return _c
-}
-
-// SetNillableImagePrice4k sets the "image_price_4k" field if the given value is not nil.
-func (_c *GroupCreate) SetNillableImagePrice4k(v *float64) *GroupCreate {
-	if v != nil {
-		_c.SetImagePrice4k(*v)
-	}
-	return _c
-}
-
-// SetClaudeCodeOnly sets the "claude_code_only" field.
-func (_c *GroupCreate) SetClaudeCodeOnly(v bool) *GroupCreate {
-	_c.mutation.SetClaudeCodeOnly(v)
-	return _c
-}
-
-// SetNillableClaudeCodeOnly sets the "claude_code_only" field if the given value is not nil.
-func (_c *GroupCreate) SetNillableClaudeCodeOnly(v *bool) *GroupCreate {
-	if v != nil {
-		_c.SetClaudeCodeOnly(*v)
-	}
-	return _c
-}
-
-// SetFallbackGroupID sets the "fallback_group_id" field.
-func (_c *GroupCreate) SetFallbackGroupID(v int64) *GroupCreate {
-	_c.mutation.SetFallbackGroupID(v)
-	return _c
-}
-
-// SetNillableFallbackGroupID sets the "fallback_group_id" field if the given value is not nil.
-func (_c *GroupCreate) SetNillableFallbackGroupID(v *int64) *GroupCreate {
-	if v != nil {
-		_c.SetFallbackGroupID(*v)
-	}
-	return _c
-}
-
-// SetModelRouting sets the "model_routing" field.
-func (_c *GroupCreate) SetModelRouting(v map[string][]int64) *GroupCreate {
-	_c.mutation.SetModelRouting(v)
-	return _c
-}
-
-// SetModelRoutingEnabled sets the "model_routing_enabled" field.
-func (_c *GroupCreate) SetModelRoutingEnabled(v bool) *GroupCreate {
-	_c.mutation.SetModelRoutingEnabled(v)
-	return _c
-}
-
-// SetNillableModelRoutingEnabled sets the "model_routing_enabled" field if the given value is not nil.
-func (_c *GroupCreate) SetNillableModelRoutingEnabled(v *bool) *GroupCreate {
-	if v != nil {
-		_c.SetModelRoutingEnabled(*v)
-	}
-	return _c
-}
-
-// AddAPIKeyIDs adds the "api_keys" edge to the APIKey entity by IDs.
+// AddAPIKeyIDs adds the "api_keys" edge to the ApiKey entity by IDs.
 func (_c *GroupCreate) AddAPIKeyIDs(ids ...int64) *GroupCreate {
 	_c.mutation.AddAPIKeyIDs(ids...)
 	return _c
 }
 
-// AddAPIKeys adds the "api_keys" edges to the APIKey entity.
-func (_c *GroupCreate) AddAPIKeys(v ...*APIKey) *GroupCreate {
+// AddAPIKeys adds the "api_keys" edges to the ApiKey entity.
+func (_c *GroupCreate) AddAPIKeys(v ...*ApiKey) *GroupCreate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -471,14 +381,6 @@ func (_c *GroupCreate) defaults() error {
 		v := group.DefaultDefaultValidityDays
 		_c.mutation.SetDefaultValidityDays(v)
 	}
-	if _, ok := _c.mutation.ClaudeCodeOnly(); !ok {
-		v := group.DefaultClaudeCodeOnly
-		_c.mutation.SetClaudeCodeOnly(v)
-	}
-	if _, ok := _c.mutation.ModelRoutingEnabled(); !ok {
-		v := group.DefaultModelRoutingEnabled
-		_c.mutation.SetModelRoutingEnabled(v)
-	}
 	return nil
 }
 
@@ -531,12 +433,6 @@ func (_c *GroupCreate) check() error {
 	if _, ok := _c.mutation.DefaultValidityDays(); !ok {
 		return &ValidationError{Name: "default_validity_days", err: errors.New(`ent: missing required field "Group.default_validity_days"`)}
 	}
-	if _, ok := _c.mutation.ClaudeCodeOnly(); !ok {
-		return &ValidationError{Name: "claude_code_only", err: errors.New(`ent: missing required field "Group.claude_code_only"`)}
-	}
-	if _, ok := _c.mutation.ModelRoutingEnabled(); !ok {
-		return &ValidationError{Name: "model_routing_enabled", err: errors.New(`ent: missing required field "Group.model_routing_enabled"`)}
-	}
 	return nil
 }
 
@@ -620,34 +516,6 @@ func (_c *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
 		_spec.SetField(group.FieldDefaultValidityDays, field.TypeInt, value)
 		_node.DefaultValidityDays = value
 	}
-	if value, ok := _c.mutation.ImagePrice1k(); ok {
-		_spec.SetField(group.FieldImagePrice1k, field.TypeFloat64, value)
-		_node.ImagePrice1k = &value
-	}
-	if value, ok := _c.mutation.ImagePrice2k(); ok {
-		_spec.SetField(group.FieldImagePrice2k, field.TypeFloat64, value)
-		_node.ImagePrice2k = &value
-	}
-	if value, ok := _c.mutation.ImagePrice4k(); ok {
-		_spec.SetField(group.FieldImagePrice4k, field.TypeFloat64, value)
-		_node.ImagePrice4k = &value
-	}
-	if value, ok := _c.mutation.ClaudeCodeOnly(); ok {
-		_spec.SetField(group.FieldClaudeCodeOnly, field.TypeBool, value)
-		_node.ClaudeCodeOnly = value
-	}
-	if value, ok := _c.mutation.FallbackGroupID(); ok {
-		_spec.SetField(group.FieldFallbackGroupID, field.TypeInt64, value)
-		_node.FallbackGroupID = &value
-	}
-	if value, ok := _c.mutation.ModelRouting(); ok {
-		_spec.SetField(group.FieldModelRouting, field.TypeJSON, value)
-		_node.ModelRouting = value
-	}
-	if value, ok := _c.mutation.ModelRoutingEnabled(); ok {
-		_spec.SetField(group.FieldModelRoutingEnabled, field.TypeBool, value)
-		_node.ModelRoutingEnabled = value
-	}
 	if nodes := _c.mutation.APIKeysIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
@@ -1020,144 +888,6 @@ func (u *GroupUpsert) AddDefaultValidityDays(v int) *GroupUpsert {
 	return u
 }
 
-// SetImagePrice1k sets the "image_price_1k" field.
-func (u *GroupUpsert) SetImagePrice1k(v float64) *GroupUpsert {
-	u.Set(group.FieldImagePrice1k, v)
-	return u
-}
-
-// UpdateImagePrice1k sets the "image_price_1k" field to the value that was provided on create.
-func (u *GroupUpsert) UpdateImagePrice1k() *GroupUpsert {
-	u.SetExcluded(group.FieldImagePrice1k)
-	return u
-}
-
-// AddImagePrice1k adds v to the "image_price_1k" field.
-func (u *GroupUpsert) AddImagePrice1k(v float64) *GroupUpsert {
-	u.Add(group.FieldImagePrice1k, v)
-	return u
-}
-
-// ClearImagePrice1k clears the value of the "image_price_1k" field.
-func (u *GroupUpsert) ClearImagePrice1k() *GroupUpsert {
-	u.SetNull(group.FieldImagePrice1k)
-	return u
-}
-
-// SetImagePrice2k sets the "image_price_2k" field.
-func (u *GroupUpsert) SetImagePrice2k(v float64) *GroupUpsert {
-	u.Set(group.FieldImagePrice2k, v)
-	return u
-}
-
-// UpdateImagePrice2k sets the "image_price_2k" field to the value that was provided on create.
-func (u *GroupUpsert) UpdateImagePrice2k() *GroupUpsert {
-	u.SetExcluded(group.FieldImagePrice2k)
-	return u
-}
-
-// AddImagePrice2k adds v to the "image_price_2k" field.
-func (u *GroupUpsert) AddImagePrice2k(v float64) *GroupUpsert {
-	u.Add(group.FieldImagePrice2k, v)
-	return u
-}
-
-// ClearImagePrice2k clears the value of the "image_price_2k" field.
-func (u *GroupUpsert) ClearImagePrice2k() *GroupUpsert {
-	u.SetNull(group.FieldImagePrice2k)
-	return u
-}
-
-// SetImagePrice4k sets the "image_price_4k" field.
-func (u *GroupUpsert) SetImagePrice4k(v float64) *GroupUpsert {
-	u.Set(group.FieldImagePrice4k, v)
-	return u
-}
-
-// UpdateImagePrice4k sets the "image_price_4k" field to the value that was provided on create.
-func (u *GroupUpsert) UpdateImagePrice4k() *GroupUpsert {
-	u.SetExcluded(group.FieldImagePrice4k)
-	return u
-}
-
-// AddImagePrice4k adds v to the "image_price_4k" field.
-func (u *GroupUpsert) AddImagePrice4k(v float64) *GroupUpsert {
-	u.Add(group.FieldImagePrice4k, v)
-	return u
-}
-
-// ClearImagePrice4k clears the value of the "image_price_4k" field.
-func (u *GroupUpsert) ClearImagePrice4k() *GroupUpsert {
-	u.SetNull(group.FieldImagePrice4k)
-	return u
-}
-
-// SetClaudeCodeOnly sets the "claude_code_only" field.
-func (u *GroupUpsert) SetClaudeCodeOnly(v bool) *GroupUpsert {
-	u.Set(group.FieldClaudeCodeOnly, v)
-	return u
-}
-
-// UpdateClaudeCodeOnly sets the "claude_code_only" field to the value that was provided on create.
-func (u *GroupUpsert) UpdateClaudeCodeOnly() *GroupUpsert {
-	u.SetExcluded(group.FieldClaudeCodeOnly)
-	return u
-}
-
-// SetFallbackGroupID sets the "fallback_group_id" field.
-func (u *GroupUpsert) SetFallbackGroupID(v int64) *GroupUpsert {
-	u.Set(group.FieldFallbackGroupID, v)
-	return u
-}
-
-// UpdateFallbackGroupID sets the "fallback_group_id" field to the value that was provided on create.
-func (u *GroupUpsert) UpdateFallbackGroupID() *GroupUpsert {
-	u.SetExcluded(group.FieldFallbackGroupID)
-	return u
-}
-
-// AddFallbackGroupID adds v to the "fallback_group_id" field.
-func (u *GroupUpsert) AddFallbackGroupID(v int64) *GroupUpsert {
-	u.Add(group.FieldFallbackGroupID, v)
-	return u
-}
-
-// ClearFallbackGroupID clears the value of the "fallback_group_id" field.
-func (u *GroupUpsert) ClearFallbackGroupID() *GroupUpsert {
-	u.SetNull(group.FieldFallbackGroupID)
-	return u
-}
-
-// SetModelRouting sets the "model_routing" field.
-func (u *GroupUpsert) SetModelRouting(v map[string][]int64) *GroupUpsert {
-	u.Set(group.FieldModelRouting, v)
-	return u
-}
-
-// UpdateModelRouting sets the "model_routing" field to the value that was provided on create.
-func (u *GroupUpsert) UpdateModelRouting() *GroupUpsert {
-	u.SetExcluded(group.FieldModelRouting)
-	return u
-}
-
-// ClearModelRouting clears the value of the "model_routing" field.
-func (u *GroupUpsert) ClearModelRouting() *GroupUpsert {
-	u.SetNull(group.FieldModelRouting)
-	return u
-}
-
-// SetModelRoutingEnabled sets the "model_routing_enabled" field.
-func (u *GroupUpsert) SetModelRoutingEnabled(v bool) *GroupUpsert {
-	u.Set(group.FieldModelRoutingEnabled, v)
-	return u
-}
-
-// UpdateModelRoutingEnabled sets the "model_routing_enabled" field to the value that was provided on create.
-func (u *GroupUpsert) UpdateModelRoutingEnabled() *GroupUpsert {
-	u.SetExcluded(group.FieldModelRoutingEnabled)
-	return u
-}
-
 // UpdateNewValues updates the mutable fields using the new values that were set on create.
 // Using this option is equivalent to using:
 //
@@ -1455,167 +1185,6 @@ func (u *GroupUpsertOne) UpdateDefaultValidityDays() *GroupUpsertOne {
 	})
 }
 
-// SetImagePrice1k sets the "image_price_1k" field.
-func (u *GroupUpsertOne) SetImagePrice1k(v float64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetImagePrice1k(v)
-	})
-}
-
-// AddImagePrice1k adds v to the "image_price_1k" field.
-func (u *GroupUpsertOne) AddImagePrice1k(v float64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddImagePrice1k(v)
-	})
-}
-
-// UpdateImagePrice1k sets the "image_price_1k" field to the value that was provided on create.
-func (u *GroupUpsertOne) UpdateImagePrice1k() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateImagePrice1k()
-	})
-}
-
-// ClearImagePrice1k clears the value of the "image_price_1k" field.
-func (u *GroupUpsertOne) ClearImagePrice1k() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearImagePrice1k()
-	})
-}
-
-// SetImagePrice2k sets the "image_price_2k" field.
-func (u *GroupUpsertOne) SetImagePrice2k(v float64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetImagePrice2k(v)
-	})
-}
-
-// AddImagePrice2k adds v to the "image_price_2k" field.
-func (u *GroupUpsertOne) AddImagePrice2k(v float64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddImagePrice2k(v)
-	})
-}
-
-// UpdateImagePrice2k sets the "image_price_2k" field to the value that was provided on create.
-func (u *GroupUpsertOne) UpdateImagePrice2k() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateImagePrice2k()
-	})
-}
-
-// ClearImagePrice2k clears the value of the "image_price_2k" field.
-func (u *GroupUpsertOne) ClearImagePrice2k() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearImagePrice2k()
-	})
-}
-
-// SetImagePrice4k sets the "image_price_4k" field.
-func (u *GroupUpsertOne) SetImagePrice4k(v float64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetImagePrice4k(v)
-	})
-}
-
-// AddImagePrice4k adds v to the "image_price_4k" field.
-func (u *GroupUpsertOne) AddImagePrice4k(v float64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddImagePrice4k(v)
-	})
-}
-
-// UpdateImagePrice4k sets the "image_price_4k" field to the value that was provided on create.
-func (u *GroupUpsertOne) UpdateImagePrice4k() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateImagePrice4k()
-	})
-}
-
-// ClearImagePrice4k clears the value of the "image_price_4k" field.
-func (u *GroupUpsertOne) ClearImagePrice4k() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearImagePrice4k()
-	})
-}
-
-// SetClaudeCodeOnly sets the "claude_code_only" field.
-func (u *GroupUpsertOne) SetClaudeCodeOnly(v bool) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetClaudeCodeOnly(v)
-	})
-}
-
-// UpdateClaudeCodeOnly sets the "claude_code_only" field to the value that was provided on create.
-func (u *GroupUpsertOne) UpdateClaudeCodeOnly() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateClaudeCodeOnly()
-	})
-}
-
-// SetFallbackGroupID sets the "fallback_group_id" field.
-func (u *GroupUpsertOne) SetFallbackGroupID(v int64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetFallbackGroupID(v)
-	})
-}
-
-// AddFallbackGroupID adds v to the "fallback_group_id" field.
-func (u *GroupUpsertOne) AddFallbackGroupID(v int64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddFallbackGroupID(v)
-	})
-}
-
-// UpdateFallbackGroupID sets the "fallback_group_id" field to the value that was provided on create.
-func (u *GroupUpsertOne) UpdateFallbackGroupID() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateFallbackGroupID()
-	})
-}
-
-// ClearFallbackGroupID clears the value of the "fallback_group_id" field.
-func (u *GroupUpsertOne) ClearFallbackGroupID() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearFallbackGroupID()
-	})
-}
-
-// SetModelRouting sets the "model_routing" field.
-func (u *GroupUpsertOne) SetModelRouting(v map[string][]int64) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetModelRouting(v)
-	})
-}
-
-// UpdateModelRouting sets the "model_routing" field to the value that was provided on create.
-func (u *GroupUpsertOne) UpdateModelRouting() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateModelRouting()
-	})
-}
-
-// ClearModelRouting clears the value of the "model_routing" field.
-func (u *GroupUpsertOne) ClearModelRouting() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearModelRouting()
-	})
-}
-
-// SetModelRoutingEnabled sets the "model_routing_enabled" field.
-func (u *GroupUpsertOne) SetModelRoutingEnabled(v bool) *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetModelRoutingEnabled(v)
-	})
-}
-
-// UpdateModelRoutingEnabled sets the "model_routing_enabled" field to the value that was provided on create.
-func (u *GroupUpsertOne) UpdateModelRoutingEnabled() *GroupUpsertOne {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateModelRoutingEnabled()
-	})
-}
-
 // Exec executes the query.
 func (u *GroupUpsertOne) Exec(ctx context.Context) error {
 	if len(u.create.conflict) == 0 {
@@ -2079,167 +1648,6 @@ func (u *GroupUpsertBulk) UpdateDefaultValidityDays() *GroupUpsertBulk {
 	})
 }
 
-// SetImagePrice1k sets the "image_price_1k" field.
-func (u *GroupUpsertBulk) SetImagePrice1k(v float64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetImagePrice1k(v)
-	})
-}
-
-// AddImagePrice1k adds v to the "image_price_1k" field.
-func (u *GroupUpsertBulk) AddImagePrice1k(v float64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddImagePrice1k(v)
-	})
-}
-
-// UpdateImagePrice1k sets the "image_price_1k" field to the value that was provided on create.
-func (u *GroupUpsertBulk) UpdateImagePrice1k() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateImagePrice1k()
-	})
-}
-
-// ClearImagePrice1k clears the value of the "image_price_1k" field.
-func (u *GroupUpsertBulk) ClearImagePrice1k() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearImagePrice1k()
-	})
-}
-
-// SetImagePrice2k sets the "image_price_2k" field.
-func (u *GroupUpsertBulk) SetImagePrice2k(v float64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetImagePrice2k(v)
-	})
-}
-
-// AddImagePrice2k adds v to the "image_price_2k" field.
-func (u *GroupUpsertBulk) AddImagePrice2k(v float64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddImagePrice2k(v)
-	})
-}
-
-// UpdateImagePrice2k sets the "image_price_2k" field to the value that was provided on create.
-func (u *GroupUpsertBulk) UpdateImagePrice2k() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateImagePrice2k()
-	})
-}
-
-// ClearImagePrice2k clears the value of the "image_price_2k" field.
-func (u *GroupUpsertBulk) ClearImagePrice2k() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearImagePrice2k()
-	})
-}
-
-// SetImagePrice4k sets the "image_price_4k" field.
-func (u *GroupUpsertBulk) SetImagePrice4k(v float64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetImagePrice4k(v)
-	})
-}
-
-// AddImagePrice4k adds v to the "image_price_4k" field.
-func (u *GroupUpsertBulk) AddImagePrice4k(v float64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddImagePrice4k(v)
-	})
-}
-
-// UpdateImagePrice4k sets the "image_price_4k" field to the value that was provided on create.
-func (u *GroupUpsertBulk) UpdateImagePrice4k() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateImagePrice4k()
-	})
-}
-
-// ClearImagePrice4k clears the value of the "image_price_4k" field.
-func (u *GroupUpsertBulk) ClearImagePrice4k() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearImagePrice4k()
-	})
-}
-
-// SetClaudeCodeOnly sets the "claude_code_only" field.
-func (u *GroupUpsertBulk) SetClaudeCodeOnly(v bool) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetClaudeCodeOnly(v)
-	})
-}
-
-// UpdateClaudeCodeOnly sets the "claude_code_only" field to the value that was provided on create.
-func (u *GroupUpsertBulk) UpdateClaudeCodeOnly() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateClaudeCodeOnly()
-	})
-}
-
-// SetFallbackGroupID sets the "fallback_group_id" field.
-func (u *GroupUpsertBulk) SetFallbackGroupID(v int64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetFallbackGroupID(v)
-	})
-}
-
-// AddFallbackGroupID adds v to the "fallback_group_id" field.
-func (u *GroupUpsertBulk) AddFallbackGroupID(v int64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.AddFallbackGroupID(v)
-	})
-}
-
-// UpdateFallbackGroupID sets the "fallback_group_id" field to the value that was provided on create.
-func (u *GroupUpsertBulk) UpdateFallbackGroupID() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateFallbackGroupID()
-	})
-}
-
-// ClearFallbackGroupID clears the value of the "fallback_group_id" field.
-func (u *GroupUpsertBulk) ClearFallbackGroupID() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearFallbackGroupID()
-	})
-}
-
-// SetModelRouting sets the "model_routing" field.
-func (u *GroupUpsertBulk) SetModelRouting(v map[string][]int64) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetModelRouting(v)
-	})
-}
-
-// UpdateModelRouting sets the "model_routing" field to the value that was provided on create.
-func (u *GroupUpsertBulk) UpdateModelRouting() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateModelRouting()
-	})
-}
-
-// ClearModelRouting clears the value of the "model_routing" field.
-func (u *GroupUpsertBulk) ClearModelRouting() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.ClearModelRouting()
-	})
-}
-
-// SetModelRoutingEnabled sets the "model_routing_enabled" field.
-func (u *GroupUpsertBulk) SetModelRoutingEnabled(v bool) *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.SetModelRoutingEnabled(v)
-	})
-}
-
-// UpdateModelRoutingEnabled sets the "model_routing_enabled" field to the value that was provided on create.
-func (u *GroupUpsertBulk) UpdateModelRoutingEnabled() *GroupUpsertBulk {
-	return u.Update(func(s *GroupUpsert) {
-		s.UpdateModelRoutingEnabled()
-	})
-}
-
 // Exec executes the query.
 func (u *GroupUpsertBulk) Exec(ctx context.Context) error {
 	if u.create.err != nil {

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/group_update.go

@@ -273,162 +273,14 @@ func (_u *GroupUpdate) AddDefaultValidityDays(v int) *GroupUpdate {
 	return _u
 }
 
-// SetImagePrice1k sets the "image_price_1k" field.
-func (_u *GroupUpdate) SetImagePrice1k(v float64) *GroupUpdate {
-	_u.mutation.ResetImagePrice1k()
-	_u.mutation.SetImagePrice1k(v)
-	return _u
-}
-
-// SetNillableImagePrice1k sets the "image_price_1k" field if the given value is not nil.
-func (_u *GroupUpdate) SetNillableImagePrice1k(v *float64) *GroupUpdate {
-	if v != nil {
-		_u.SetImagePrice1k(*v)
-	}
-	return _u
-}
-
-// AddImagePrice1k adds value to the "image_price_1k" field.
-func (_u *GroupUpdate) AddImagePrice1k(v float64) *GroupUpdate {
-	_u.mutation.AddImagePrice1k(v)
-	return _u
-}
-
-// ClearImagePrice1k clears the value of the "image_price_1k" field.
-func (_u *GroupUpdate) ClearImagePrice1k() *GroupUpdate {
-	_u.mutation.ClearImagePrice1k()
-	return _u
-}
-
-// SetImagePrice2k sets the "image_price_2k" field.
-func (_u *GroupUpdate) SetImagePrice2k(v float64) *GroupUpdate {
-	_u.mutation.ResetImagePrice2k()
-	_u.mutation.SetImagePrice2k(v)
-	return _u
-}
-
-// SetNillableImagePrice2k sets the "image_price_2k" field if the given value is not nil.
-func (_u *GroupUpdate) SetNillableImagePrice2k(v *float64) *GroupUpdate {
-	if v != nil {
-		_u.SetImagePrice2k(*v)
-	}
-	return _u
-}
-
-// AddImagePrice2k adds value to the "image_price_2k" field.
-func (_u *GroupUpdate) AddImagePrice2k(v float64) *GroupUpdate {
-	_u.mutation.AddImagePrice2k(v)
-	return _u
-}
-
-// ClearImagePrice2k clears the value of the "image_price_2k" field.
-func (_u *GroupUpdate) ClearImagePrice2k() *GroupUpdate {
-	_u.mutation.ClearImagePrice2k()
-	return _u
-}
-
-// SetImagePrice4k sets the "image_price_4k" field.
-func (_u *GroupUpdate) SetImagePrice4k(v float64) *GroupUpdate {
-	_u.mutation.ResetImagePrice4k()
-	_u.mutation.SetImagePrice4k(v)
-	return _u
-}
-
-// SetNillableImagePrice4k sets the "image_price_4k" field if the given value is not nil.
-func (_u *GroupUpdate) SetNillableImagePrice4k(v *float64) *GroupUpdate {
-	if v != nil {
-		_u.SetImagePrice4k(*v)
-	}
-	return _u
-}
-
-// AddImagePrice4k adds value to the "image_price_4k" field.
-func (_u *GroupUpdate) AddImagePrice4k(v float64) *GroupUpdate {
-	_u.mutation.AddImagePrice4k(v)
-	return _u
-}
-
-// ClearImagePrice4k clears the value of the "image_price_4k" field.
-func (_u *GroupUpdate) ClearImagePrice4k() *GroupUpdate {
-	_u.mutation.ClearImagePrice4k()
-	return _u
-}
-
-// SetClaudeCodeOnly sets the "claude_code_only" field.
-func (_u *GroupUpdate) SetClaudeCodeOnly(v bool) *GroupUpdate {
-	_u.mutation.SetClaudeCodeOnly(v)
-	return _u
-}
-
-// SetNillableClaudeCodeOnly sets the "claude_code_only" field if the given value is not nil.
-func (_u *GroupUpdate) SetNillableClaudeCodeOnly(v *bool) *GroupUpdate {
-	if v != nil {
-		_u.SetClaudeCodeOnly(*v)
-	}
-	return _u
-}
-
-// SetFallbackGroupID sets the "fallback_group_id" field.
-func (_u *GroupUpdate) SetFallbackGroupID(v int64) *GroupUpdate {
-	_u.mutation.ResetFallbackGroupID()
-	_u.mutation.SetFallbackGroupID(v)
-	return _u
-}
-
-// SetNillableFallbackGroupID sets the "fallback_group_id" field if the given value is not nil.
-func (_u *GroupUpdate) SetNillableFallbackGroupID(v *int64) *GroupUpdate {
-	if v != nil {
-		_u.SetFallbackGroupID(*v)
-	}
-	return _u
-}
-
-// AddFallbackGroupID adds value to the "fallback_group_id" field.
-func (_u *GroupUpdate) AddFallbackGroupID(v int64) *GroupUpdate {
-	_u.mutation.AddFallbackGroupID(v)
-	return _u
-}
-
-// ClearFallbackGroupID clears the value of the "fallback_group_id" field.
-func (_u *GroupUpdate) ClearFallbackGroupID() *GroupUpdate {
-	_u.mutation.ClearFallbackGroupID()
-	return _u
-}
-
-// SetModelRouting sets the "model_routing" field.
-func (_u *GroupUpdate) SetModelRouting(v map[string][]int64) *GroupUpdate {
-	_u.mutation.SetModelRouting(v)
-	return _u
-}
-
-// ClearModelRouting clears the value of the "model_routing" field.
-func (_u *GroupUpdate) ClearModelRouting() *GroupUpdate {
-	_u.mutation.ClearModelRouting()
-	return _u
-}
-
-// SetModelRoutingEnabled sets the "model_routing_enabled" field.
-func (_u *GroupUpdate) SetModelRoutingEnabled(v bool) *GroupUpdate {
-	_u.mutation.SetModelRoutingEnabled(v)
-	return _u
-}
-
-// SetNillableModelRoutingEnabled sets the "model_routing_enabled" field if the given value is not nil.
-func (_u *GroupUpdate) SetNillableModelRoutingEnabled(v *bool) *GroupUpdate {
-	if v != nil {
-		_u.SetModelRoutingEnabled(*v)
-	}
-	return _u
-}
-
-// AddAPIKeyIDs adds the "api_keys" edge to the APIKey entity by IDs.
+// AddAPIKeyIDs adds the "api_keys" edge to the ApiKey entity by IDs.
 func (_u *GroupUpdate) AddAPIKeyIDs(ids ...int64) *GroupUpdate {
 	_u.mutation.AddAPIKeyIDs(ids...)
 	return _u
 }
 
-// AddAPIKeys adds the "api_keys" edges to the APIKey entity.
-func (_u *GroupUpdate) AddAPIKeys(v ...*APIKey) *GroupUpdate {
+// AddAPIKeys adds the "api_keys" edges to the ApiKey entity.
+func (_u *GroupUpdate) AddAPIKeys(v ...*ApiKey) *GroupUpdate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -516,20 +368,20 @@ func (_u *GroupUpdate) Mutation() *GroupMutation {
 	return _u.mutation
 }
 
-// ClearAPIKeys clears all "api_keys" edges to the APIKey entity.
+// ClearAPIKeys clears all "api_keys" edges to the ApiKey entity.
 func (_u *GroupUpdate) ClearAPIKeys() *GroupUpdate {
 	_u.mutation.ClearAPIKeys()
 	return _u
 }
 
-// RemoveAPIKeyIDs removes the "api_keys" edge to APIKey entities by IDs.
+// RemoveAPIKeyIDs removes the "api_keys" edge to ApiKey entities by IDs.
 func (_u *GroupUpdate) RemoveAPIKeyIDs(ids ...int64) *GroupUpdate {
 	_u.mutation.RemoveAPIKeyIDs(ids...)
 	return _u
 }
 
-// RemoveAPIKeys removes "api_keys" edges to APIKey entities.
-func (_u *GroupUpdate) RemoveAPIKeys(v ...*APIKey) *GroupUpdate {
+// RemoveAPIKeys removes "api_keys" edges to ApiKey entities.
+func (_u *GroupUpdate) RemoveAPIKeys(v ...*ApiKey) *GroupUpdate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -790,54 +642,6 @@ func (_u *GroupUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.AddedDefaultValidityDays(); ok {
 		_spec.AddField(group.FieldDefaultValidityDays, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.ImagePrice1k(); ok {
-		_spec.SetField(group.FieldImagePrice1k, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedImagePrice1k(); ok {
-		_spec.AddField(group.FieldImagePrice1k, field.TypeFloat64, value)
-	}
-	if _u.mutation.ImagePrice1kCleared() {
-		_spec.ClearField(group.FieldImagePrice1k, field.TypeFloat64)
-	}
-	if value, ok := _u.mutation.ImagePrice2k(); ok {
-		_spec.SetField(group.FieldImagePrice2k, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedImagePrice2k(); ok {
-		_spec.AddField(group.FieldImagePrice2k, field.TypeFloat64, value)
-	}
-	if _u.mutation.ImagePrice2kCleared() {
-		_spec.ClearField(group.FieldImagePrice2k, field.TypeFloat64)
-	}
-	if value, ok := _u.mutation.ImagePrice4k(); ok {
-		_spec.SetField(group.FieldImagePrice4k, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedImagePrice4k(); ok {
-		_spec.AddField(group.FieldImagePrice4k, field.TypeFloat64, value)
-	}
-	if _u.mutation.ImagePrice4kCleared() {
-		_spec.ClearField(group.FieldImagePrice4k, field.TypeFloat64)
-	}
-	if value, ok := _u.mutation.ClaudeCodeOnly(); ok {
-		_spec.SetField(group.FieldClaudeCodeOnly, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.FallbackGroupID(); ok {
-		_spec.SetField(group.FieldFallbackGroupID, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedFallbackGroupID(); ok {
-		_spec.AddField(group.FieldFallbackGroupID, field.TypeInt64, value)
-	}
-	if _u.mutation.FallbackGroupIDCleared() {
-		_spec.ClearField(group.FieldFallbackGroupID, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.ModelRouting(); ok {
-		_spec.SetField(group.FieldModelRouting, field.TypeJSON, value)
-	}
-	if _u.mutation.ModelRoutingCleared() {
-		_spec.ClearField(group.FieldModelRouting, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.ModelRoutingEnabled(); ok {
-		_spec.SetField(group.FieldModelRoutingEnabled, field.TypeBool, value)
-	}
 	if _u.mutation.APIKeysCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
@@ -1391,162 +1195,14 @@ func (_u *GroupUpdateOne) AddDefaultValidityDays(v int) *GroupUpdateOne {
 	return _u
 }
 
-// SetImagePrice1k sets the "image_price_1k" field.
-func (_u *GroupUpdateOne) SetImagePrice1k(v float64) *GroupUpdateOne {
-	_u.mutation.ResetImagePrice1k()
-	_u.mutation.SetImagePrice1k(v)
-	return _u
-}
-
-// SetNillableImagePrice1k sets the "image_price_1k" field if the given value is not nil.
-func (_u *GroupUpdateOne) SetNillableImagePrice1k(v *float64) *GroupUpdateOne {
-	if v != nil {
-		_u.SetImagePrice1k(*v)
-	}
-	return _u
-}
-
-// AddImagePrice1k adds value to the "image_price_1k" field.
-func (_u *GroupUpdateOne) AddImagePrice1k(v float64) *GroupUpdateOne {
-	_u.mutation.AddImagePrice1k(v)
-	return _u
-}
-
-// ClearImagePrice1k clears the value of the "image_price_1k" field.
-func (_u *GroupUpdateOne) ClearImagePrice1k() *GroupUpdateOne {
-	_u.mutation.ClearImagePrice1k()
-	return _u
-}
-
-// SetImagePrice2k sets the "image_price_2k" field.
-func (_u *GroupUpdateOne) SetImagePrice2k(v float64) *GroupUpdateOne {
-	_u.mutation.ResetImagePrice2k()
-	_u.mutation.SetImagePrice2k(v)
-	return _u
-}
-
-// SetNillableImagePrice2k sets the "image_price_2k" field if the given value is not nil.
-func (_u *GroupUpdateOne) SetNillableImagePrice2k(v *float64) *GroupUpdateOne {
-	if v != nil {
-		_u.SetImagePrice2k(*v)
-	}
-	return _u
-}
-
-// AddImagePrice2k adds value to the "image_price_2k" field.
-func (_u *GroupUpdateOne) AddImagePrice2k(v float64) *GroupUpdateOne {
-	_u.mutation.AddImagePrice2k(v)
-	return _u
-}
-
-// ClearImagePrice2k clears the value of the "image_price_2k" field.
-func (_u *GroupUpdateOne) ClearImagePrice2k() *GroupUpdateOne {
-	_u.mutation.ClearImagePrice2k()
-	return _u
-}
-
-// SetImagePrice4k sets the "image_price_4k" field.
-func (_u *GroupUpdateOne) SetImagePrice4k(v float64) *GroupUpdateOne {
-	_u.mutation.ResetImagePrice4k()
-	_u.mutation.SetImagePrice4k(v)
-	return _u
-}
-
-// SetNillableImagePrice4k sets the "image_price_4k" field if the given value is not nil.
-func (_u *GroupUpdateOne) SetNillableImagePrice4k(v *float64) *GroupUpdateOne {
-	if v != nil {
-		_u.SetImagePrice4k(*v)
-	}
-	return _u
-}
-
-// AddImagePrice4k adds value to the "image_price_4k" field.
-func (_u *GroupUpdateOne) AddImagePrice4k(v float64) *GroupUpdateOne {
-	_u.mutation.AddImagePrice4k(v)
-	return _u
-}
-
-// ClearImagePrice4k clears the value of the "image_price_4k" field.
-func (_u *GroupUpdateOne) ClearImagePrice4k() *GroupUpdateOne {
-	_u.mutation.ClearImagePrice4k()
-	return _u
-}
-
-// SetClaudeCodeOnly sets the "claude_code_only" field.
-func (_u *GroupUpdateOne) SetClaudeCodeOnly(v bool) *GroupUpdateOne {
-	_u.mutation.SetClaudeCodeOnly(v)
-	return _u
-}
-
-// SetNillableClaudeCodeOnly sets the "claude_code_only" field if the given value is not nil.
-func (_u *GroupUpdateOne) SetNillableClaudeCodeOnly(v *bool) *GroupUpdateOne {
-	if v != nil {
-		_u.SetClaudeCodeOnly(*v)
-	}
-	return _u
-}
-
-// SetFallbackGroupID sets the "fallback_group_id" field.
-func (_u *GroupUpdateOne) SetFallbackGroupID(v int64) *GroupUpdateOne {
-	_u.mutation.ResetFallbackGroupID()
-	_u.mutation.SetFallbackGroupID(v)
-	return _u
-}
-
-// SetNillableFallbackGroupID sets the "fallback_group_id" field if the given value is not nil.
-func (_u *GroupUpdateOne) SetNillableFallbackGroupID(v *int64) *GroupUpdateOne {
-	if v != nil {
-		_u.SetFallbackGroupID(*v)
-	}
-	return _u
-}
-
-// AddFallbackGroupID adds value to the "fallback_group_id" field.
-func (_u *GroupUpdateOne) AddFallbackGroupID(v int64) *GroupUpdateOne {
-	_u.mutation.AddFallbackGroupID(v)
-	return _u
-}
-
-// ClearFallbackGroupID clears the value of the "fallback_group_id" field.
-func (_u *GroupUpdateOne) ClearFallbackGroupID() *GroupUpdateOne {
-	_u.mutation.ClearFallbackGroupID()
-	return _u
-}
-
-// SetModelRouting sets the "model_routing" field.
-func (_u *GroupUpdateOne) SetModelRouting(v map[string][]int64) *GroupUpdateOne {
-	_u.mutation.SetModelRouting(v)
-	return _u
-}
-
-// ClearModelRouting clears the value of the "model_routing" field.
-func (_u *GroupUpdateOne) ClearModelRouting() *GroupUpdateOne {
-	_u.mutation.ClearModelRouting()
-	return _u
-}
-
-// SetModelRoutingEnabled sets the "model_routing_enabled" field.
-func (_u *GroupUpdateOne) SetModelRoutingEnabled(v bool) *GroupUpdateOne {
-	_u.mutation.SetModelRoutingEnabled(v)
-	return _u
-}
-
-// SetNillableModelRoutingEnabled sets the "model_routing_enabled" field if the given value is not nil.
-func (_u *GroupUpdateOne) SetNillableModelRoutingEnabled(v *bool) *GroupUpdateOne {
-	if v != nil {
-		_u.SetModelRoutingEnabled(*v)
-	}
-	return _u
-}
-
-// AddAPIKeyIDs adds the "api_keys" edge to the APIKey entity by IDs.
+// AddAPIKeyIDs adds the "api_keys" edge to the ApiKey entity by IDs.
 func (_u *GroupUpdateOne) AddAPIKeyIDs(ids ...int64) *GroupUpdateOne {
 	_u.mutation.AddAPIKeyIDs(ids...)
 	return _u
 }
 
-// AddAPIKeys adds the "api_keys" edges to the APIKey entity.
-func (_u *GroupUpdateOne) AddAPIKeys(v ...*APIKey) *GroupUpdateOne {
+// AddAPIKeys adds the "api_keys" edges to the ApiKey entity.
+func (_u *GroupUpdateOne) AddAPIKeys(v ...*ApiKey) *GroupUpdateOne {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -1634,20 +1290,20 @@ func (_u *GroupUpdateOne) Mutation() *GroupMutation {
 	return _u.mutation
 }
 
-// ClearAPIKeys clears all "api_keys" edges to the APIKey entity.
+// ClearAPIKeys clears all "api_keys" edges to the ApiKey entity.
 func (_u *GroupUpdateOne) ClearAPIKeys() *GroupUpdateOne {
 	_u.mutation.ClearAPIKeys()
 	return _u
 }
 
-// RemoveAPIKeyIDs removes the "api_keys" edge to APIKey entities by IDs.
+// RemoveAPIKeyIDs removes the "api_keys" edge to ApiKey entities by IDs.
 func (_u *GroupUpdateOne) RemoveAPIKeyIDs(ids ...int64) *GroupUpdateOne {
 	_u.mutation.RemoveAPIKeyIDs(ids...)
 	return _u
 }
 
-// RemoveAPIKeys removes "api_keys" edges to APIKey entities.
-func (_u *GroupUpdateOne) RemoveAPIKeys(v ...*APIKey) *GroupUpdateOne {
+// RemoveAPIKeys removes "api_keys" edges to ApiKey entities.
+func (_u *GroupUpdateOne) RemoveAPIKeys(v ...*ApiKey) *GroupUpdateOne {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -1938,54 +1594,6 @@ func (_u *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error)
 	if value, ok := _u.mutation.AddedDefaultValidityDays(); ok {
 		_spec.AddField(group.FieldDefaultValidityDays, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.ImagePrice1k(); ok {
-		_spec.SetField(group.FieldImagePrice1k, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedImagePrice1k(); ok {
-		_spec.AddField(group.FieldImagePrice1k, field.TypeFloat64, value)
-	}
-	if _u.mutation.ImagePrice1kCleared() {
-		_spec.ClearField(group.FieldImagePrice1k, field.TypeFloat64)
-	}
-	if value, ok := _u.mutation.ImagePrice2k(); ok {
-		_spec.SetField(group.FieldImagePrice2k, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedImagePrice2k(); ok {
-		_spec.AddField(group.FieldImagePrice2k, field.TypeFloat64, value)
-	}
-	if _u.mutation.ImagePrice2kCleared() {
-		_spec.ClearField(group.FieldImagePrice2k, field.TypeFloat64)
-	}
-	if value, ok := _u.mutation.ImagePrice4k(); ok {
-		_spec.SetField(group.FieldImagePrice4k, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedImagePrice4k(); ok {
-		_spec.AddField(group.FieldImagePrice4k, field.TypeFloat64, value)
-	}
-	if _u.mutation.ImagePrice4kCleared() {
-		_spec.ClearField(group.FieldImagePrice4k, field.TypeFloat64)
-	}
-	if value, ok := _u.mutation.ClaudeCodeOnly(); ok {
-		_spec.SetField(group.FieldClaudeCodeOnly, field.TypeBool, value)
-	}
-	if value, ok := _u.mutation.FallbackGroupID(); ok {
-		_spec.SetField(group.FieldFallbackGroupID, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedFallbackGroupID(); ok {
-		_spec.AddField(group.FieldFallbackGroupID, field.TypeInt64, value)
-	}
-	if _u.mutation.FallbackGroupIDCleared() {
-		_spec.ClearField(group.FieldFallbackGroupID, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.ModelRouting(); ok {
-		_spec.SetField(group.FieldModelRouting, field.TypeJSON, value)
-	}
-	if _u.mutation.ModelRoutingCleared() {
-		_spec.ClearField(group.FieldModelRouting, field.TypeJSON)
-	}
-	if value, ok := _u.mutation.ModelRoutingEnabled(); ok {
-		_spec.SetField(group.FieldModelRoutingEnabled, field.TypeBool, value)
-	}
 	if _u.mutation.APIKeysCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,

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,6 +33,18 @@ 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 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 GroupFunc type is an adapter to allow the use of ordinary
 // function as Group mutator.
 type GroupFunc func(context.Context, *ent.GroupMutation) (ent.Value, error)
@@ -57,30 +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 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)
@@ -117,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)
@@ -165,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/intercept/intercept.go

@@ -13,17 +13,12 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
 	"github.com/Wei-Shaw/sub2api/ent/group"
 	"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/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"
 )
 
@@ -83,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)
 
@@ -164,6 +132,33 @@ func (f TraverseAccountGroup) Traverse(ctx context.Context, q ent.Query) error {
 	return fmt.Errorf("unexpected query type %T. expect *ent.AccountGroupQuery", q)
 }
 
+// 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 GroupFunc type is an adapter to allow the use of ordinary function as a Querier.
 type GroupFunc func(context.Context, *ent.GroupQuery) (ent.Value, error)
 
@@ -191,60 +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 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)
 
@@ -326,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)
 
@@ -434,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)
 
@@ -518,36 +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.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.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.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,62 +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: "ip_whitelist", Type: field.TypeJSON, Nullable: true},
-		{Name: "ip_blacklist", Type: field.TypeJSON, 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[9]},
-				RefColumns: []*schema.Column{GroupsColumns[0]},
-				OnDelete:   schema.SetNull,
-			},
-			{
-				Symbol:     "api_keys_users_api_keys",
-				Columns:    []*schema.Column{APIKeysColumns[10]},
-				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
-		},
-		Indexes: []*schema.Index{
-			{
-				Name:    "apikey_user_id",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[10]},
-			},
-			{
-				Name:    "apikey_group_id",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[9]},
-			},
-			{
-				Name:    "apikey_status",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[6]},
-			},
-			{
-				Name:    "apikey_deleted_at",
-				Unique:  false,
-				Columns: []*schema.Column{APIKeysColumns[3]},
-			},
-		},
-	}
 	// AccountsColumns holds the columns for the "accounts" table.
 	AccountsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
@@ -72,19 +16,15 @@ 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: "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"}},
@@ -102,7 +42,7 @@ var (
 		ForeignKeys: []*schema.ForeignKey{
 			{
 				Symbol:     "accounts_proxies_proxy",
-				Columns:    []*schema.Column{AccountsColumns[25]},
+				Columns:    []*schema.Column{AccountsColumns[21]},
 				RefColumns: []*schema.Column{ProxiesColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
@@ -111,52 +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[13]},
+				Columns: []*schema.Column{AccountsColumns[11]},
 			},
 			{
 				Name:    "account_proxy_id",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[25]},
+				Columns: []*schema.Column{AccountsColumns[21]},
 			},
 			{
 				Name:    "account_priority",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[11]},
+				Columns: []*schema.Column{AccountsColumns[10]},
 			},
 			{
 				Name:    "account_last_used_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[15]},
+				Columns: []*schema.Column{AccountsColumns[13]},
 			},
 			{
 				Name:    "account_schedulable",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[18]},
+				Columns: []*schema.Column{AccountsColumns[14]},
 			},
 			{
 				Name:    "account_rate_limited_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[19]},
+				Columns: []*schema.Column{AccountsColumns[15]},
 			},
 			{
 				Name:    "account_rate_limit_reset_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[20]},
+				Columns: []*schema.Column{AccountsColumns[16]},
 			},
 			{
 				Name:    "account_overload_until",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[21]},
+				Columns: []*schema.Column{AccountsColumns[17]},
 			},
 			{
 				Name:    "account_deleted_at",
@@ -204,6 +144,60 @@ 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: "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[7]},
+				RefColumns: []*schema.Column{GroupsColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+			{
+				Symbol:     "api_keys_users_api_keys",
+				Columns:    []*schema.Column{APIKeysColumns[8]},
+				RefColumns: []*schema.Column{UsersColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "apikey_user_id",
+				Unique:  false,
+				Columns: []*schema.Column{APIKeysColumns[8]},
+			},
+			{
+				Name:    "apikey_group_id",
+				Unique:  false,
+				Columns: []*schema.Column{APIKeysColumns[7]},
+			},
+			{
+				Name:    "apikey_status",
+				Unique:  false,
+				Columns: []*schema.Column{APIKeysColumns[6]},
+			},
+			{
+				Name:    "apikey_deleted_at",
+				Unique:  false,
+				Columns: []*schema.Column{APIKeysColumns[3]},
+			},
+		},
+	}
 	// GroupsColumns holds the columns for the "groups" table.
 	GroupsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
@@ -221,13 +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: "claude_code_only", Type: field.TypeBool, Default: false},
-		{Name: "fallback_group_id", 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},
 	}
 	// GroupsTable holds the schema information for the "groups" table.
 	GroupsTable = &schema.Table{
@@ -262,82 +249,6 @@ var (
 			},
 		},
 	}
-	// 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.
 	ProxiesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt64, Increment: true},
@@ -434,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},
@@ -490,18 +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: "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},
@@ -512,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[26]},
-				RefColumns: []*schema.Column{APIKeysColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
 			{
 				Symbol:     "usage_logs_accounts_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[27]},
+				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[28]},
+				Columns:    []*schema.Column{UsageLogsColumns[23]},
 				RefColumns: []*schema.Column{GroupsColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
 			{
 				Symbol:     "usage_logs_users_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[29]},
+				Columns:    []*schema.Column{UsageLogsColumns[24]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
 			{
 				Symbol:     "usage_logs_user_subscriptions_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[30]},
+				Columns:    []*schema.Column{UsageLogsColumns[25]},
 				RefColumns: []*schema.Column{UserSubscriptionsColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
@@ -547,32 +415,32 @@ var (
 			{
 				Name:    "usagelog_user_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[29]},
+				Columns: []*schema.Column{UsageLogsColumns[24]},
 			},
 			{
 				Name:    "usagelog_api_key_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[26]},
+				Columns: []*schema.Column{UsageLogsColumns[22]},
 			},
 			{
 				Name:    "usagelog_account_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[27]},
+				Columns: []*schema.Column{UsageLogsColumns[21]},
 			},
 			{
 				Name:    "usagelog_group_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[28]},
+				Columns: []*schema.Column{UsageLogsColumns[23]},
 			},
 			{
 				Name:    "usagelog_subscription_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[30]},
+				Columns: []*schema.Column{UsageLogsColumns[25]},
 			},
 			{
 				Name:    "usagelog_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[25]},
+				Columns: []*schema.Column{UsageLogsColumns[20]},
 			},
 			{
 				Name:    "usagelog_model",
@@ -587,12 +455,12 @@ var (
 			{
 				Name:    "usagelog_user_id_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[29], UsageLogsColumns[25]},
+				Columns: []*schema.Column{UsageLogsColumns[24], UsageLogsColumns[20]},
 			},
 			{
 				Name:    "usagelog_api_key_id_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[26], UsageLogsColumns[25]},
+				Columns: []*schema.Column{UsageLogsColumns[22], UsageLogsColumns[20]},
 			},
 		},
 	}
@@ -609,6 +477,7 @@ 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"}},
 	}
 	// UsersTable holds the schema information for the "users" table.
@@ -662,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},
@@ -834,31 +617,21 @@ var (
 	}
 	// Tables holds all the tables in the schema.
 	Tables = []*schema.Table{
-		APIKeysTable,
 		AccountsTable,
 		AccountGroupsTable,
+		APIKeysTable,
 		GroupsTable,
-		PromoCodesTable,
-		PromoCodeUsagesTable,
 		ProxiesTable,
 		RedeemCodesTable,
 		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",
@@ -868,17 +641,14 @@ func init() {
 	AccountGroupsTable.Annotation = &entsql.Annotation{
 		Table: "account_groups",
 	}
+	APIKeysTable.ForeignKeys[0].RefTable = GroupsTable
+	APIKeysTable.ForeignKeys[1].RefTable = UsersTable
+	APIKeysTable.Annotation = &entsql.Annotation{
+		Table: "api_keys",
+	}
 	GroupsTable.Annotation = &entsql.Annotation{
 		Table: "groups",
 	}
-	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",
 	}
@@ -890,11 +660,8 @@ func init() {
 	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
@@ -909,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,24 +6,18 @@ 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)
 
+// 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)
 
-// 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)
 
@@ -33,9 +27,6 @@ type RedeemCode 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)
 
@@ -45,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

@@ -9,18 +9,13 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/accountgroup"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
 	"github.com/Wei-Shaw/sub2api/ent/group"
-	"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/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"
 )
 
@@ -28,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()
@@ -89,127 +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)
-	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[8].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[9].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[10].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[14].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[15].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[21].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)
 	groupMixin := schema.Group{}.Mixin()
 	groupMixinHooks1 := groupMixin[1].Hooks()
 	group.Hooks[0] = groupMixinHooks1[0]
@@ -277,68 +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)
-	// groupDescClaudeCodeOnly is the schema descriptor for claude_code_only field.
-	groupDescClaudeCodeOnly := groupFields[14].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[17].Descriptor()
-	// group.DefaultModelRoutingEnabled holds the default value on creation for the model_routing_enabled field.
-	group.DefaultModelRoutingEnabled = groupDescModelRoutingEnabled.Default.(bool)
-	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]
@@ -496,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.
@@ -624,31 +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)
 	// usagelogDescCreatedAt is the schema descriptor for created_at field.
-	usagelogDescCreatedAt := usagelogFields[29].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()
@@ -732,8 +604,14 @@ 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)
 	userallowedgroupFields := schema.UserAllowedGroup{}.Fields()
@@ -742,128 +620,6 @@ func init() {
 	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

@@ -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").
@@ -102,12 +97,6 @@ func (Account) Fields() []ent.Field {
 		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).
@@ -124,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 中添加

backend/ent/schema/api_key.go

@@ -12,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,16 +46,10 @@ func (APIKey) Fields() []ent.Field {
 		field.String("status").
 			MaxLen(20).
 			Default(service.StatusActive),
-		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"),
 	}
 }
 
-func (APIKey) Edges() []ent.Edge {
+func (ApiKey) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.From("user", User.Type).
 			Ref("api_keys").
@@ -70,7 +64,7 @@ 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"),

backend/ent/schema/group.go

@@ -72,46 +72,12 @@ func (Group) Fields() []ent.Field {
 			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}),
 		field.Int("default_validity_days").
 			Default(30),
-
-		// 图片生成计费配置（antigravity 和 gemini 平台使用）
-		field.Float("image_price_1k").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}),
-		field.Float("image_price_2k").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}),
-		field.Float("image_price_4k").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}),
-
-		// Claude Code 客户端限制 (added by migration 029)
-		field.Bool("claude_code_only").
-			Default(false).
-			Comment("是否仅允许 Claude Code 客户端"),
-		field.Int64("fallback_group_id").
-			Optional().
-			Nillable().
-			Comment("非 Claude Code 请求降级使用的分组 ID"),
-
-		// 模型路由配置 (added by migration 040)
-		field.JSON("model_routing", map[string][]int64{}).
-			Optional().
-			SchemaType(map[string]string{dialect.Postgres: "jsonb"}).
-			Comment("模型路由配置：模型模式 -> 优先账号ID列表"),
-
-		// 模型路由开关 (added by migration 041)
-		field.Bool("model_routing_enabled").
-			Default(false).
-			Comment("是否启用模型路由配置"),
 	}
 }
 
 func (Group) Edges() []ent.Edge {
 	return []ent.Edge{
-		edge.To("api_keys", APIKey.Type),
+		edge.To("api_keys", ApiKey.Type),
 		edge.To("redeem_codes", RedeemCode.Type),
 		edge.To("subscriptions", UserSubscription.Type),
 		edge.To("usage_logs", UsageLog.Type),
@@ -121,8 +87,6 @@ func (Group) Edges() []ent.Edge {
 		edge.From("allowed_users", User.Type).
 			Ref("allowed_groups").
 			Through("user_allowed_groups", UserAllowedGroup.Type),
-		// 注意：fallback_group_id 直接作为字段使用，不定义 edge
-		// 这样允许多个分组指向同一个降级分组（M2O 关系）
 	}
 }
 

backend/ent/schema/mixins/soft_delete.go

@@ -5,7 +5,6 @@ package mixins
 import (
 	"context"
 	"fmt"
-	"reflect"
 	"time"
 
 	"entgo.io/ent"
@@ -13,6 +12,7 @@ import (
 	"entgo.io/ent/dialect/sql"
 	"entgo.io/ent/schema/field"
 	"entgo.io/ent/schema/mixin"
+	dbent "github.com/Wei-Shaw/sub2api/ent"
 	"github.com/Wei-Shaw/sub2api/ent/intercept"
 )
 
@@ -113,6 +113,7 @@ func (d SoftDeleteMixin) Hooks() []ent.Hook {
 					SetOp(ent.Op)
 					SetDeletedAt(time.Time)
 					WhereP(...func(*sql.Selector))
+					Client() *dbent.Client
 				})
 				if !ok {
 					return nil, fmt.Errorf("unexpected mutation type %T", m)
@@ -123,7 +124,7 @@ func (d SoftDeleteMixin) Hooks() []ent.Hook {
 				mx.SetOp(ent.OpUpdate)
 				// 设置删除时间为当前时间
 				mx.SetDeletedAt(time.Now())
-				return mutateWithClient(ctx, m, next)
+				return mx.Client().Mutate(ctx, m)
 			})
 		},
 	}
@@ -136,41 +137,3 @@ func (d SoftDeleteMixin) applyPredicate(w interface{ WhereP(...func(*sql.Selecto
 		sql.FieldIsNull(d.Fields()[0].Descriptor().Name),
 	)
 }
-
-func mutateWithClient(ctx context.Context, m ent.Mutation, fallback ent.Mutator) (ent.Value, error) {
-	clientMethod := reflect.ValueOf(m).MethodByName("Client")
-	if !clientMethod.IsValid() || clientMethod.Type().NumIn() != 0 || clientMethod.Type().NumOut() != 1 {
-		return nil, fmt.Errorf("soft delete: mutation client method not found for %T", m)
-	}
-	client := clientMethod.Call(nil)[0]
-	mutateMethod := client.MethodByName("Mutate")
-	if !mutateMethod.IsValid() {
-		return nil, fmt.Errorf("soft delete: mutation client missing Mutate for %T", m)
-	}
-	if mutateMethod.Type().NumIn() != 2 || mutateMethod.Type().NumOut() != 2 {
-		return nil, fmt.Errorf("soft delete: mutation client signature mismatch for %T", m)
-	}
-
-	results := mutateMethod.Call([]reflect.Value{reflect.ValueOf(ctx), reflect.ValueOf(m)})
-	value := results[0].Interface()
-	var err error
-	if !results[1].IsNil() {
-		errValue := results[1].Interface()
-		typedErr, ok := errValue.(error)
-		if !ok {
-			return nil, fmt.Errorf("soft delete: unexpected error type %T for %T", errValue, m)
-		}
-		err = typedErr
-	}
-	if err != nil {
-		return nil, err
-	}
-	if value == nil {
-		return nil, fmt.Errorf("soft delete: mutation client returned nil for %T", m)
-	}
-	v, ok := value.(ent.Value)
-	if !ok {
-		return nil, fmt.Errorf("soft delete: unexpected value type %T for %T", value, m)
-	}
-	return v, nil
-}

backend/ent/schema/promo_code.go

@@ -1,87 +0,0 @@
-package schema
-
-import (
-	"time"
-
-	"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"
-	"entgo.io/ent/schema/field"
-	"entgo.io/ent/schema/index"
-)
-
-// PromoCode holds the schema definition for the PromoCode entity.
-//
-// 注册优惠码：用户注册时使用，可获得赠送余额
-// 与 RedeemCode 不同，PromoCode 支持多次使用（有使用次数限制）
-//
-// 删除策略：硬删除
-type PromoCode struct {
-	ent.Schema
-}
-
-func (PromoCode) Annotations() []schema.Annotation {
-	return []schema.Annotation{
-		entsql.Annotation{Table: "promo_codes"},
-	}
-}
-
-func (PromoCode) Fields() []ent.Field {
-	return []ent.Field{
-		field.String("code").
-			MaxLen(32).
-			NotEmpty().
-			Unique().
-			Comment("优惠码"),
-		field.Float("bonus_amount").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Default(0).
-			Comment("赠送余额金额"),
-		field.Int("max_uses").
-			Default(0).
-			Comment("最大使用次数，0表示无限制"),
-		field.Int("used_count").
-			Default(0).
-			Comment("已使用次数"),
-		field.String("status").
-			MaxLen(20).
-			Default(service.PromoCodeStatusActive).
-			Comment("状态: active, disabled"),
-		field.Time("expires_at").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}).
-			Comment("过期时间，null表示永不过期"),
-		field.String("notes").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "text"}).
-			Comment("备注"),
-		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 (PromoCode) Edges() []ent.Edge {
-	return []ent.Edge{
-		edge.To("usage_records", PromoCodeUsage.Type),
-	}
-}
-
-func (PromoCode) Indexes() []ent.Index {
-	return []ent.Index{
-		// code 字段已在 Fields() 中声明 Unique()，无需重复索引
-		index.Fields("status"),
-		index.Fields("expires_at"),
-	}
-}

backend/ent/schema/promo_code_usage.go

@@ -1,66 +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"
-)
-
-// PromoCodeUsage holds the schema definition for the PromoCodeUsage entity.
-//
-// 优惠码使用记录：记录每个用户使用优惠码的情况
-type PromoCodeUsage struct {
-	ent.Schema
-}
-
-func (PromoCodeUsage) Annotations() []schema.Annotation {
-	return []schema.Annotation{
-		entsql.Annotation{Table: "promo_code_usages"},
-	}
-}
-
-func (PromoCodeUsage) Fields() []ent.Field {
-	return []ent.Field{
-		field.Int64("promo_code_id").
-			Comment("优惠码ID"),
-		field.Int64("user_id").
-			Comment("使用用户ID"),
-		field.Float("bonus_amount").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(20,8)"}).
-			Comment("实际赠送金额"),
-		field.Time("used_at").
-			Default(time.Now).
-			SchemaType(map[string]string{dialect.Postgres: "timestamptz"}).
-			Comment("使用时间"),
-	}
-}
-
-func (PromoCodeUsage) Edges() []ent.Edge {
-	return []ent.Edge{
-		edge.From("promo_code", PromoCode.Type).
-			Ref("usage_records").
-			Field("promo_code_id").
-			Required().
-			Unique(),
-		edge.From("user", User.Type).
-			Ref("promo_code_usages").
-			Field("user_id").
-			Required().
-			Unique(),
-	}
-}
-
-func (PromoCodeUsage) Indexes() []ent.Index {
-	return []ent.Index{
-		index.Fields("promo_code_id"),
-		index.Fields("user_id"),
-		// 每个用户每个优惠码只能使用一次
-		index.Fields("promo_code_id", "user_id").Unique(),
-	}
-}

backend/ent/schema/usage_cleanup_task.go

@@ -1,75 +0,0 @@
-package schema
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/Wei-Shaw/sub2api/ent/schema/mixins"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/entsql"
-	"entgo.io/ent/schema"
-	"entgo.io/ent/schema/field"
-	"entgo.io/ent/schema/index"
-)
-
-// UsageCleanupTask 定义使用记录清理任务的 schema。
-type UsageCleanupTask struct {
-	ent.Schema
-}
-
-func (UsageCleanupTask) Annotations() []schema.Annotation {
-	return []schema.Annotation{
-		entsql.Annotation{Table: "usage_cleanup_tasks"},
-	}
-}
-
-func (UsageCleanupTask) Mixin() []ent.Mixin {
-	return []ent.Mixin{
-		mixins.TimeMixin{},
-	}
-}
-
-func (UsageCleanupTask) Fields() []ent.Field {
-	return []ent.Field{
-		field.String("status").
-			MaxLen(20).
-			Validate(validateUsageCleanupStatus),
-		field.JSON("filters", json.RawMessage{}),
-		field.Int64("created_by"),
-		field.Int64("deleted_rows").
-			Default(0),
-		field.String("error_message").
-			Optional().
-			Nillable(),
-		field.Int64("canceled_by").
-			Optional().
-			Nillable(),
-		field.Time("canceled_at").
-			Optional().
-			Nillable(),
-		field.Time("started_at").
-			Optional().
-			Nillable(),
-		field.Time("finished_at").
-			Optional().
-			Nillable(),
-	}
-}
-
-func (UsageCleanupTask) Indexes() []ent.Index {
-	return []ent.Index{
-		index.Fields("status", "created_at"),
-		index.Fields("created_at"),
-		index.Fields("canceled_at"),
-	}
-}
-
-func validateUsageCleanupStatus(status string) error {
-	switch status {
-	case "pending", "running", "succeeded", "failed", "canceled":
-		return nil
-	default:
-		return fmt.Errorf("invalid usage cleanup status: %s", status)
-	}
-}

backend/ent/schema/usage_log.go

@@ -85,12 +85,6 @@ func (UsageLog) Fields() []ent.Field {
 			Default(1).
 			SchemaType(map[string]string{dialect.Postgres: "decimal(10,4)"}),
 
-		// account_rate_multiplier: 账号计费倍率快照（NULL 表示按 1.0 处理）
-		field.Float("account_rate_multiplier").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "decimal(10,4)"}),
-
 		// 其他字段
 		field.Int8("billing_type").
 			Default(0),
@@ -102,22 +96,6 @@ func (UsageLog) Fields() []ent.Field {
 		field.Int("first_token_ms").
 			Optional().
 			Nillable(),
-		field.String("user_agent").
-			MaxLen(512).
-			Optional().
-			Nillable(),
-		field.String("ip_address").
-			MaxLen(45). // 支持 IPv6
-			Optional().
-			Nillable(),
-
-		// 图片生成字段（仅 gemini-3-pro-image 等图片模型使用）
-		field.Int("image_count").
-			Default(0),
-		field.String("image_size").
-			MaxLen(10).
-			Optional().
-			Nillable(),
 
 		// 时间戳（只有 created_at，日志不可修改）
 		field.Time("created_at").
@@ -135,7 +113,7 @@ func (UsageLog) Edges() []ent.Edge {
 			Field("user_id").
 			Required().
 			Unique(),
-		edge.From("api_key", APIKey.Type).
+		edge.From("api_key", ApiKey.Type).
 			Ref("usage_logs").
 			Field("api_key_id").
 			Required().

backend/ent/schema/user.go

@@ -57,7 +57,9 @@ func (User) Fields() []ent.Field {
 		field.String("username").
 			MaxLen(100).
 			Default(""),
-		// wechat field migrated to user_attribute_values (see migration 019)
+		field.String("wechat").
+			MaxLen(100).
+			Default(""),
 		field.String("notes").
 			SchemaType(map[string]string{dialect.Postgres: "text"}).
 			Default(""),
@@ -66,15 +68,13 @@ func (User) Fields() []ent.Field {
 
 func (User) Edges() []ent.Edge {
 	return []ent.Edge{
-		edge.To("api_keys", APIKey.Type),
+		edge.To("api_keys", ApiKey.Type),
 		edge.To("redeem_codes", RedeemCode.Type),
 		edge.To("subscriptions", UserSubscription.Type),
 		edge.To("assigned_subscriptions", UserSubscription.Type),
 		edge.To("allowed_groups", Group.Type).
 			Through("user_allowed_groups", UserAllowedGroup.Type),
 		edge.To("usage_logs", UsageLog.Type),
-		edge.To("attribute_values", UserAttributeValue.Type),
-		edge.To("promo_code_usages", PromoCodeUsage.Type),
 	}
 }
 

backend/ent/schema/user_attribute_definition.go

@@ -1,109 +0,0 @@
-package schema
-
-import (
-	"github.com/Wei-Shaw/sub2api/ent/schema/mixins"
-
-	"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"
-)
-
-// UserAttributeDefinition holds the schema definition for custom user attributes.
-//
-// This entity defines the metadata for user attributes, such as:
-//   - Attribute key (unique identifier like "company_name")
-//   - Display name shown in forms
-//   - Field type (text, number, select, etc.)
-//   - Validation rules
-//   - Whether the field is required or enabled
-type UserAttributeDefinition struct {
-	ent.Schema
-}
-
-func (UserAttributeDefinition) Annotations() []schema.Annotation {
-	return []schema.Annotation{
-		entsql.Annotation{Table: "user_attribute_definitions"},
-	}
-}
-
-func (UserAttributeDefinition) Mixin() []ent.Mixin {
-	return []ent.Mixin{
-		mixins.TimeMixin{},
-		mixins.SoftDeleteMixin{},
-	}
-}
-
-func (UserAttributeDefinition) Fields() []ent.Field {
-	return []ent.Field{
-		// key: Unique identifier for the attribute (e.g., "company_name")
-		// Used for programmatic reference
-		field.String("key").
-			MaxLen(100).
-			NotEmpty(),
-
-		// name: Display name shown in forms (e.g., "Company Name")
-		field.String("name").
-			MaxLen(255).
-			NotEmpty(),
-
-		// description: Optional description/help text for the attribute
-		field.String("description").
-			SchemaType(map[string]string{dialect.Postgres: "text"}).
-			Default(""),
-
-		// type: Attribute type - text, textarea, number, email, url, date, select, multi_select
-		field.String("type").
-			MaxLen(20).
-			NotEmpty(),
-
-		// options: Select options for select/multi_select types (stored as JSONB)
-		// Format: [{"value": "xxx", "label": "XXX"}, ...]
-		field.JSON("options", []map[string]any{}).
-			Default([]map[string]any{}).
-			SchemaType(map[string]string{dialect.Postgres: "jsonb"}),
-
-		// required: Whether this attribute is required when editing a user
-		field.Bool("required").
-			Default(false),
-
-		// validation: Validation rules for the attribute value (stored as JSONB)
-		// Format: {"min_length": 1, "max_length": 100, "min": 0, "max": 100, "pattern": "^[a-z]+$", "message": "..."}
-		field.JSON("validation", map[string]any{}).
-			Default(map[string]any{}).
-			SchemaType(map[string]string{dialect.Postgres: "jsonb"}),
-
-		// placeholder: Placeholder text shown in input fields
-		field.String("placeholder").
-			MaxLen(255).
-			Default(""),
-
-		// display_order: Order in which attributes are displayed (lower = first)
-		field.Int("display_order").
-			Default(0),
-
-		// enabled: Whether this attribute is active and shown in forms
-		field.Bool("enabled").
-			Default(true),
-	}
-}
-
-func (UserAttributeDefinition) Edges() []ent.Edge {
-	return []ent.Edge{
-		// values: All user values for this attribute definition
-		edge.To("values", UserAttributeValue.Type),
-	}
-}
-
-func (UserAttributeDefinition) Indexes() []ent.Index {
-	return []ent.Index{
-		// Partial unique index on key (WHERE deleted_at IS NULL) via migration
-		index.Fields("key"),
-		index.Fields("enabled"),
-		index.Fields("display_order"),
-		index.Fields("deleted_at"),
-	}
-}

backend/ent/schema/user_attribute_value.go

@@ -1,74 +0,0 @@
-package schema
-
-import (
-	"github.com/Wei-Shaw/sub2api/ent/schema/mixins"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/entsql"
-	"entgo.io/ent/schema"
-	"entgo.io/ent/schema/edge"
-	"entgo.io/ent/schema/field"
-	"entgo.io/ent/schema/index"
-)
-
-// UserAttributeValue holds a user's value for a specific attribute.
-//
-// This entity stores the actual values that users have for each attribute definition.
-// Values are stored as strings and converted to the appropriate type by the application.
-type UserAttributeValue struct {
-	ent.Schema
-}
-
-func (UserAttributeValue) Annotations() []schema.Annotation {
-	return []schema.Annotation{
-		entsql.Annotation{Table: "user_attribute_values"},
-	}
-}
-
-func (UserAttributeValue) Mixin() []ent.Mixin {
-	return []ent.Mixin{
-		// Only use TimeMixin, no soft delete - values are hard deleted
-		mixins.TimeMixin{},
-	}
-}
-
-func (UserAttributeValue) Fields() []ent.Field {
-	return []ent.Field{
-		// user_id: References the user this value belongs to
-		field.Int64("user_id"),
-
-		// attribute_id: References the attribute definition
-		field.Int64("attribute_id"),
-
-		// value: The actual value stored as a string
-		// For multi_select, this is a JSON array string
-		field.Text("value").
-			Default(""),
-	}
-}
-
-func (UserAttributeValue) Edges() []ent.Edge {
-	return []ent.Edge{
-		// user: The user who owns this attribute value
-		edge.From("user", User.Type).
-			Ref("attribute_values").
-			Field("user_id").
-			Required().
-			Unique(),
-
-		// definition: The attribute definition this value is for
-		edge.From("definition", UserAttributeDefinition.Type).
-			Ref("values").
-			Field("attribute_id").
-			Required().
-			Unique(),
-	}
-}
-
-func (UserAttributeValue) Indexes() []ent.Index {
-	return []ent.Index{
-		// Unique index on (user_id, attribute_id)
-		index.Fields("user_id", "attribute_id").Unique(),
-		index.Fields("attribute_id"),
-	}
-}

backend/ent/setting_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"
@@ -23,7 +22,6 @@ type SettingQuery struct {
 	order      []setting.OrderOption
 	inters     []Interceptor
 	predicates []predicate.Setting
-	modifiers  []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -345,9 +343,6 @@ func (_q *SettingQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Sett
 		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)
 	}
@@ -362,9 +357,6 @@ func (_q *SettingQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Sett
 
 func (_q *SettingQuery) 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
@@ -427,9 +419,6 @@ func (_q *SettingQuery) 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)
 	}
@@ -447,32 +436,6 @@ func (_q *SettingQuery) 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 *SettingQuery) ForUpdate(opts ...sql.LockOption) *SettingQuery {
-	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 *SettingQuery) ForShare(opts ...sql.LockOption) *SettingQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // SettingGroupBy is the group-by builder for Setting entities.
 type SettingGroupBy struct {
 	selector

backend/ent/tx.go

@@ -14,36 +14,26 @@ import (
 // Tx is a transactional client that is created by calling Client.Tx().
 type Tx struct {
 	config
-	// APIKey is the client for interacting with the APIKey builders.
-	APIKey *APIKeyClient
 	// Account is the client for interacting with the Account builders.
 	Account *AccountClient
 	// AccountGroup is the client for interacting with the AccountGroup builders.
 	AccountGroup *AccountGroupClient
+	// ApiKey is the client for interacting with the ApiKey builders.
+	ApiKey *ApiKeyClient
 	// Group is the client for interacting with the Group builders.
 	Group *GroupClient
-	// PromoCode is the client for interacting with the PromoCode builders.
-	PromoCode *PromoCodeClient
-	// PromoCodeUsage is the client for interacting with the PromoCodeUsage builders.
-	PromoCodeUsage *PromoCodeUsageClient
 	// Proxy is the client for interacting with the Proxy builders.
 	Proxy *ProxyClient
 	// RedeemCode is the client for interacting with the RedeemCode builders.
 	RedeemCode *RedeemCodeClient
 	// Setting is the client for interacting with the Setting builders.
 	Setting *SettingClient
-	// UsageCleanupTask is the client for interacting with the UsageCleanupTask builders.
-	UsageCleanupTask *UsageCleanupTaskClient
 	// UsageLog is the client for interacting with the UsageLog builders.
 	UsageLog *UsageLogClient
 	// User is the client for interacting with the User builders.
 	User *UserClient
 	// UserAllowedGroup is the client for interacting with the UserAllowedGroup builders.
 	UserAllowedGroup *UserAllowedGroupClient
-	// UserAttributeDefinition is the client for interacting with the UserAttributeDefinition builders.
-	UserAttributeDefinition *UserAttributeDefinitionClient
-	// UserAttributeValue is the client for interacting with the UserAttributeValue builders.
-	UserAttributeValue *UserAttributeValueClient
 	// UserSubscription is the client for interacting with the UserSubscription builders.
 	UserSubscription *UserSubscriptionClient
 
@@ -177,21 +167,16 @@ func (tx *Tx) Client() *Client {
 }
 
 func (tx *Tx) init() {
-	tx.APIKey = NewAPIKeyClient(tx.config)
 	tx.Account = NewAccountClient(tx.config)
 	tx.AccountGroup = NewAccountGroupClient(tx.config)
+	tx.ApiKey = NewApiKeyClient(tx.config)
 	tx.Group = NewGroupClient(tx.config)
-	tx.PromoCode = NewPromoCodeClient(tx.config)
-	tx.PromoCodeUsage = NewPromoCodeUsageClient(tx.config)
 	tx.Proxy = NewProxyClient(tx.config)
 	tx.RedeemCode = NewRedeemCodeClient(tx.config)
 	tx.Setting = NewSettingClient(tx.config)
-	tx.UsageCleanupTask = NewUsageCleanupTaskClient(tx.config)
 	tx.UsageLog = NewUsageLogClient(tx.config)
 	tx.User = NewUserClient(tx.config)
 	tx.UserAllowedGroup = NewUserAllowedGroupClient(tx.config)
-	tx.UserAttributeDefinition = NewUserAttributeDefinitionClient(tx.config)
-	tx.UserAttributeValue = NewUserAttributeValueClient(tx.config)
 	tx.UserSubscription = NewUserSubscriptionClient(tx.config)
 }
 
@@ -202,7 +187,7 @@ func (tx *Tx) init() {
 // of them in order to commit or rollback the transaction.
 //
 // If a closed transaction is embedded in one of the generated entities, and the entity
-// applies a query, for example: APIKey.QueryXXX(), the query will be executed
+// applies a query, for example: Account.QueryXXX(), the query will be executed
 // through the driver which created this transaction.
 //
 // Note that txDriver is not goroutine safe.

backend/ent/usagecleanuptask.go

@@ -1,236 +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/usagecleanuptask"
-)
-
-// UsageCleanupTask is the model entity for the UsageCleanupTask schema.
-type UsageCleanupTask 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"`
-	// Status holds the value of the "status" field.
-	Status string `json:"status,omitempty"`
-	// Filters holds the value of the "filters" field.
-	Filters json.RawMessage `json:"filters,omitempty"`
-	// CreatedBy holds the value of the "created_by" field.
-	CreatedBy int64 `json:"created_by,omitempty"`
-	// DeletedRows holds the value of the "deleted_rows" field.
-	DeletedRows int64 `json:"deleted_rows,omitempty"`
-	// ErrorMessage holds the value of the "error_message" field.
-	ErrorMessage *string `json:"error_message,omitempty"`
-	// CanceledBy holds the value of the "canceled_by" field.
-	CanceledBy *int64 `json:"canceled_by,omitempty"`
-	// CanceledAt holds the value of the "canceled_at" field.
-	CanceledAt *time.Time `json:"canceled_at,omitempty"`
-	// StartedAt holds the value of the "started_at" field.
-	StartedAt *time.Time `json:"started_at,omitempty"`
-	// FinishedAt holds the value of the "finished_at" field.
-	FinishedAt   *time.Time `json:"finished_at,omitempty"`
-	selectValues sql.SelectValues
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*UsageCleanupTask) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case usagecleanuptask.FieldFilters:
-			values[i] = new([]byte)
-		case usagecleanuptask.FieldID, usagecleanuptask.FieldCreatedBy, usagecleanuptask.FieldDeletedRows, usagecleanuptask.FieldCanceledBy:
-			values[i] = new(sql.NullInt64)
-		case usagecleanuptask.FieldStatus, usagecleanuptask.FieldErrorMessage:
-			values[i] = new(sql.NullString)
-		case usagecleanuptask.FieldCreatedAt, usagecleanuptask.FieldUpdatedAt, usagecleanuptask.FieldCanceledAt, usagecleanuptask.FieldStartedAt, usagecleanuptask.FieldFinishedAt:
-			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 UsageCleanupTask fields.
-func (_m *UsageCleanupTask) 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 usagecleanuptask.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 usagecleanuptask.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 usagecleanuptask.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 usagecleanuptask.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 usagecleanuptask.FieldFilters:
-			if value, ok := values[i].(*[]byte); !ok {
-				return fmt.Errorf("unexpected type %T for field filters", values[i])
-			} else if value != nil && len(*value) > 0 {
-				if err := json.Unmarshal(*value, &_m.Filters); err != nil {
-					return fmt.Errorf("unmarshal field filters: %w", err)
-				}
-			}
-		case usagecleanuptask.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 = value.Int64
-			}
-		case usagecleanuptask.FieldDeletedRows:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field deleted_rows", values[i])
-			} else if value.Valid {
-				_m.DeletedRows = value.Int64
-			}
-		case usagecleanuptask.FieldErrorMessage:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field error_message", values[i])
-			} else if value.Valid {
-				_m.ErrorMessage = new(string)
-				*_m.ErrorMessage = value.String
-			}
-		case usagecleanuptask.FieldCanceledBy:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field canceled_by", values[i])
-			} else if value.Valid {
-				_m.CanceledBy = new(int64)
-				*_m.CanceledBy = value.Int64
-			}
-		case usagecleanuptask.FieldCanceledAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field canceled_at", values[i])
-			} else if value.Valid {
-				_m.CanceledAt = new(time.Time)
-				*_m.CanceledAt = value.Time
-			}
-		case usagecleanuptask.FieldStartedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field started_at", values[i])
-			} else if value.Valid {
-				_m.StartedAt = new(time.Time)
-				*_m.StartedAt = value.Time
-			}
-		case usagecleanuptask.FieldFinishedAt:
-			if value, ok := values[i].(*sql.NullTime); !ok {
-				return fmt.Errorf("unexpected type %T for field finished_at", values[i])
-			} else if value.Valid {
-				_m.FinishedAt = new(time.Time)
-				*_m.FinishedAt = 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 UsageCleanupTask.
-// This includes values selected through modifiers, order, etc.
-func (_m *UsageCleanupTask) Value(name string) (ent.Value, error) {
-	return _m.selectValues.Get(name)
-}
-
-// Update returns a builder for updating this UsageCleanupTask.
-// Note that you need to call UsageCleanupTask.Unwrap() before calling this method if this UsageCleanupTask
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (_m *UsageCleanupTask) Update() *UsageCleanupTaskUpdateOne {
-	return NewUsageCleanupTaskClient(_m.config).UpdateOne(_m)
-}
-
-// Unwrap unwraps the UsageCleanupTask 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 *UsageCleanupTask) Unwrap() *UsageCleanupTask {
-	_tx, ok := _m.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: UsageCleanupTask is not a transactional entity")
-	}
-	_m.config.driver = _tx.drv
-	return _m
-}
-
-// String implements the fmt.Stringer.
-func (_m *UsageCleanupTask) String() string {
-	var builder strings.Builder
-	builder.WriteString("UsageCleanupTask(")
-	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("status=")
-	builder.WriteString(_m.Status)
-	builder.WriteString(", ")
-	builder.WriteString("filters=")
-	builder.WriteString(fmt.Sprintf("%v", _m.Filters))
-	builder.WriteString(", ")
-	builder.WriteString("created_by=")
-	builder.WriteString(fmt.Sprintf("%v", _m.CreatedBy))
-	builder.WriteString(", ")
-	builder.WriteString("deleted_rows=")
-	builder.WriteString(fmt.Sprintf("%v", _m.DeletedRows))
-	builder.WriteString(", ")
-	if v := _m.ErrorMessage; v != nil {
-		builder.WriteString("error_message=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
-	if v := _m.CanceledBy; v != nil {
-		builder.WriteString("canceled_by=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
-	if v := _m.CanceledAt; v != nil {
-		builder.WriteString("canceled_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.StartedAt; v != nil {
-		builder.WriteString("started_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteString(", ")
-	if v := _m.FinishedAt; v != nil {
-		builder.WriteString("finished_at=")
-		builder.WriteString(v.Format(time.ANSIC))
-	}
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// UsageCleanupTasks is a parsable slice of UsageCleanupTask.
-type UsageCleanupTasks []*UsageCleanupTask

backend/ent/usagecleanuptask/usagecleanuptask.go

@@ -1,137 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package usagecleanuptask
-
-import (
-	"time"
-
-	"entgo.io/ent/dialect/sql"
-)
-
-const (
-	// Label holds the string label denoting the usagecleanuptask type in the database.
-	Label = "usage_cleanup_task"
-	// 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"
-	// FieldStatus holds the string denoting the status field in the database.
-	FieldStatus = "status"
-	// FieldFilters holds the string denoting the filters field in the database.
-	FieldFilters = "filters"
-	// FieldCreatedBy holds the string denoting the created_by field in the database.
-	FieldCreatedBy = "created_by"
-	// FieldDeletedRows holds the string denoting the deleted_rows field in the database.
-	FieldDeletedRows = "deleted_rows"
-	// FieldErrorMessage holds the string denoting the error_message field in the database.
-	FieldErrorMessage = "error_message"
-	// FieldCanceledBy holds the string denoting the canceled_by field in the database.
-	FieldCanceledBy = "canceled_by"
-	// FieldCanceledAt holds the string denoting the canceled_at field in the database.
-	FieldCanceledAt = "canceled_at"
-	// FieldStartedAt holds the string denoting the started_at field in the database.
-	FieldStartedAt = "started_at"
-	// FieldFinishedAt holds the string denoting the finished_at field in the database.
-	FieldFinishedAt = "finished_at"
-	// Table holds the table name of the usagecleanuptask in the database.
-	Table = "usage_cleanup_tasks"
-)
-
-// Columns holds all SQL columns for usagecleanuptask fields.
-var Columns = []string{
-	FieldID,
-	FieldCreatedAt,
-	FieldUpdatedAt,
-	FieldStatus,
-	FieldFilters,
-	FieldCreatedBy,
-	FieldDeletedRows,
-	FieldErrorMessage,
-	FieldCanceledBy,
-	FieldCanceledAt,
-	FieldStartedAt,
-	FieldFinishedAt,
-}
-
-// 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
-	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
-	StatusValidator func(string) error
-	// DefaultDeletedRows holds the default value on creation for the "deleted_rows" field.
-	DefaultDeletedRows int64
-)
-
-// OrderOption defines the ordering options for the UsageCleanupTask 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()
-}
-
-// ByStatus orders the results by the status field.
-func ByStatus(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldStatus, opts...).ToFunc()
-}
-
-// ByCreatedBy orders the results by the created_by field.
-func ByCreatedBy(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCreatedBy, opts...).ToFunc()
-}
-
-// ByDeletedRows orders the results by the deleted_rows field.
-func ByDeletedRows(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldDeletedRows, opts...).ToFunc()
-}
-
-// ByErrorMessage orders the results by the error_message field.
-func ByErrorMessage(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldErrorMessage, opts...).ToFunc()
-}
-
-// ByCanceledBy orders the results by the canceled_by field.
-func ByCanceledBy(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCanceledBy, opts...).ToFunc()
-}
-
-// ByCanceledAt orders the results by the canceled_at field.
-func ByCanceledAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldCanceledAt, opts...).ToFunc()
-}
-
-// ByStartedAt orders the results by the started_at field.
-func ByStartedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldStartedAt, opts...).ToFunc()
-}
-
-// ByFinishedAt orders the results by the finished_at field.
-func ByFinishedAt(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldFinishedAt, opts...).ToFunc()
-}

backend/ent/usagecleanuptask/where.go

@@ -1,620 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package usagecleanuptask
-
-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.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(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.UsageCleanupTask {
-	return predicate.UsageCleanupTask(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.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
-func Status(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldStatus, v))
-}
-
-// CreatedBy applies equality check predicate on the "created_by" field. It's identical to CreatedByEQ.
-func CreatedBy(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldCreatedBy, v))
-}
-
-// DeletedRows applies equality check predicate on the "deleted_rows" field. It's identical to DeletedRowsEQ.
-func DeletedRows(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldDeletedRows, v))
-}
-
-// ErrorMessage applies equality check predicate on the "error_message" field. It's identical to ErrorMessageEQ.
-func ErrorMessage(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldErrorMessage, v))
-}
-
-// CanceledBy applies equality check predicate on the "canceled_by" field. It's identical to CanceledByEQ.
-func CanceledBy(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldCanceledBy, v))
-}
-
-// CanceledAt applies equality check predicate on the "canceled_at" field. It's identical to CanceledAtEQ.
-func CanceledAt(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldCanceledAt, v))
-}
-
-// StartedAt applies equality check predicate on the "started_at" field. It's identical to StartedAtEQ.
-func StartedAt(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldStartedAt, v))
-}
-
-// FinishedAt applies equality check predicate on the "finished_at" field. It's identical to FinishedAtEQ.
-func FinishedAt(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldFinishedAt, v))
-}
-
-// CreatedAtEQ applies the EQ predicate on the "created_at" field.
-func CreatedAtEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
-func CreatedAtNEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldCreatedAt, v))
-}
-
-// CreatedAtIn applies the In predicate on the "created_at" field.
-func CreatedAtIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
-func CreatedAtNotIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldCreatedAt, vs...))
-}
-
-// CreatedAtGT applies the GT predicate on the "created_at" field.
-func CreatedAtGT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldCreatedAt, v))
-}
-
-// CreatedAtGTE applies the GTE predicate on the "created_at" field.
-func CreatedAtGTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldCreatedAt, v))
-}
-
-// CreatedAtLT applies the LT predicate on the "created_at" field.
-func CreatedAtLT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldCreatedAt, v))
-}
-
-// CreatedAtLTE applies the LTE predicate on the "created_at" field.
-func CreatedAtLTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldCreatedAt, v))
-}
-
-// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
-func UpdatedAtEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
-func UpdatedAtNEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldUpdatedAt, v))
-}
-
-// UpdatedAtIn applies the In predicate on the "updated_at" field.
-func UpdatedAtIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
-func UpdatedAtNotIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldUpdatedAt, vs...))
-}
-
-// UpdatedAtGT applies the GT predicate on the "updated_at" field.
-func UpdatedAtGT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
-func UpdatedAtGTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLT applies the LT predicate on the "updated_at" field.
-func UpdatedAtLT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldUpdatedAt, v))
-}
-
-// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
-func UpdatedAtLTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldUpdatedAt, v))
-}
-
-// StatusEQ applies the EQ predicate on the "status" field.
-func StatusEQ(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldStatus, v))
-}
-
-// StatusNEQ applies the NEQ predicate on the "status" field.
-func StatusNEQ(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldStatus, v))
-}
-
-// StatusIn applies the In predicate on the "status" field.
-func StatusIn(vs ...string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldStatus, vs...))
-}
-
-// StatusNotIn applies the NotIn predicate on the "status" field.
-func StatusNotIn(vs ...string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldStatus, vs...))
-}
-
-// StatusGT applies the GT predicate on the "status" field.
-func StatusGT(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldStatus, v))
-}
-
-// StatusGTE applies the GTE predicate on the "status" field.
-func StatusGTE(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldStatus, v))
-}
-
-// StatusLT applies the LT predicate on the "status" field.
-func StatusLT(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldStatus, v))
-}
-
-// StatusLTE applies the LTE predicate on the "status" field.
-func StatusLTE(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldStatus, v))
-}
-
-// StatusContains applies the Contains predicate on the "status" field.
-func StatusContains(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldContains(FieldStatus, v))
-}
-
-// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
-func StatusHasPrefix(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldHasPrefix(FieldStatus, v))
-}
-
-// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
-func StatusHasSuffix(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldHasSuffix(FieldStatus, v))
-}
-
-// StatusEqualFold applies the EqualFold predicate on the "status" field.
-func StatusEqualFold(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEqualFold(FieldStatus, v))
-}
-
-// StatusContainsFold applies the ContainsFold predicate on the "status" field.
-func StatusContainsFold(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldContainsFold(FieldStatus, v))
-}
-
-// CreatedByEQ applies the EQ predicate on the "created_by" field.
-func CreatedByEQ(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldCreatedBy, v))
-}
-
-// CreatedByNEQ applies the NEQ predicate on the "created_by" field.
-func CreatedByNEQ(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldCreatedBy, v))
-}
-
-// CreatedByIn applies the In predicate on the "created_by" field.
-func CreatedByIn(vs ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldCreatedBy, vs...))
-}
-
-// CreatedByNotIn applies the NotIn predicate on the "created_by" field.
-func CreatedByNotIn(vs ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldCreatedBy, vs...))
-}
-
-// CreatedByGT applies the GT predicate on the "created_by" field.
-func CreatedByGT(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldCreatedBy, v))
-}
-
-// CreatedByGTE applies the GTE predicate on the "created_by" field.
-func CreatedByGTE(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldCreatedBy, v))
-}
-
-// CreatedByLT applies the LT predicate on the "created_by" field.
-func CreatedByLT(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldCreatedBy, v))
-}
-
-// CreatedByLTE applies the LTE predicate on the "created_by" field.
-func CreatedByLTE(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldCreatedBy, v))
-}
-
-// DeletedRowsEQ applies the EQ predicate on the "deleted_rows" field.
-func DeletedRowsEQ(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldDeletedRows, v))
-}
-
-// DeletedRowsNEQ applies the NEQ predicate on the "deleted_rows" field.
-func DeletedRowsNEQ(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldDeletedRows, v))
-}
-
-// DeletedRowsIn applies the In predicate on the "deleted_rows" field.
-func DeletedRowsIn(vs ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldDeletedRows, vs...))
-}
-
-// DeletedRowsNotIn applies the NotIn predicate on the "deleted_rows" field.
-func DeletedRowsNotIn(vs ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldDeletedRows, vs...))
-}
-
-// DeletedRowsGT applies the GT predicate on the "deleted_rows" field.
-func DeletedRowsGT(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldDeletedRows, v))
-}
-
-// DeletedRowsGTE applies the GTE predicate on the "deleted_rows" field.
-func DeletedRowsGTE(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldDeletedRows, v))
-}
-
-// DeletedRowsLT applies the LT predicate on the "deleted_rows" field.
-func DeletedRowsLT(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldDeletedRows, v))
-}
-
-// DeletedRowsLTE applies the LTE predicate on the "deleted_rows" field.
-func DeletedRowsLTE(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldDeletedRows, v))
-}
-
-// ErrorMessageEQ applies the EQ predicate on the "error_message" field.
-func ErrorMessageEQ(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldErrorMessage, v))
-}
-
-// ErrorMessageNEQ applies the NEQ predicate on the "error_message" field.
-func ErrorMessageNEQ(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldErrorMessage, v))
-}
-
-// ErrorMessageIn applies the In predicate on the "error_message" field.
-func ErrorMessageIn(vs ...string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldErrorMessage, vs...))
-}
-
-// ErrorMessageNotIn applies the NotIn predicate on the "error_message" field.
-func ErrorMessageNotIn(vs ...string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldErrorMessage, vs...))
-}
-
-// ErrorMessageGT applies the GT predicate on the "error_message" field.
-func ErrorMessageGT(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldErrorMessage, v))
-}
-
-// ErrorMessageGTE applies the GTE predicate on the "error_message" field.
-func ErrorMessageGTE(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldErrorMessage, v))
-}
-
-// ErrorMessageLT applies the LT predicate on the "error_message" field.
-func ErrorMessageLT(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldErrorMessage, v))
-}
-
-// ErrorMessageLTE applies the LTE predicate on the "error_message" field.
-func ErrorMessageLTE(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldErrorMessage, v))
-}
-
-// ErrorMessageContains applies the Contains predicate on the "error_message" field.
-func ErrorMessageContains(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldContains(FieldErrorMessage, v))
-}
-
-// ErrorMessageHasPrefix applies the HasPrefix predicate on the "error_message" field.
-func ErrorMessageHasPrefix(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldHasPrefix(FieldErrorMessage, v))
-}
-
-// ErrorMessageHasSuffix applies the HasSuffix predicate on the "error_message" field.
-func ErrorMessageHasSuffix(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldHasSuffix(FieldErrorMessage, v))
-}
-
-// ErrorMessageIsNil applies the IsNil predicate on the "error_message" field.
-func ErrorMessageIsNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIsNull(FieldErrorMessage))
-}
-
-// ErrorMessageNotNil applies the NotNil predicate on the "error_message" field.
-func ErrorMessageNotNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotNull(FieldErrorMessage))
-}
-
-// ErrorMessageEqualFold applies the EqualFold predicate on the "error_message" field.
-func ErrorMessageEqualFold(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEqualFold(FieldErrorMessage, v))
-}
-
-// ErrorMessageContainsFold applies the ContainsFold predicate on the "error_message" field.
-func ErrorMessageContainsFold(v string) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldContainsFold(FieldErrorMessage, v))
-}
-
-// CanceledByEQ applies the EQ predicate on the "canceled_by" field.
-func CanceledByEQ(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldCanceledBy, v))
-}
-
-// CanceledByNEQ applies the NEQ predicate on the "canceled_by" field.
-func CanceledByNEQ(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldCanceledBy, v))
-}
-
-// CanceledByIn applies the In predicate on the "canceled_by" field.
-func CanceledByIn(vs ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldCanceledBy, vs...))
-}
-
-// CanceledByNotIn applies the NotIn predicate on the "canceled_by" field.
-func CanceledByNotIn(vs ...int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldCanceledBy, vs...))
-}
-
-// CanceledByGT applies the GT predicate on the "canceled_by" field.
-func CanceledByGT(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldCanceledBy, v))
-}
-
-// CanceledByGTE applies the GTE predicate on the "canceled_by" field.
-func CanceledByGTE(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldCanceledBy, v))
-}
-
-// CanceledByLT applies the LT predicate on the "canceled_by" field.
-func CanceledByLT(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldCanceledBy, v))
-}
-
-// CanceledByLTE applies the LTE predicate on the "canceled_by" field.
-func CanceledByLTE(v int64) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldCanceledBy, v))
-}
-
-// CanceledByIsNil applies the IsNil predicate on the "canceled_by" field.
-func CanceledByIsNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIsNull(FieldCanceledBy))
-}
-
-// CanceledByNotNil applies the NotNil predicate on the "canceled_by" field.
-func CanceledByNotNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotNull(FieldCanceledBy))
-}
-
-// CanceledAtEQ applies the EQ predicate on the "canceled_at" field.
-func CanceledAtEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldCanceledAt, v))
-}
-
-// CanceledAtNEQ applies the NEQ predicate on the "canceled_at" field.
-func CanceledAtNEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldCanceledAt, v))
-}
-
-// CanceledAtIn applies the In predicate on the "canceled_at" field.
-func CanceledAtIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldCanceledAt, vs...))
-}
-
-// CanceledAtNotIn applies the NotIn predicate on the "canceled_at" field.
-func CanceledAtNotIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldCanceledAt, vs...))
-}
-
-// CanceledAtGT applies the GT predicate on the "canceled_at" field.
-func CanceledAtGT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldCanceledAt, v))
-}
-
-// CanceledAtGTE applies the GTE predicate on the "canceled_at" field.
-func CanceledAtGTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldCanceledAt, v))
-}
-
-// CanceledAtLT applies the LT predicate on the "canceled_at" field.
-func CanceledAtLT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldCanceledAt, v))
-}
-
-// CanceledAtLTE applies the LTE predicate on the "canceled_at" field.
-func CanceledAtLTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldCanceledAt, v))
-}
-
-// CanceledAtIsNil applies the IsNil predicate on the "canceled_at" field.
-func CanceledAtIsNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIsNull(FieldCanceledAt))
-}
-
-// CanceledAtNotNil applies the NotNil predicate on the "canceled_at" field.
-func CanceledAtNotNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotNull(FieldCanceledAt))
-}
-
-// StartedAtEQ applies the EQ predicate on the "started_at" field.
-func StartedAtEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldStartedAt, v))
-}
-
-// StartedAtNEQ applies the NEQ predicate on the "started_at" field.
-func StartedAtNEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldStartedAt, v))
-}
-
-// StartedAtIn applies the In predicate on the "started_at" field.
-func StartedAtIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldStartedAt, vs...))
-}
-
-// StartedAtNotIn applies the NotIn predicate on the "started_at" field.
-func StartedAtNotIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldStartedAt, vs...))
-}
-
-// StartedAtGT applies the GT predicate on the "started_at" field.
-func StartedAtGT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldStartedAt, v))
-}
-
-// StartedAtGTE applies the GTE predicate on the "started_at" field.
-func StartedAtGTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldStartedAt, v))
-}
-
-// StartedAtLT applies the LT predicate on the "started_at" field.
-func StartedAtLT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldStartedAt, v))
-}
-
-// StartedAtLTE applies the LTE predicate on the "started_at" field.
-func StartedAtLTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldStartedAt, v))
-}
-
-// StartedAtIsNil applies the IsNil predicate on the "started_at" field.
-func StartedAtIsNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIsNull(FieldStartedAt))
-}
-
-// StartedAtNotNil applies the NotNil predicate on the "started_at" field.
-func StartedAtNotNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotNull(FieldStartedAt))
-}
-
-// FinishedAtEQ applies the EQ predicate on the "finished_at" field.
-func FinishedAtEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldEQ(FieldFinishedAt, v))
-}
-
-// FinishedAtNEQ applies the NEQ predicate on the "finished_at" field.
-func FinishedAtNEQ(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNEQ(FieldFinishedAt, v))
-}
-
-// FinishedAtIn applies the In predicate on the "finished_at" field.
-func FinishedAtIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIn(FieldFinishedAt, vs...))
-}
-
-// FinishedAtNotIn applies the NotIn predicate on the "finished_at" field.
-func FinishedAtNotIn(vs ...time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotIn(FieldFinishedAt, vs...))
-}
-
-// FinishedAtGT applies the GT predicate on the "finished_at" field.
-func FinishedAtGT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGT(FieldFinishedAt, v))
-}
-
-// FinishedAtGTE applies the GTE predicate on the "finished_at" field.
-func FinishedAtGTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldGTE(FieldFinishedAt, v))
-}
-
-// FinishedAtLT applies the LT predicate on the "finished_at" field.
-func FinishedAtLT(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLT(FieldFinishedAt, v))
-}
-
-// FinishedAtLTE applies the LTE predicate on the "finished_at" field.
-func FinishedAtLTE(v time.Time) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldLTE(FieldFinishedAt, v))
-}
-
-// FinishedAtIsNil applies the IsNil predicate on the "finished_at" field.
-func FinishedAtIsNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldIsNull(FieldFinishedAt))
-}
-
-// FinishedAtNotNil applies the NotNil predicate on the "finished_at" field.
-func FinishedAtNotNil() predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.FieldNotNull(FieldFinishedAt))
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.UsageCleanupTask) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.UsageCleanupTask) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.UsageCleanupTask) predicate.UsageCleanupTask {
-	return predicate.UsageCleanupTask(sql.NotPredicates(p))
-}

backend/ent/usagecleanuptask_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/usagecleanuptask"
-)
-
-// UsageCleanupTaskDelete is the builder for deleting a UsageCleanupTask entity.
-type UsageCleanupTaskDelete struct {
-	config
-	hooks    []Hook
-	mutation *UsageCleanupTaskMutation
-}
-
-// Where appends a list predicates to the UsageCleanupTaskDelete builder.
-func (_d *UsageCleanupTaskDelete) Where(ps ...predicate.UsageCleanupTask) *UsageCleanupTaskDelete {
-	_d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (_d *UsageCleanupTaskDelete) 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 *UsageCleanupTaskDelete) ExecX(ctx context.Context) int {
-	n, err := _d.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (_d *UsageCleanupTaskDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(usagecleanuptask.Table, sqlgraph.NewFieldSpec(usagecleanuptask.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
-}
-
-// UsageCleanupTaskDeleteOne is the builder for deleting a single UsageCleanupTask entity.
-type UsageCleanupTaskDeleteOne struct {
-	_d *UsageCleanupTaskDelete
-}
-
-// Where appends a list predicates to the UsageCleanupTaskDelete builder.
-func (_d *UsageCleanupTaskDeleteOne) Where(ps ...predicate.UsageCleanupTask) *UsageCleanupTaskDeleteOne {
-	_d._d.mutation.Where(ps...)
-	return _d
-}
-
-// Exec executes the deletion query.
-func (_d *UsageCleanupTaskDeleteOne) Exec(ctx context.Context) error {
-	n, err := _d._d.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{usagecleanuptask.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_d *UsageCleanupTaskDeleteOne) ExecX(ctx context.Context) {
-	if err := _d.Exec(ctx); err != nil {
-		panic(err)
-	}
-}

backend/ent/usagecleanuptask_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/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/usagecleanuptask"
-)
-
-// UsageCleanupTaskQuery is the builder for querying UsageCleanupTask entities.
-type UsageCleanupTaskQuery struct {
-	config
-	ctx        *QueryContext
-	order      []usagecleanuptask.OrderOption
-	inters     []Interceptor
-	predicates []predicate.UsageCleanupTask
-	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 UsageCleanupTaskQuery builder.
-func (_q *UsageCleanupTaskQuery) Where(ps ...predicate.UsageCleanupTask) *UsageCleanupTaskQuery {
-	_q.predicates = append(_q.predicates, ps...)
-	return _q
-}
-
-// Limit the number of records to be returned by this query.
-func (_q *UsageCleanupTaskQuery) Limit(limit int) *UsageCleanupTaskQuery {
-	_q.ctx.Limit = &limit
-	return _q
-}
-
-// Offset to start from.
-func (_q *UsageCleanupTaskQuery) Offset(offset int) *UsageCleanupTaskQuery {
-	_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 *UsageCleanupTaskQuery) Unique(unique bool) *UsageCleanupTaskQuery {
-	_q.ctx.Unique = &unique
-	return _q
-}
-
-// Order specifies how the records should be ordered.
-func (_q *UsageCleanupTaskQuery) Order(o ...usagecleanuptask.OrderOption) *UsageCleanupTaskQuery {
-	_q.order = append(_q.order, o...)
-	return _q
-}
-
-// First returns the first UsageCleanupTask entity from the query.
-// Returns a *NotFoundError when no UsageCleanupTask was found.
-func (_q *UsageCleanupTaskQuery) First(ctx context.Context) (*UsageCleanupTask, 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{usagecleanuptask.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (_q *UsageCleanupTaskQuery) FirstX(ctx context.Context) *UsageCleanupTask {
-	node, err := _q.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first UsageCleanupTask ID from the query.
-// Returns a *NotFoundError when no UsageCleanupTask ID was found.
-func (_q *UsageCleanupTaskQuery) 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{usagecleanuptask.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (_q *UsageCleanupTaskQuery) FirstIDX(ctx context.Context) int64 {
-	id, err := _q.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single UsageCleanupTask entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one UsageCleanupTask entity is found.
-// Returns a *NotFoundError when no UsageCleanupTask entities are found.
-func (_q *UsageCleanupTaskQuery) Only(ctx context.Context) (*UsageCleanupTask, 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{usagecleanuptask.Label}
-	default:
-		return nil, &NotSingularError{usagecleanuptask.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (_q *UsageCleanupTaskQuery) OnlyX(ctx context.Context) *UsageCleanupTask {
-	node, err := _q.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only UsageCleanupTask ID in the query.
-// Returns a *NotSingularError when more than one UsageCleanupTask ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (_q *UsageCleanupTaskQuery) 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{usagecleanuptask.Label}
-	default:
-		err = &NotSingularError{usagecleanuptask.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (_q *UsageCleanupTaskQuery) 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 UsageCleanupTasks.
-func (_q *UsageCleanupTaskQuery) All(ctx context.Context) ([]*UsageCleanupTask, error) {
-	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
-	if err := _q.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*UsageCleanupTask, *UsageCleanupTaskQuery]()
-	return withInterceptors[[]*UsageCleanupTask](ctx, _q, qr, _q.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (_q *UsageCleanupTaskQuery) AllX(ctx context.Context) []*UsageCleanupTask {
-	nodes, err := _q.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of UsageCleanupTask IDs.
-func (_q *UsageCleanupTaskQuery) 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(usagecleanuptask.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (_q *UsageCleanupTaskQuery) 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 *UsageCleanupTaskQuery) 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[*UsageCleanupTaskQuery](), _q.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (_q *UsageCleanupTaskQuery) 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 *UsageCleanupTaskQuery) 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 *UsageCleanupTaskQuery) ExistX(ctx context.Context) bool {
-	exist, err := _q.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the UsageCleanupTaskQuery 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 *UsageCleanupTaskQuery) Clone() *UsageCleanupTaskQuery {
-	if _q == nil {
-		return nil
-	}
-	return &UsageCleanupTaskQuery{
-		config:     _q.config,
-		ctx:        _q.ctx.Clone(),
-		order:      append([]usagecleanuptask.OrderOption{}, _q.order...),
-		inters:     append([]Interceptor{}, _q.inters...),
-		predicates: append([]predicate.UsageCleanupTask{}, _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.UsageCleanupTask.Query().
-//		GroupBy(usagecleanuptask.FieldCreatedAt).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (_q *UsageCleanupTaskQuery) GroupBy(field string, fields ...string) *UsageCleanupTaskGroupBy {
-	_q.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &UsageCleanupTaskGroupBy{build: _q}
-	grbuild.flds = &_q.ctx.Fields
-	grbuild.label = usagecleanuptask.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.UsageCleanupTask.Query().
-//		Select(usagecleanuptask.FieldCreatedAt).
-//		Scan(ctx, &v)
-func (_q *UsageCleanupTaskQuery) Select(fields ...string) *UsageCleanupTaskSelect {
-	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
-	sbuild := &UsageCleanupTaskSelect{UsageCleanupTaskQuery: _q}
-	sbuild.label = usagecleanuptask.Label
-	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a UsageCleanupTaskSelect configured with the given aggregations.
-func (_q *UsageCleanupTaskQuery) Aggregate(fns ...AggregateFunc) *UsageCleanupTaskSelect {
-	return _q.Select().Aggregate(fns...)
-}
-
-func (_q *UsageCleanupTaskQuery) 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 !usagecleanuptask.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 *UsageCleanupTaskQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*UsageCleanupTask, error) {
-	var (
-		nodes = []*UsageCleanupTask{}
-		_spec = _q.querySpec()
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*UsageCleanupTask).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &UsageCleanupTask{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 *UsageCleanupTaskQuery) 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 *UsageCleanupTaskQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(usagecleanuptask.Table, usagecleanuptask.Columns, sqlgraph.NewFieldSpec(usagecleanuptask.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, usagecleanuptask.FieldID)
-		for i := range fields {
-			if fields[i] != usagecleanuptask.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 *UsageCleanupTaskQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(_q.driver.Dialect())
-	t1 := builder.Table(usagecleanuptask.Table)
-	columns := _q.ctx.Fields
-	if len(columns) == 0 {
-		columns = usagecleanuptask.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 *UsageCleanupTaskQuery) ForUpdate(opts ...sql.LockOption) *UsageCleanupTaskQuery {
-	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 *UsageCleanupTaskQuery) ForShare(opts ...sql.LockOption) *UsageCleanupTaskQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
-// UsageCleanupTaskGroupBy is the group-by builder for UsageCleanupTask entities.
-type UsageCleanupTaskGroupBy struct {
-	selector
-	build *UsageCleanupTaskQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (_g *UsageCleanupTaskGroupBy) Aggregate(fns ...AggregateFunc) *UsageCleanupTaskGroupBy {
-	_g.fns = append(_g.fns, fns...)
-	return _g
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_g *UsageCleanupTaskGroupBy) 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[*UsageCleanupTaskQuery, *UsageCleanupTaskGroupBy](ctx, _g.build, _g, _g.build.inters, v)
-}
-
-func (_g *UsageCleanupTaskGroupBy) sqlScan(ctx context.Context, root *UsageCleanupTaskQuery, 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)
-}
-
-// UsageCleanupTaskSelect is the builder for selecting fields of UsageCleanupTask entities.
-type UsageCleanupTaskSelect struct {
-	*UsageCleanupTaskQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (_s *UsageCleanupTaskSelect) Aggregate(fns ...AggregateFunc) *UsageCleanupTaskSelect {
-	_s.fns = append(_s.fns, fns...)
-	return _s
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (_s *UsageCleanupTaskSelect) 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[*UsageCleanupTaskQuery, *UsageCleanupTaskSelect](ctx, _s.UsageCleanupTaskQuery, _s, _s.inters, v)
-}
-
-func (_s *UsageCleanupTaskSelect) sqlScan(ctx context.Context, root *UsageCleanupTaskQuery, 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/usagecleanuptask_update.go

@@ -1,702 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"encoding/json"
-	"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/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/usagecleanuptask"
-)
-
-// UsageCleanupTaskUpdate is the builder for updating UsageCleanupTask entities.
-type UsageCleanupTaskUpdate struct {
-	config
-	hooks    []Hook
-	mutation *UsageCleanupTaskMutation
-}
-
-// Where appends a list predicates to the UsageCleanupTaskUpdate builder.
-func (_u *UsageCleanupTaskUpdate) Where(ps ...predicate.UsageCleanupTask) *UsageCleanupTaskUpdate {
-	_u.mutation.Where(ps...)
-	return _u
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *UsageCleanupTaskUpdate) SetUpdatedAt(v time.Time) *UsageCleanupTaskUpdate {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *UsageCleanupTaskUpdate) SetStatus(v string) *UsageCleanupTaskUpdate {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableStatus(v *string) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetFilters sets the "filters" field.
-func (_u *UsageCleanupTaskUpdate) SetFilters(v json.RawMessage) *UsageCleanupTaskUpdate {
-	_u.mutation.SetFilters(v)
-	return _u
-}
-
-// AppendFilters appends value to the "filters" field.
-func (_u *UsageCleanupTaskUpdate) AppendFilters(v json.RawMessage) *UsageCleanupTaskUpdate {
-	_u.mutation.AppendFilters(v)
-	return _u
-}
-
-// SetCreatedBy sets the "created_by" field.
-func (_u *UsageCleanupTaskUpdate) SetCreatedBy(v int64) *UsageCleanupTaskUpdate {
-	_u.mutation.ResetCreatedBy()
-	_u.mutation.SetCreatedBy(v)
-	return _u
-}
-
-// SetNillableCreatedBy sets the "created_by" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableCreatedBy(v *int64) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetCreatedBy(*v)
-	}
-	return _u
-}
-
-// AddCreatedBy adds value to the "created_by" field.
-func (_u *UsageCleanupTaskUpdate) AddCreatedBy(v int64) *UsageCleanupTaskUpdate {
-	_u.mutation.AddCreatedBy(v)
-	return _u
-}
-
-// SetDeletedRows sets the "deleted_rows" field.
-func (_u *UsageCleanupTaskUpdate) SetDeletedRows(v int64) *UsageCleanupTaskUpdate {
-	_u.mutation.ResetDeletedRows()
-	_u.mutation.SetDeletedRows(v)
-	return _u
-}
-
-// SetNillableDeletedRows sets the "deleted_rows" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableDeletedRows(v *int64) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetDeletedRows(*v)
-	}
-	return _u
-}
-
-// AddDeletedRows adds value to the "deleted_rows" field.
-func (_u *UsageCleanupTaskUpdate) AddDeletedRows(v int64) *UsageCleanupTaskUpdate {
-	_u.mutation.AddDeletedRows(v)
-	return _u
-}
-
-// SetErrorMessage sets the "error_message" field.
-func (_u *UsageCleanupTaskUpdate) SetErrorMessage(v string) *UsageCleanupTaskUpdate {
-	_u.mutation.SetErrorMessage(v)
-	return _u
-}
-
-// SetNillableErrorMessage sets the "error_message" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableErrorMessage(v *string) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetErrorMessage(*v)
-	}
-	return _u
-}
-
-// ClearErrorMessage clears the value of the "error_message" field.
-func (_u *UsageCleanupTaskUpdate) ClearErrorMessage() *UsageCleanupTaskUpdate {
-	_u.mutation.ClearErrorMessage()
-	return _u
-}
-
-// SetCanceledBy sets the "canceled_by" field.
-func (_u *UsageCleanupTaskUpdate) SetCanceledBy(v int64) *UsageCleanupTaskUpdate {
-	_u.mutation.ResetCanceledBy()
-	_u.mutation.SetCanceledBy(v)
-	return _u
-}
-
-// SetNillableCanceledBy sets the "canceled_by" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableCanceledBy(v *int64) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetCanceledBy(*v)
-	}
-	return _u
-}
-
-// AddCanceledBy adds value to the "canceled_by" field.
-func (_u *UsageCleanupTaskUpdate) AddCanceledBy(v int64) *UsageCleanupTaskUpdate {
-	_u.mutation.AddCanceledBy(v)
-	return _u
-}
-
-// ClearCanceledBy clears the value of the "canceled_by" field.
-func (_u *UsageCleanupTaskUpdate) ClearCanceledBy() *UsageCleanupTaskUpdate {
-	_u.mutation.ClearCanceledBy()
-	return _u
-}
-
-// SetCanceledAt sets the "canceled_at" field.
-func (_u *UsageCleanupTaskUpdate) SetCanceledAt(v time.Time) *UsageCleanupTaskUpdate {
-	_u.mutation.SetCanceledAt(v)
-	return _u
-}
-
-// SetNillableCanceledAt sets the "canceled_at" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableCanceledAt(v *time.Time) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetCanceledAt(*v)
-	}
-	return _u
-}
-
-// ClearCanceledAt clears the value of the "canceled_at" field.
-func (_u *UsageCleanupTaskUpdate) ClearCanceledAt() *UsageCleanupTaskUpdate {
-	_u.mutation.ClearCanceledAt()
-	return _u
-}
-
-// SetStartedAt sets the "started_at" field.
-func (_u *UsageCleanupTaskUpdate) SetStartedAt(v time.Time) *UsageCleanupTaskUpdate {
-	_u.mutation.SetStartedAt(v)
-	return _u
-}
-
-// SetNillableStartedAt sets the "started_at" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableStartedAt(v *time.Time) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetStartedAt(*v)
-	}
-	return _u
-}
-
-// ClearStartedAt clears the value of the "started_at" field.
-func (_u *UsageCleanupTaskUpdate) ClearStartedAt() *UsageCleanupTaskUpdate {
-	_u.mutation.ClearStartedAt()
-	return _u
-}
-
-// SetFinishedAt sets the "finished_at" field.
-func (_u *UsageCleanupTaskUpdate) SetFinishedAt(v time.Time) *UsageCleanupTaskUpdate {
-	_u.mutation.SetFinishedAt(v)
-	return _u
-}
-
-// SetNillableFinishedAt sets the "finished_at" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdate) SetNillableFinishedAt(v *time.Time) *UsageCleanupTaskUpdate {
-	if v != nil {
-		_u.SetFinishedAt(*v)
-	}
-	return _u
-}
-
-// ClearFinishedAt clears the value of the "finished_at" field.
-func (_u *UsageCleanupTaskUpdate) ClearFinishedAt() *UsageCleanupTaskUpdate {
-	_u.mutation.ClearFinishedAt()
-	return _u
-}
-
-// Mutation returns the UsageCleanupTaskMutation object of the builder.
-func (_u *UsageCleanupTaskUpdate) Mutation() *UsageCleanupTaskMutation {
-	return _u.mutation
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (_u *UsageCleanupTaskUpdate) 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 *UsageCleanupTaskUpdate) SaveX(ctx context.Context) int {
-	affected, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (_u *UsageCleanupTaskUpdate) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *UsageCleanupTaskUpdate) 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 *UsageCleanupTaskUpdate) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := usagecleanuptask.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *UsageCleanupTaskUpdate) check() error {
-	if v, ok := _u.mutation.Status(); ok {
-		if err := usagecleanuptask.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "UsageCleanupTask.status": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *UsageCleanupTaskUpdate) sqlSave(ctx context.Context) (_node int, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(usagecleanuptask.Table, usagecleanuptask.Columns, sqlgraph.NewFieldSpec(usagecleanuptask.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(usagecleanuptask.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(usagecleanuptask.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Filters(); ok {
-		_spec.SetField(usagecleanuptask.FieldFilters, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedFilters(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, usagecleanuptask.FieldFilters, value)
-		})
-	}
-	if value, ok := _u.mutation.CreatedBy(); ok {
-		_spec.SetField(usagecleanuptask.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedCreatedBy(); ok {
-		_spec.AddField(usagecleanuptask.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.DeletedRows(); ok {
-		_spec.SetField(usagecleanuptask.FieldDeletedRows, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedDeletedRows(); ok {
-		_spec.AddField(usagecleanuptask.FieldDeletedRows, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.ErrorMessage(); ok {
-		_spec.SetField(usagecleanuptask.FieldErrorMessage, field.TypeString, value)
-	}
-	if _u.mutation.ErrorMessageCleared() {
-		_spec.ClearField(usagecleanuptask.FieldErrorMessage, field.TypeString)
-	}
-	if value, ok := _u.mutation.CanceledBy(); ok {
-		_spec.SetField(usagecleanuptask.FieldCanceledBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedCanceledBy(); ok {
-		_spec.AddField(usagecleanuptask.FieldCanceledBy, field.TypeInt64, value)
-	}
-	if _u.mutation.CanceledByCleared() {
-		_spec.ClearField(usagecleanuptask.FieldCanceledBy, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.CanceledAt(); ok {
-		_spec.SetField(usagecleanuptask.FieldCanceledAt, field.TypeTime, value)
-	}
-	if _u.mutation.CanceledAtCleared() {
-		_spec.ClearField(usagecleanuptask.FieldCanceledAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.StartedAt(); ok {
-		_spec.SetField(usagecleanuptask.FieldStartedAt, field.TypeTime, value)
-	}
-	if _u.mutation.StartedAtCleared() {
-		_spec.ClearField(usagecleanuptask.FieldStartedAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.FinishedAt(); ok {
-		_spec.SetField(usagecleanuptask.FieldFinishedAt, field.TypeTime, value)
-	}
-	if _u.mutation.FinishedAtCleared() {
-		_spec.ClearField(usagecleanuptask.FieldFinishedAt, field.TypeTime)
-	}
-	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{usagecleanuptask.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	_u.mutation.done = true
-	return _node, nil
-}
-
-// UsageCleanupTaskUpdateOne is the builder for updating a single UsageCleanupTask entity.
-type UsageCleanupTaskUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *UsageCleanupTaskMutation
-}
-
-// SetUpdatedAt sets the "updated_at" field.
-func (_u *UsageCleanupTaskUpdateOne) SetUpdatedAt(v time.Time) *UsageCleanupTaskUpdateOne {
-	_u.mutation.SetUpdatedAt(v)
-	return _u
-}
-
-// SetStatus sets the "status" field.
-func (_u *UsageCleanupTaskUpdateOne) SetStatus(v string) *UsageCleanupTaskUpdateOne {
-	_u.mutation.SetStatus(v)
-	return _u
-}
-
-// SetNillableStatus sets the "status" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableStatus(v *string) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetStatus(*v)
-	}
-	return _u
-}
-
-// SetFilters sets the "filters" field.
-func (_u *UsageCleanupTaskUpdateOne) SetFilters(v json.RawMessage) *UsageCleanupTaskUpdateOne {
-	_u.mutation.SetFilters(v)
-	return _u
-}
-
-// AppendFilters appends value to the "filters" field.
-func (_u *UsageCleanupTaskUpdateOne) AppendFilters(v json.RawMessage) *UsageCleanupTaskUpdateOne {
-	_u.mutation.AppendFilters(v)
-	return _u
-}
-
-// SetCreatedBy sets the "created_by" field.
-func (_u *UsageCleanupTaskUpdateOne) SetCreatedBy(v int64) *UsageCleanupTaskUpdateOne {
-	_u.mutation.ResetCreatedBy()
-	_u.mutation.SetCreatedBy(v)
-	return _u
-}
-
-// SetNillableCreatedBy sets the "created_by" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableCreatedBy(v *int64) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetCreatedBy(*v)
-	}
-	return _u
-}
-
-// AddCreatedBy adds value to the "created_by" field.
-func (_u *UsageCleanupTaskUpdateOne) AddCreatedBy(v int64) *UsageCleanupTaskUpdateOne {
-	_u.mutation.AddCreatedBy(v)
-	return _u
-}
-
-// SetDeletedRows sets the "deleted_rows" field.
-func (_u *UsageCleanupTaskUpdateOne) SetDeletedRows(v int64) *UsageCleanupTaskUpdateOne {
-	_u.mutation.ResetDeletedRows()
-	_u.mutation.SetDeletedRows(v)
-	return _u
-}
-
-// SetNillableDeletedRows sets the "deleted_rows" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableDeletedRows(v *int64) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetDeletedRows(*v)
-	}
-	return _u
-}
-
-// AddDeletedRows adds value to the "deleted_rows" field.
-func (_u *UsageCleanupTaskUpdateOne) AddDeletedRows(v int64) *UsageCleanupTaskUpdateOne {
-	_u.mutation.AddDeletedRows(v)
-	return _u
-}
-
-// SetErrorMessage sets the "error_message" field.
-func (_u *UsageCleanupTaskUpdateOne) SetErrorMessage(v string) *UsageCleanupTaskUpdateOne {
-	_u.mutation.SetErrorMessage(v)
-	return _u
-}
-
-// SetNillableErrorMessage sets the "error_message" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableErrorMessage(v *string) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetErrorMessage(*v)
-	}
-	return _u
-}
-
-// ClearErrorMessage clears the value of the "error_message" field.
-func (_u *UsageCleanupTaskUpdateOne) ClearErrorMessage() *UsageCleanupTaskUpdateOne {
-	_u.mutation.ClearErrorMessage()
-	return _u
-}
-
-// SetCanceledBy sets the "canceled_by" field.
-func (_u *UsageCleanupTaskUpdateOne) SetCanceledBy(v int64) *UsageCleanupTaskUpdateOne {
-	_u.mutation.ResetCanceledBy()
-	_u.mutation.SetCanceledBy(v)
-	return _u
-}
-
-// SetNillableCanceledBy sets the "canceled_by" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableCanceledBy(v *int64) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetCanceledBy(*v)
-	}
-	return _u
-}
-
-// AddCanceledBy adds value to the "canceled_by" field.
-func (_u *UsageCleanupTaskUpdateOne) AddCanceledBy(v int64) *UsageCleanupTaskUpdateOne {
-	_u.mutation.AddCanceledBy(v)
-	return _u
-}
-
-// ClearCanceledBy clears the value of the "canceled_by" field.
-func (_u *UsageCleanupTaskUpdateOne) ClearCanceledBy() *UsageCleanupTaskUpdateOne {
-	_u.mutation.ClearCanceledBy()
-	return _u
-}
-
-// SetCanceledAt sets the "canceled_at" field.
-func (_u *UsageCleanupTaskUpdateOne) SetCanceledAt(v time.Time) *UsageCleanupTaskUpdateOne {
-	_u.mutation.SetCanceledAt(v)
-	return _u
-}
-
-// SetNillableCanceledAt sets the "canceled_at" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableCanceledAt(v *time.Time) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetCanceledAt(*v)
-	}
-	return _u
-}
-
-// ClearCanceledAt clears the value of the "canceled_at" field.
-func (_u *UsageCleanupTaskUpdateOne) ClearCanceledAt() *UsageCleanupTaskUpdateOne {
-	_u.mutation.ClearCanceledAt()
-	return _u
-}
-
-// SetStartedAt sets the "started_at" field.
-func (_u *UsageCleanupTaskUpdateOne) SetStartedAt(v time.Time) *UsageCleanupTaskUpdateOne {
-	_u.mutation.SetStartedAt(v)
-	return _u
-}
-
-// SetNillableStartedAt sets the "started_at" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableStartedAt(v *time.Time) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetStartedAt(*v)
-	}
-	return _u
-}
-
-// ClearStartedAt clears the value of the "started_at" field.
-func (_u *UsageCleanupTaskUpdateOne) ClearStartedAt() *UsageCleanupTaskUpdateOne {
-	_u.mutation.ClearStartedAt()
-	return _u
-}
-
-// SetFinishedAt sets the "finished_at" field.
-func (_u *UsageCleanupTaskUpdateOne) SetFinishedAt(v time.Time) *UsageCleanupTaskUpdateOne {
-	_u.mutation.SetFinishedAt(v)
-	return _u
-}
-
-// SetNillableFinishedAt sets the "finished_at" field if the given value is not nil.
-func (_u *UsageCleanupTaskUpdateOne) SetNillableFinishedAt(v *time.Time) *UsageCleanupTaskUpdateOne {
-	if v != nil {
-		_u.SetFinishedAt(*v)
-	}
-	return _u
-}
-
-// ClearFinishedAt clears the value of the "finished_at" field.
-func (_u *UsageCleanupTaskUpdateOne) ClearFinishedAt() *UsageCleanupTaskUpdateOne {
-	_u.mutation.ClearFinishedAt()
-	return _u
-}
-
-// Mutation returns the UsageCleanupTaskMutation object of the builder.
-func (_u *UsageCleanupTaskUpdateOne) Mutation() *UsageCleanupTaskMutation {
-	return _u.mutation
-}
-
-// Where appends a list predicates to the UsageCleanupTaskUpdate builder.
-func (_u *UsageCleanupTaskUpdateOne) Where(ps ...predicate.UsageCleanupTask) *UsageCleanupTaskUpdateOne {
-	_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 *UsageCleanupTaskUpdateOne) Select(field string, fields ...string) *UsageCleanupTaskUpdateOne {
-	_u.fields = append([]string{field}, fields...)
-	return _u
-}
-
-// Save executes the query and returns the updated UsageCleanupTask entity.
-func (_u *UsageCleanupTaskUpdateOne) Save(ctx context.Context) (*UsageCleanupTask, error) {
-	_u.defaults()
-	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (_u *UsageCleanupTaskUpdateOne) SaveX(ctx context.Context) *UsageCleanupTask {
-	node, err := _u.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (_u *UsageCleanupTaskUpdateOne) Exec(ctx context.Context) error {
-	_, err := _u.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (_u *UsageCleanupTaskUpdateOne) 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 *UsageCleanupTaskUpdateOne) defaults() {
-	if _, ok := _u.mutation.UpdatedAt(); !ok {
-		v := usagecleanuptask.UpdateDefaultUpdatedAt()
-		_u.mutation.SetUpdatedAt(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (_u *UsageCleanupTaskUpdateOne) check() error {
-	if v, ok := _u.mutation.Status(); ok {
-		if err := usagecleanuptask.StatusValidator(v); err != nil {
-			return &ValidationError{Name: "status", err: fmt.Errorf(`ent: validator failed for field "UsageCleanupTask.status": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (_u *UsageCleanupTaskUpdateOne) sqlSave(ctx context.Context) (_node *UsageCleanupTask, err error) {
-	if err := _u.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(usagecleanuptask.Table, usagecleanuptask.Columns, sqlgraph.NewFieldSpec(usagecleanuptask.FieldID, field.TypeInt64))
-	id, ok := _u.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "UsageCleanupTask.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, usagecleanuptask.FieldID)
-		for _, f := range fields {
-			if !usagecleanuptask.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != usagecleanuptask.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(usagecleanuptask.FieldUpdatedAt, field.TypeTime, value)
-	}
-	if value, ok := _u.mutation.Status(); ok {
-		_spec.SetField(usagecleanuptask.FieldStatus, field.TypeString, value)
-	}
-	if value, ok := _u.mutation.Filters(); ok {
-		_spec.SetField(usagecleanuptask.FieldFilters, field.TypeJSON, value)
-	}
-	if value, ok := _u.mutation.AppendedFilters(); ok {
-		_spec.AddModifier(func(u *sql.UpdateBuilder) {
-			sqljson.Append(u, usagecleanuptask.FieldFilters, value)
-		})
-	}
-	if value, ok := _u.mutation.CreatedBy(); ok {
-		_spec.SetField(usagecleanuptask.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedCreatedBy(); ok {
-		_spec.AddField(usagecleanuptask.FieldCreatedBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.DeletedRows(); ok {
-		_spec.SetField(usagecleanuptask.FieldDeletedRows, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedDeletedRows(); ok {
-		_spec.AddField(usagecleanuptask.FieldDeletedRows, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.ErrorMessage(); ok {
-		_spec.SetField(usagecleanuptask.FieldErrorMessage, field.TypeString, value)
-	}
-	if _u.mutation.ErrorMessageCleared() {
-		_spec.ClearField(usagecleanuptask.FieldErrorMessage, field.TypeString)
-	}
-	if value, ok := _u.mutation.CanceledBy(); ok {
-		_spec.SetField(usagecleanuptask.FieldCanceledBy, field.TypeInt64, value)
-	}
-	if value, ok := _u.mutation.AddedCanceledBy(); ok {
-		_spec.AddField(usagecleanuptask.FieldCanceledBy, field.TypeInt64, value)
-	}
-	if _u.mutation.CanceledByCleared() {
-		_spec.ClearField(usagecleanuptask.FieldCanceledBy, field.TypeInt64)
-	}
-	if value, ok := _u.mutation.CanceledAt(); ok {
-		_spec.SetField(usagecleanuptask.FieldCanceledAt, field.TypeTime, value)
-	}
-	if _u.mutation.CanceledAtCleared() {
-		_spec.ClearField(usagecleanuptask.FieldCanceledAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.StartedAt(); ok {
-		_spec.SetField(usagecleanuptask.FieldStartedAt, field.TypeTime, value)
-	}
-	if _u.mutation.StartedAtCleared() {
-		_spec.ClearField(usagecleanuptask.FieldStartedAt, field.TypeTime)
-	}
-	if value, ok := _u.mutation.FinishedAt(); ok {
-		_spec.SetField(usagecleanuptask.FieldFinishedAt, field.TypeTime, value)
-	}
-	if _u.mutation.FinishedAtCleared() {
-		_spec.ClearField(usagecleanuptask.FieldFinishedAt, field.TypeTime)
-	}
-	_node = &UsageCleanupTask{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{usagecleanuptask.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/usagelog.go

@@ -62,8 +62,6 @@ type UsageLog struct {
 	ActualCost float64 `json:"actual_cost,omitempty"`
 	// RateMultiplier holds the value of the "rate_multiplier" field.
 	RateMultiplier float64 `json:"rate_multiplier,omitempty"`
-	// AccountRateMultiplier holds the value of the "account_rate_multiplier" field.
-	AccountRateMultiplier *float64 `json:"account_rate_multiplier,omitempty"`
 	// BillingType holds the value of the "billing_type" field.
 	BillingType int8 `json:"billing_type,omitempty"`
 	// Stream holds the value of the "stream" field.
@@ -72,14 +70,6 @@ type UsageLog struct {
 	DurationMs *int `json:"duration_ms,omitempty"`
 	// FirstTokenMs holds the value of the "first_token_ms" field.
 	FirstTokenMs *int `json:"first_token_ms,omitempty"`
-	// UserAgent holds the value of the "user_agent" field.
-	UserAgent *string `json:"user_agent,omitempty"`
-	// IPAddress holds the value of the "ip_address" field.
-	IPAddress *string `json:"ip_address,omitempty"`
-	// ImageCount holds the value of the "image_count" field.
-	ImageCount int `json:"image_count,omitempty"`
-	// ImageSize holds the value of the "image_size" field.
-	ImageSize *string `json:"image_size,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.
@@ -93,7 +83,7 @@ type UsageLogEdges struct {
 	// User holds the value of the user edge.
 	User *User `json:"user,omitempty"`
 	// APIKey holds the value of the api_key edge.
-	APIKey *APIKey `json:"api_key,omitempty"`
+	APIKey *ApiKey `json:"api_key,omitempty"`
 	// Account holds the value of the account edge.
 	Account *Account `json:"account,omitempty"`
 	// Group holds the value of the group edge.
@@ -118,7 +108,7 @@ func (e UsageLogEdges) UserOrErr() (*User, error) {
 
 // APIKeyOrErr returns the APIKey value or an error if the edge
 // was not loaded in eager-loading, or loaded but was not found.
-func (e UsageLogEdges) APIKeyOrErr() (*APIKey, error) {
+func (e UsageLogEdges) APIKeyOrErr() (*ApiKey, error) {
 	if e.APIKey != nil {
 		return e.APIKey, nil
 	} else if e.loadedTypes[1] {
@@ -167,11 +157,11 @@ func (*UsageLog) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case usagelog.FieldStream:
 			values[i] = new(sql.NullBool)
-		case usagelog.FieldInputCost, usagelog.FieldOutputCost, usagelog.FieldCacheCreationCost, usagelog.FieldCacheReadCost, usagelog.FieldTotalCost, usagelog.FieldActualCost, usagelog.FieldRateMultiplier, usagelog.FieldAccountRateMultiplier:
+		case usagelog.FieldInputCost, usagelog.FieldOutputCost, usagelog.FieldCacheCreationCost, usagelog.FieldCacheReadCost, usagelog.FieldTotalCost, usagelog.FieldActualCost, usagelog.FieldRateMultiplier:
 			values[i] = new(sql.NullFloat64)
-		case usagelog.FieldID, usagelog.FieldUserID, usagelog.FieldAPIKeyID, usagelog.FieldAccountID, usagelog.FieldGroupID, usagelog.FieldSubscriptionID, usagelog.FieldInputTokens, usagelog.FieldOutputTokens, usagelog.FieldCacheCreationTokens, usagelog.FieldCacheReadTokens, usagelog.FieldCacheCreation5mTokens, usagelog.FieldCacheCreation1hTokens, usagelog.FieldBillingType, usagelog.FieldDurationMs, usagelog.FieldFirstTokenMs, usagelog.FieldImageCount:
+		case usagelog.FieldID, usagelog.FieldUserID, usagelog.FieldAPIKeyID, usagelog.FieldAccountID, usagelog.FieldGroupID, usagelog.FieldSubscriptionID, usagelog.FieldInputTokens, usagelog.FieldOutputTokens, usagelog.FieldCacheCreationTokens, usagelog.FieldCacheReadTokens, usagelog.FieldCacheCreation5mTokens, usagelog.FieldCacheCreation1hTokens, usagelog.FieldBillingType, usagelog.FieldDurationMs, usagelog.FieldFirstTokenMs:
 			values[i] = new(sql.NullInt64)
-		case usagelog.FieldRequestID, usagelog.FieldModel, usagelog.FieldUserAgent, usagelog.FieldIPAddress, usagelog.FieldImageSize:
+		case usagelog.FieldRequestID, usagelog.FieldModel:
 			values[i] = new(sql.NullString)
 		case usagelog.FieldCreatedAt:
 			values[i] = new(sql.NullTime)
@@ -318,13 +308,6 @@ func (_m *UsageLog) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.RateMultiplier = value.Float64
 			}
-		case usagelog.FieldAccountRateMultiplier:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field account_rate_multiplier", values[i])
-			} else if value.Valid {
-				_m.AccountRateMultiplier = new(float64)
-				*_m.AccountRateMultiplier = value.Float64
-			}
 		case usagelog.FieldBillingType:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field billing_type", values[i])
@@ -351,33 +334,6 @@ func (_m *UsageLog) assignValues(columns []string, values []any) error {
 				_m.FirstTokenMs = new(int)
 				*_m.FirstTokenMs = int(value.Int64)
 			}
-		case usagelog.FieldUserAgent:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field user_agent", values[i])
-			} else if value.Valid {
-				_m.UserAgent = new(string)
-				*_m.UserAgent = value.String
-			}
-		case usagelog.FieldIPAddress:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field ip_address", values[i])
-			} else if value.Valid {
-				_m.IPAddress = new(string)
-				*_m.IPAddress = value.String
-			}
-		case usagelog.FieldImageCount:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for field image_count", values[i])
-			} else if value.Valid {
-				_m.ImageCount = int(value.Int64)
-			}
-		case usagelog.FieldImageSize:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field image_size", values[i])
-			} else if value.Valid {
-				_m.ImageSize = new(string)
-				*_m.ImageSize = value.String
-			}
 		case usagelog.FieldCreatedAt:
 			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
@@ -403,7 +359,7 @@ func (_m *UsageLog) QueryUser() *UserQuery {
 }
 
 // QueryAPIKey queries the "api_key" edge of the UsageLog entity.
-func (_m *UsageLog) QueryAPIKey() *APIKeyQuery {
+func (_m *UsageLog) QueryAPIKey() *ApiKeyQuery {
 	return NewUsageLogClient(_m.config).QueryAPIKey(_m)
 }
 
@@ -509,11 +465,6 @@ func (_m *UsageLog) String() string {
 	builder.WriteString("rate_multiplier=")
 	builder.WriteString(fmt.Sprintf("%v", _m.RateMultiplier))
 	builder.WriteString(", ")
-	if v := _m.AccountRateMultiplier; v != nil {
-		builder.WriteString("account_rate_multiplier=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
 	builder.WriteString("billing_type=")
 	builder.WriteString(fmt.Sprintf("%v", _m.BillingType))
 	builder.WriteString(", ")
@@ -530,24 +481,6 @@ func (_m *UsageLog) String() string {
 		builder.WriteString(fmt.Sprintf("%v", *v))
 	}
 	builder.WriteString(", ")
-	if v := _m.UserAgent; v != nil {
-		builder.WriteString("user_agent=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
-	if v := _m.IPAddress; v != nil {
-		builder.WriteString("ip_address=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
-	builder.WriteString("image_count=")
-	builder.WriteString(fmt.Sprintf("%v", _m.ImageCount))
-	builder.WriteString(", ")
-	if v := _m.ImageSize; v != nil {
-		builder.WriteString("image_size=")
-		builder.WriteString(*v)
-	}
-	builder.WriteString(", ")
 	builder.WriteString("created_at=")
 	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
 	builder.WriteByte(')')

backend/ent/usagelog/usagelog.go

@@ -54,8 +54,6 @@ const (
 	FieldActualCost = "actual_cost"
 	// FieldRateMultiplier holds the string denoting the rate_multiplier field in the database.
 	FieldRateMultiplier = "rate_multiplier"
-	// FieldAccountRateMultiplier holds the string denoting the account_rate_multiplier field in the database.
-	FieldAccountRateMultiplier = "account_rate_multiplier"
 	// FieldBillingType holds the string denoting the billing_type field in the database.
 	FieldBillingType = "billing_type"
 	// FieldStream holds the string denoting the stream field in the database.
@@ -64,14 +62,6 @@ const (
 	FieldDurationMs = "duration_ms"
 	// FieldFirstTokenMs holds the string denoting the first_token_ms field in the database.
 	FieldFirstTokenMs = "first_token_ms"
-	// FieldUserAgent holds the string denoting the user_agent field in the database.
-	FieldUserAgent = "user_agent"
-	// FieldIPAddress holds the string denoting the ip_address field in the database.
-	FieldIPAddress = "ip_address"
-	// FieldImageCount holds the string denoting the image_count field in the database.
-	FieldImageCount = "image_count"
-	// FieldImageSize holds the string denoting the image_size field in the database.
-	FieldImageSize = "image_size"
 	// FieldCreatedAt holds the string denoting the created_at field in the database.
 	FieldCreatedAt = "created_at"
 	// EdgeUser holds the string denoting the user edge name in mutations.
@@ -95,7 +85,7 @@ const (
 	UserColumn = "user_id"
 	// APIKeyTable is the table that holds the api_key relation/edge.
 	APIKeyTable = "usage_logs"
-	// APIKeyInverseTable is the table name for the APIKey entity.
+	// APIKeyInverseTable is the table name for the ApiKey entity.
 	// It exists in this package in order to avoid circular dependency with the "apikey" package.
 	APIKeyInverseTable = "api_keys"
 	// APIKeyColumn is the table column denoting the api_key relation/edge.
@@ -146,15 +136,10 @@ var Columns = []string{
 	FieldTotalCost,
 	FieldActualCost,
 	FieldRateMultiplier,
-	FieldAccountRateMultiplier,
 	FieldBillingType,
 	FieldStream,
 	FieldDurationMs,
 	FieldFirstTokenMs,
-	FieldUserAgent,
-	FieldIPAddress,
-	FieldImageCount,
-	FieldImageSize,
 	FieldCreatedAt,
 }
 
@@ -203,14 +188,6 @@ var (
 	DefaultBillingType int8
 	// DefaultStream holds the default value on creation for the "stream" field.
 	DefaultStream bool
-	// UserAgentValidator is a validator for the "user_agent" field. It is called by the builders before save.
-	UserAgentValidator func(string) error
-	// IPAddressValidator is a validator for the "ip_address" field. It is called by the builders before save.
-	IPAddressValidator func(string) error
-	// DefaultImageCount holds the default value on creation for the "image_count" field.
-	DefaultImageCount int
-	// ImageSizeValidator is a validator for the "image_size" field. It is called by the builders before save.
-	ImageSizeValidator func(string) error
 	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
 	DefaultCreatedAt func() time.Time
 )
@@ -323,11 +300,6 @@ func ByRateMultiplier(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldRateMultiplier, opts...).ToFunc()
 }
 
-// ByAccountRateMultiplier orders the results by the account_rate_multiplier field.
-func ByAccountRateMultiplier(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldAccountRateMultiplier, opts...).ToFunc()
-}
-
 // ByBillingType orders the results by the billing_type field.
 func ByBillingType(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldBillingType, opts...).ToFunc()
@@ -348,26 +320,6 @@ func ByFirstTokenMs(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldFirstTokenMs, opts...).ToFunc()
 }
 
-// ByUserAgent orders the results by the user_agent field.
-func ByUserAgent(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldUserAgent, opts...).ToFunc()
-}
-
-// ByIPAddress orders the results by the ip_address field.
-func ByIPAddress(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldIPAddress, opts...).ToFunc()
-}
-
-// ByImageCount orders the results by the image_count field.
-func ByImageCount(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldImageCount, opts...).ToFunc()
-}
-
-// ByImageSize orders the results by the image_size field.
-func ByImageSize(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldImageSize, opts...).ToFunc()
-}
-
 // ByCreatedAt orders the results by the created_at field.
 func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()

backend/ent/usagelog/where.go

@@ -155,11 +155,6 @@ func RateMultiplier(v float64) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldRateMultiplier, v))
 }
 
-// AccountRateMultiplier applies equality check predicate on the "account_rate_multiplier" field. It's identical to AccountRateMultiplierEQ.
-func AccountRateMultiplier(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldAccountRateMultiplier, v))
-}
-
 // BillingType applies equality check predicate on the "billing_type" field. It's identical to BillingTypeEQ.
 func BillingType(v int8) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldBillingType, v))
@@ -180,26 +175,6 @@ func FirstTokenMs(v int) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldFirstTokenMs, v))
 }
 
-// UserAgent applies equality check predicate on the "user_agent" field. It's identical to UserAgentEQ.
-func UserAgent(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldUserAgent, v))
-}
-
-// IPAddress applies equality check predicate on the "ip_address" field. It's identical to IPAddressEQ.
-func IPAddress(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldIPAddress, v))
-}
-
-// ImageCount applies equality check predicate on the "image_count" field. It's identical to ImageCountEQ.
-func ImageCount(v int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldImageCount, v))
-}
-
-// ImageSize applies equality check predicate on the "image_size" field. It's identical to ImageSizeEQ.
-func ImageSize(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldImageSize, v))
-}
-
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
 func CreatedAt(v time.Time) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldCreatedAt, v))
@@ -975,56 +950,6 @@ func RateMultiplierLTE(v float64) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldLTE(FieldRateMultiplier, v))
 }
 
-// AccountRateMultiplierEQ applies the EQ predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierEQ(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierNEQ applies the NEQ predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierNEQ(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNEQ(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierIn applies the In predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierIn(vs ...float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIn(FieldAccountRateMultiplier, vs...))
-}
-
-// AccountRateMultiplierNotIn applies the NotIn predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierNotIn(vs ...float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotIn(FieldAccountRateMultiplier, vs...))
-}
-
-// AccountRateMultiplierGT applies the GT predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierGT(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGT(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierGTE applies the GTE predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierGTE(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGTE(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierLT applies the LT predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierLT(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLT(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierLTE applies the LTE predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierLTE(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLTE(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierIsNil applies the IsNil predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierIsNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIsNull(FieldAccountRateMultiplier))
-}
-
-// AccountRateMultiplierNotNil applies the NotNil predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierNotNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotNull(FieldAccountRateMultiplier))
-}
-
 // BillingTypeEQ applies the EQ predicate on the "billing_type" field.
 func BillingTypeEQ(v int8) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldBillingType, v))
@@ -1175,271 +1100,6 @@ func FirstTokenMsNotNil() predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldNotNull(FieldFirstTokenMs))
 }
 
-// UserAgentEQ applies the EQ predicate on the "user_agent" field.
-func UserAgentEQ(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldUserAgent, v))
-}
-
-// UserAgentNEQ applies the NEQ predicate on the "user_agent" field.
-func UserAgentNEQ(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNEQ(FieldUserAgent, v))
-}
-
-// UserAgentIn applies the In predicate on the "user_agent" field.
-func UserAgentIn(vs ...string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIn(FieldUserAgent, vs...))
-}
-
-// UserAgentNotIn applies the NotIn predicate on the "user_agent" field.
-func UserAgentNotIn(vs ...string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotIn(FieldUserAgent, vs...))
-}
-
-// UserAgentGT applies the GT predicate on the "user_agent" field.
-func UserAgentGT(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGT(FieldUserAgent, v))
-}
-
-// UserAgentGTE applies the GTE predicate on the "user_agent" field.
-func UserAgentGTE(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGTE(FieldUserAgent, v))
-}
-
-// UserAgentLT applies the LT predicate on the "user_agent" field.
-func UserAgentLT(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLT(FieldUserAgent, v))
-}
-
-// UserAgentLTE applies the LTE predicate on the "user_agent" field.
-func UserAgentLTE(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLTE(FieldUserAgent, v))
-}
-
-// UserAgentContains applies the Contains predicate on the "user_agent" field.
-func UserAgentContains(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldContains(FieldUserAgent, v))
-}
-
-// UserAgentHasPrefix applies the HasPrefix predicate on the "user_agent" field.
-func UserAgentHasPrefix(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldHasPrefix(FieldUserAgent, v))
-}
-
-// UserAgentHasSuffix applies the HasSuffix predicate on the "user_agent" field.
-func UserAgentHasSuffix(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldHasSuffix(FieldUserAgent, v))
-}
-
-// UserAgentIsNil applies the IsNil predicate on the "user_agent" field.
-func UserAgentIsNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIsNull(FieldUserAgent))
-}
-
-// UserAgentNotNil applies the NotNil predicate on the "user_agent" field.
-func UserAgentNotNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotNull(FieldUserAgent))
-}
-
-// UserAgentEqualFold applies the EqualFold predicate on the "user_agent" field.
-func UserAgentEqualFold(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEqualFold(FieldUserAgent, v))
-}
-
-// UserAgentContainsFold applies the ContainsFold predicate on the "user_agent" field.
-func UserAgentContainsFold(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldContainsFold(FieldUserAgent, v))
-}
-
-// IPAddressEQ applies the EQ predicate on the "ip_address" field.
-func IPAddressEQ(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldIPAddress, v))
-}
-
-// IPAddressNEQ applies the NEQ predicate on the "ip_address" field.
-func IPAddressNEQ(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNEQ(FieldIPAddress, v))
-}
-
-// IPAddressIn applies the In predicate on the "ip_address" field.
-func IPAddressIn(vs ...string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIn(FieldIPAddress, vs...))
-}
-
-// IPAddressNotIn applies the NotIn predicate on the "ip_address" field.
-func IPAddressNotIn(vs ...string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotIn(FieldIPAddress, vs...))
-}
-
-// IPAddressGT applies the GT predicate on the "ip_address" field.
-func IPAddressGT(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGT(FieldIPAddress, v))
-}
-
-// IPAddressGTE applies the GTE predicate on the "ip_address" field.
-func IPAddressGTE(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGTE(FieldIPAddress, v))
-}
-
-// IPAddressLT applies the LT predicate on the "ip_address" field.
-func IPAddressLT(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLT(FieldIPAddress, v))
-}
-
-// IPAddressLTE applies the LTE predicate on the "ip_address" field.
-func IPAddressLTE(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLTE(FieldIPAddress, v))
-}
-
-// IPAddressContains applies the Contains predicate on the "ip_address" field.
-func IPAddressContains(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldContains(FieldIPAddress, v))
-}
-
-// IPAddressHasPrefix applies the HasPrefix predicate on the "ip_address" field.
-func IPAddressHasPrefix(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldHasPrefix(FieldIPAddress, v))
-}
-
-// IPAddressHasSuffix applies the HasSuffix predicate on the "ip_address" field.
-func IPAddressHasSuffix(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldHasSuffix(FieldIPAddress, v))
-}
-
-// IPAddressIsNil applies the IsNil predicate on the "ip_address" field.
-func IPAddressIsNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIsNull(FieldIPAddress))
-}
-
-// IPAddressNotNil applies the NotNil predicate on the "ip_address" field.
-func IPAddressNotNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotNull(FieldIPAddress))
-}
-
-// IPAddressEqualFold applies the EqualFold predicate on the "ip_address" field.
-func IPAddressEqualFold(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEqualFold(FieldIPAddress, v))
-}
-
-// IPAddressContainsFold applies the ContainsFold predicate on the "ip_address" field.
-func IPAddressContainsFold(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldContainsFold(FieldIPAddress, v))
-}
-
-// ImageCountEQ applies the EQ predicate on the "image_count" field.
-func ImageCountEQ(v int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldImageCount, v))
-}
-
-// ImageCountNEQ applies the NEQ predicate on the "image_count" field.
-func ImageCountNEQ(v int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNEQ(FieldImageCount, v))
-}
-
-// ImageCountIn applies the In predicate on the "image_count" field.
-func ImageCountIn(vs ...int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIn(FieldImageCount, vs...))
-}
-
-// ImageCountNotIn applies the NotIn predicate on the "image_count" field.
-func ImageCountNotIn(vs ...int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotIn(FieldImageCount, vs...))
-}
-
-// ImageCountGT applies the GT predicate on the "image_count" field.
-func ImageCountGT(v int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGT(FieldImageCount, v))
-}
-
-// ImageCountGTE applies the GTE predicate on the "image_count" field.
-func ImageCountGTE(v int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGTE(FieldImageCount, v))
-}
-
-// ImageCountLT applies the LT predicate on the "image_count" field.
-func ImageCountLT(v int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLT(FieldImageCount, v))
-}
-
-// ImageCountLTE applies the LTE predicate on the "image_count" field.
-func ImageCountLTE(v int) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLTE(FieldImageCount, v))
-}
-
-// ImageSizeEQ applies the EQ predicate on the "image_size" field.
-func ImageSizeEQ(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldImageSize, v))
-}
-
-// ImageSizeNEQ applies the NEQ predicate on the "image_size" field.
-func ImageSizeNEQ(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNEQ(FieldImageSize, v))
-}
-
-// ImageSizeIn applies the In predicate on the "image_size" field.
-func ImageSizeIn(vs ...string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIn(FieldImageSize, vs...))
-}
-
-// ImageSizeNotIn applies the NotIn predicate on the "image_size" field.
-func ImageSizeNotIn(vs ...string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotIn(FieldImageSize, vs...))
-}
-
-// ImageSizeGT applies the GT predicate on the "image_size" field.
-func ImageSizeGT(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGT(FieldImageSize, v))
-}
-
-// ImageSizeGTE applies the GTE predicate on the "image_size" field.
-func ImageSizeGTE(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGTE(FieldImageSize, v))
-}
-
-// ImageSizeLT applies the LT predicate on the "image_size" field.
-func ImageSizeLT(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLT(FieldImageSize, v))
-}
-
-// ImageSizeLTE applies the LTE predicate on the "image_size" field.
-func ImageSizeLTE(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLTE(FieldImageSize, v))
-}
-
-// ImageSizeContains applies the Contains predicate on the "image_size" field.
-func ImageSizeContains(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldContains(FieldImageSize, v))
-}
-
-// ImageSizeHasPrefix applies the HasPrefix predicate on the "image_size" field.
-func ImageSizeHasPrefix(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldHasPrefix(FieldImageSize, v))
-}
-
-// ImageSizeHasSuffix applies the HasSuffix predicate on the "image_size" field.
-func ImageSizeHasSuffix(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldHasSuffix(FieldImageSize, v))
-}
-
-// ImageSizeIsNil applies the IsNil predicate on the "image_size" field.
-func ImageSizeIsNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIsNull(FieldImageSize))
-}
-
-// ImageSizeNotNil applies the NotNil predicate on the "image_size" field.
-func ImageSizeNotNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotNull(FieldImageSize))
-}
-
-// ImageSizeEqualFold applies the EqualFold predicate on the "image_size" field.
-func ImageSizeEqualFold(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEqualFold(FieldImageSize, v))
-}
-
-// ImageSizeContainsFold applies the ContainsFold predicate on the "image_size" field.
-func ImageSizeContainsFold(v string) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldContainsFold(FieldImageSize, v))
-}
-
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v time.Time) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldCreatedAt, v))
@@ -1515,7 +1175,7 @@ func HasAPIKey() predicate.UsageLog {
 }
 
 // HasAPIKeyWith applies the HasEdge predicate on the "api_key" edge with a given conditions (other predicates).
-func HasAPIKeyWith(preds ...predicate.APIKey) predicate.UsageLog {
+func HasAPIKeyWith(preds ...predicate.ApiKey) predicate.UsageLog {
 	return predicate.UsageLog(func(s *sql.Selector) {
 		step := newAPIKeyStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {

backend/ent/usagelog_create.go

@@ -267,20 +267,6 @@ func (_c *UsageLogCreate) SetNillableRateMultiplier(v *float64) *UsageLogCreate
 	return _c
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (_c *UsageLogCreate) SetAccountRateMultiplier(v float64) *UsageLogCreate {
-	_c.mutation.SetAccountRateMultiplier(v)
-	return _c
-}
-
-// SetNillableAccountRateMultiplier sets the "account_rate_multiplier" field if the given value is not nil.
-func (_c *UsageLogCreate) SetNillableAccountRateMultiplier(v *float64) *UsageLogCreate {
-	if v != nil {
-		_c.SetAccountRateMultiplier(*v)
-	}
-	return _c
-}
-
 // SetBillingType sets the "billing_type" field.
 func (_c *UsageLogCreate) SetBillingType(v int8) *UsageLogCreate {
 	_c.mutation.SetBillingType(v)
@@ -337,62 +323,6 @@ func (_c *UsageLogCreate) SetNillableFirstTokenMs(v *int) *UsageLogCreate {
 	return _c
 }
 
-// SetUserAgent sets the "user_agent" field.
-func (_c *UsageLogCreate) SetUserAgent(v string) *UsageLogCreate {
-	_c.mutation.SetUserAgent(v)
-	return _c
-}
-
-// SetNillableUserAgent sets the "user_agent" field if the given value is not nil.
-func (_c *UsageLogCreate) SetNillableUserAgent(v *string) *UsageLogCreate {
-	if v != nil {
-		_c.SetUserAgent(*v)
-	}
-	return _c
-}
-
-// SetIPAddress sets the "ip_address" field.
-func (_c *UsageLogCreate) SetIPAddress(v string) *UsageLogCreate {
-	_c.mutation.SetIPAddress(v)
-	return _c
-}
-
-// SetNillableIPAddress sets the "ip_address" field if the given value is not nil.
-func (_c *UsageLogCreate) SetNillableIPAddress(v *string) *UsageLogCreate {
-	if v != nil {
-		_c.SetIPAddress(*v)
-	}
-	return _c
-}
-
-// SetImageCount sets the "image_count" field.
-func (_c *UsageLogCreate) SetImageCount(v int) *UsageLogCreate {
-	_c.mutation.SetImageCount(v)
-	return _c
-}
-
-// SetNillableImageCount sets the "image_count" field if the given value is not nil.
-func (_c *UsageLogCreate) SetNillableImageCount(v *int) *UsageLogCreate {
-	if v != nil {
-		_c.SetImageCount(*v)
-	}
-	return _c
-}
-
-// SetImageSize sets the "image_size" field.
-func (_c *UsageLogCreate) SetImageSize(v string) *UsageLogCreate {
-	_c.mutation.SetImageSize(v)
-	return _c
-}
-
-// SetNillableImageSize sets the "image_size" field if the given value is not nil.
-func (_c *UsageLogCreate) SetNillableImageSize(v *string) *UsageLogCreate {
-	if v != nil {
-		_c.SetImageSize(*v)
-	}
-	return _c
-}
-
 // SetCreatedAt sets the "created_at" field.
 func (_c *UsageLogCreate) SetCreatedAt(v time.Time) *UsageLogCreate {
 	_c.mutation.SetCreatedAt(v)
@@ -412,8 +342,8 @@ func (_c *UsageLogCreate) SetUser(v *User) *UsageLogCreate {
 	return _c.SetUserID(v.ID)
 }
 
-// SetAPIKey sets the "api_key" edge to the APIKey entity.
-func (_c *UsageLogCreate) SetAPIKey(v *APIKey) *UsageLogCreate {
+// SetAPIKey sets the "api_key" edge to the ApiKey entity.
+func (_c *UsageLogCreate) SetAPIKey(v *ApiKey) *UsageLogCreate {
 	return _c.SetAPIKeyID(v.ID)
 }
 
@@ -527,10 +457,6 @@ func (_c *UsageLogCreate) defaults() {
 		v := usagelog.DefaultStream
 		_c.mutation.SetStream(v)
 	}
-	if _, ok := _c.mutation.ImageCount(); !ok {
-		v := usagelog.DefaultImageCount
-		_c.mutation.SetImageCount(v)
-	}
 	if _, ok := _c.mutation.CreatedAt(); !ok {
 		v := usagelog.DefaultCreatedAt()
 		_c.mutation.SetCreatedAt(v)
@@ -609,24 +535,6 @@ func (_c *UsageLogCreate) check() error {
 	if _, ok := _c.mutation.Stream(); !ok {
 		return &ValidationError{Name: "stream", err: errors.New(`ent: missing required field "UsageLog.stream"`)}
 	}
-	if v, ok := _c.mutation.UserAgent(); ok {
-		if err := usagelog.UserAgentValidator(v); err != nil {
-			return &ValidationError{Name: "user_agent", err: fmt.Errorf(`ent: validator failed for field "UsageLog.user_agent": %w`, err)}
-		}
-	}
-	if v, ok := _c.mutation.IPAddress(); ok {
-		if err := usagelog.IPAddressValidator(v); err != nil {
-			return &ValidationError{Name: "ip_address", err: fmt.Errorf(`ent: validator failed for field "UsageLog.ip_address": %w`, err)}
-		}
-	}
-	if _, ok := _c.mutation.ImageCount(); !ok {
-		return &ValidationError{Name: "image_count", err: errors.New(`ent: missing required field "UsageLog.image_count"`)}
-	}
-	if v, ok := _c.mutation.ImageSize(); ok {
-		if err := usagelog.ImageSizeValidator(v); err != nil {
-			return &ValidationError{Name: "image_size", err: fmt.Errorf(`ent: validator failed for field "UsageLog.image_size": %w`, err)}
-		}
-	}
 	if _, ok := _c.mutation.CreatedAt(); !ok {
 		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "UsageLog.created_at"`)}
 	}
@@ -726,10 +634,6 @@ func (_c *UsageLogCreate) createSpec() (*UsageLog, *sqlgraph.CreateSpec) {
 		_spec.SetField(usagelog.FieldRateMultiplier, field.TypeFloat64, value)
 		_node.RateMultiplier = value
 	}
-	if value, ok := _c.mutation.AccountRateMultiplier(); ok {
-		_spec.SetField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-		_node.AccountRateMultiplier = &value
-	}
 	if value, ok := _c.mutation.BillingType(); ok {
 		_spec.SetField(usagelog.FieldBillingType, field.TypeInt8, value)
 		_node.BillingType = value
@@ -746,22 +650,6 @@ func (_c *UsageLogCreate) createSpec() (*UsageLog, *sqlgraph.CreateSpec) {
 		_spec.SetField(usagelog.FieldFirstTokenMs, field.TypeInt, value)
 		_node.FirstTokenMs = &value
 	}
-	if value, ok := _c.mutation.UserAgent(); ok {
-		_spec.SetField(usagelog.FieldUserAgent, field.TypeString, value)
-		_node.UserAgent = &value
-	}
-	if value, ok := _c.mutation.IPAddress(); ok {
-		_spec.SetField(usagelog.FieldIPAddress, field.TypeString, value)
-		_node.IPAddress = &value
-	}
-	if value, ok := _c.mutation.ImageCount(); ok {
-		_spec.SetField(usagelog.FieldImageCount, field.TypeInt, value)
-		_node.ImageCount = value
-	}
-	if value, ok := _c.mutation.ImageSize(); ok {
-		_spec.SetField(usagelog.FieldImageSize, field.TypeString, value)
-		_node.ImageSize = &value
-	}
 	if value, ok := _c.mutation.CreatedAt(); ok {
 		_spec.SetField(usagelog.FieldCreatedAt, field.TypeTime, value)
 		_node.CreatedAt = value
@@ -1233,30 +1121,6 @@ func (u *UsageLogUpsert) AddRateMultiplier(v float64) *UsageLogUpsert {
 	return u
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (u *UsageLogUpsert) SetAccountRateMultiplier(v float64) *UsageLogUpsert {
-	u.Set(usagelog.FieldAccountRateMultiplier, v)
-	return u
-}
-
-// UpdateAccountRateMultiplier sets the "account_rate_multiplier" field to the value that was provided on create.
-func (u *UsageLogUpsert) UpdateAccountRateMultiplier() *UsageLogUpsert {
-	u.SetExcluded(usagelog.FieldAccountRateMultiplier)
-	return u
-}
-
-// AddAccountRateMultiplier adds v to the "account_rate_multiplier" field.
-func (u *UsageLogUpsert) AddAccountRateMultiplier(v float64) *UsageLogUpsert {
-	u.Add(usagelog.FieldAccountRateMultiplier, v)
-	return u
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (u *UsageLogUpsert) ClearAccountRateMultiplier() *UsageLogUpsert {
-	u.SetNull(usagelog.FieldAccountRateMultiplier)
-	return u
-}
-
 // SetBillingType sets the "billing_type" field.
 func (u *UsageLogUpsert) SetBillingType(v int8) *UsageLogUpsert {
 	u.Set(usagelog.FieldBillingType, v)
@@ -1335,78 +1199,6 @@ func (u *UsageLogUpsert) ClearFirstTokenMs() *UsageLogUpsert {
 	return u
 }
 
-// SetUserAgent sets the "user_agent" field.
-func (u *UsageLogUpsert) SetUserAgent(v string) *UsageLogUpsert {
-	u.Set(usagelog.FieldUserAgent, v)
-	return u
-}
-
-// UpdateUserAgent sets the "user_agent" field to the value that was provided on create.
-func (u *UsageLogUpsert) UpdateUserAgent() *UsageLogUpsert {
-	u.SetExcluded(usagelog.FieldUserAgent)
-	return u
-}
-
-// ClearUserAgent clears the value of the "user_agent" field.
-func (u *UsageLogUpsert) ClearUserAgent() *UsageLogUpsert {
-	u.SetNull(usagelog.FieldUserAgent)
-	return u
-}
-
-// SetIPAddress sets the "ip_address" field.
-func (u *UsageLogUpsert) SetIPAddress(v string) *UsageLogUpsert {
-	u.Set(usagelog.FieldIPAddress, v)
-	return u
-}
-
-// UpdateIPAddress sets the "ip_address" field to the value that was provided on create.
-func (u *UsageLogUpsert) UpdateIPAddress() *UsageLogUpsert {
-	u.SetExcluded(usagelog.FieldIPAddress)
-	return u
-}
-
-// ClearIPAddress clears the value of the "ip_address" field.
-func (u *UsageLogUpsert) ClearIPAddress() *UsageLogUpsert {
-	u.SetNull(usagelog.FieldIPAddress)
-	return u
-}
-
-// SetImageCount sets the "image_count" field.
-func (u *UsageLogUpsert) SetImageCount(v int) *UsageLogUpsert {
-	u.Set(usagelog.FieldImageCount, v)
-	return u
-}
-
-// UpdateImageCount sets the "image_count" field to the value that was provided on create.
-func (u *UsageLogUpsert) UpdateImageCount() *UsageLogUpsert {
-	u.SetExcluded(usagelog.FieldImageCount)
-	return u
-}
-
-// AddImageCount adds v to the "image_count" field.
-func (u *UsageLogUpsert) AddImageCount(v int) *UsageLogUpsert {
-	u.Add(usagelog.FieldImageCount, v)
-	return u
-}
-
-// SetImageSize sets the "image_size" field.
-func (u *UsageLogUpsert) SetImageSize(v string) *UsageLogUpsert {
-	u.Set(usagelog.FieldImageSize, v)
-	return u
-}
-
-// UpdateImageSize sets the "image_size" field to the value that was provided on create.
-func (u *UsageLogUpsert) UpdateImageSize() *UsageLogUpsert {
-	u.SetExcluded(usagelog.FieldImageSize)
-	return u
-}
-
-// ClearImageSize clears the value of the "image_size" field.
-func (u *UsageLogUpsert) ClearImageSize() *UsageLogUpsert {
-	u.SetNull(usagelog.FieldImageSize)
-	return u
-}
-
 // UpdateNewValues updates the mutable fields using the new values that were set on create.
 // Using this option is equivalent to using:
 //
@@ -1837,34 +1629,6 @@ func (u *UsageLogUpsertOne) UpdateRateMultiplier() *UsageLogUpsertOne {
 	})
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (u *UsageLogUpsertOne) SetAccountRateMultiplier(v float64) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetAccountRateMultiplier(v)
-	})
-}
-
-// AddAccountRateMultiplier adds v to the "account_rate_multiplier" field.
-func (u *UsageLogUpsertOne) AddAccountRateMultiplier(v float64) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.AddAccountRateMultiplier(v)
-	})
-}
-
-// UpdateAccountRateMultiplier sets the "account_rate_multiplier" field to the value that was provided on create.
-func (u *UsageLogUpsertOne) UpdateAccountRateMultiplier() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateAccountRateMultiplier()
-	})
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (u *UsageLogUpsertOne) ClearAccountRateMultiplier() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearAccountRateMultiplier()
-	})
-}
-
 // SetBillingType sets the "billing_type" field.
 func (u *UsageLogUpsertOne) SetBillingType(v int8) *UsageLogUpsertOne {
 	return u.Update(func(s *UsageLogUpsert) {
@@ -1956,90 +1720,6 @@ func (u *UsageLogUpsertOne) ClearFirstTokenMs() *UsageLogUpsertOne {
 	})
 }
 
-// SetUserAgent sets the "user_agent" field.
-func (u *UsageLogUpsertOne) SetUserAgent(v string) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetUserAgent(v)
-	})
-}
-
-// UpdateUserAgent sets the "user_agent" field to the value that was provided on create.
-func (u *UsageLogUpsertOne) UpdateUserAgent() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateUserAgent()
-	})
-}
-
-// ClearUserAgent clears the value of the "user_agent" field.
-func (u *UsageLogUpsertOne) ClearUserAgent() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearUserAgent()
-	})
-}
-
-// SetIPAddress sets the "ip_address" field.
-func (u *UsageLogUpsertOne) SetIPAddress(v string) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetIPAddress(v)
-	})
-}
-
-// UpdateIPAddress sets the "ip_address" field to the value that was provided on create.
-func (u *UsageLogUpsertOne) UpdateIPAddress() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateIPAddress()
-	})
-}
-
-// ClearIPAddress clears the value of the "ip_address" field.
-func (u *UsageLogUpsertOne) ClearIPAddress() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearIPAddress()
-	})
-}
-
-// SetImageCount sets the "image_count" field.
-func (u *UsageLogUpsertOne) SetImageCount(v int) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetImageCount(v)
-	})
-}
-
-// AddImageCount adds v to the "image_count" field.
-func (u *UsageLogUpsertOne) AddImageCount(v int) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.AddImageCount(v)
-	})
-}
-
-// UpdateImageCount sets the "image_count" field to the value that was provided on create.
-func (u *UsageLogUpsertOne) UpdateImageCount() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateImageCount()
-	})
-}
-
-// SetImageSize sets the "image_size" field.
-func (u *UsageLogUpsertOne) SetImageSize(v string) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetImageSize(v)
-	})
-}
-
-// UpdateImageSize sets the "image_size" field to the value that was provided on create.
-func (u *UsageLogUpsertOne) UpdateImageSize() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateImageSize()
-	})
-}
-
-// ClearImageSize clears the value of the "image_size" field.
-func (u *UsageLogUpsertOne) ClearImageSize() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearImageSize()
-	})
-}
-
 // Exec executes the query.
 func (u *UsageLogUpsertOne) Exec(ctx context.Context) error {
 	if len(u.create.conflict) == 0 {
@@ -2636,34 +2316,6 @@ func (u *UsageLogUpsertBulk) UpdateRateMultiplier() *UsageLogUpsertBulk {
 	})
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (u *UsageLogUpsertBulk) SetAccountRateMultiplier(v float64) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetAccountRateMultiplier(v)
-	})
-}
-
-// AddAccountRateMultiplier adds v to the "account_rate_multiplier" field.
-func (u *UsageLogUpsertBulk) AddAccountRateMultiplier(v float64) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.AddAccountRateMultiplier(v)
-	})
-}
-
-// UpdateAccountRateMultiplier sets the "account_rate_multiplier" field to the value that was provided on create.
-func (u *UsageLogUpsertBulk) UpdateAccountRateMultiplier() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateAccountRateMultiplier()
-	})
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (u *UsageLogUpsertBulk) ClearAccountRateMultiplier() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearAccountRateMultiplier()
-	})
-}
-
 // SetBillingType sets the "billing_type" field.
 func (u *UsageLogUpsertBulk) SetBillingType(v int8) *UsageLogUpsertBulk {
 	return u.Update(func(s *UsageLogUpsert) {
@@ -2755,90 +2407,6 @@ func (u *UsageLogUpsertBulk) ClearFirstTokenMs() *UsageLogUpsertBulk {
 	})
 }
 
-// SetUserAgent sets the "user_agent" field.
-func (u *UsageLogUpsertBulk) SetUserAgent(v string) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetUserAgent(v)
-	})
-}
-
-// UpdateUserAgent sets the "user_agent" field to the value that was provided on create.
-func (u *UsageLogUpsertBulk) UpdateUserAgent() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateUserAgent()
-	})
-}
-
-// ClearUserAgent clears the value of the "user_agent" field.
-func (u *UsageLogUpsertBulk) ClearUserAgent() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearUserAgent()
-	})
-}
-
-// SetIPAddress sets the "ip_address" field.
-func (u *UsageLogUpsertBulk) SetIPAddress(v string) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetIPAddress(v)
-	})
-}
-
-// UpdateIPAddress sets the "ip_address" field to the value that was provided on create.
-func (u *UsageLogUpsertBulk) UpdateIPAddress() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateIPAddress()
-	})
-}
-
-// ClearIPAddress clears the value of the "ip_address" field.
-func (u *UsageLogUpsertBulk) ClearIPAddress() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearIPAddress()
-	})
-}
-
-// SetImageCount sets the "image_count" field.
-func (u *UsageLogUpsertBulk) SetImageCount(v int) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetImageCount(v)
-	})
-}
-
-// AddImageCount adds v to the "image_count" field.
-func (u *UsageLogUpsertBulk) AddImageCount(v int) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.AddImageCount(v)
-	})
-}
-
-// UpdateImageCount sets the "image_count" field to the value that was provided on create.
-func (u *UsageLogUpsertBulk) UpdateImageCount() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateImageCount()
-	})
-}
-
-// SetImageSize sets the "image_size" field.
-func (u *UsageLogUpsertBulk) SetImageSize(v string) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetImageSize(v)
-	})
-}
-
-// UpdateImageSize sets the "image_size" field to the value that was provided on create.
-func (u *UsageLogUpsertBulk) UpdateImageSize() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateImageSize()
-	})
-}
-
-// ClearImageSize clears the value of the "image_size" field.
-func (u *UsageLogUpsertBulk) ClearImageSize() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearImageSize()
-	})
-}
-
 // Exec executes the query.
 func (u *UsageLogUpsertBulk) Exec(ctx context.Context) error {
 	if u.create.err != nil {

backend/ent/usagelog_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"
@@ -29,11 +28,10 @@ type UsageLogQuery struct {
 	inters           []Interceptor
 	predicates       []predicate.UsageLog
 	withUser         *UserQuery
-	withAPIKey       *APIKeyQuery
+	withAPIKey       *ApiKeyQuery
 	withAccount      *AccountQuery
 	withGroup        *GroupQuery
 	withSubscription *UserSubscriptionQuery
-	modifiers        []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -93,8 +91,8 @@ func (_q *UsageLogQuery) QueryUser() *UserQuery {
 }
 
 // QueryAPIKey chains the current query on the "api_key" edge.
-func (_q *UsageLogQuery) QueryAPIKey() *APIKeyQuery {
-	query := (&APIKeyClient{config: _q.config}).Query()
+func (_q *UsageLogQuery) QueryAPIKey() *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
@@ -396,8 +394,8 @@ func (_q *UsageLogQuery) WithUser(opts ...func(*UserQuery)) *UsageLogQuery {
 
 // WithAPIKey tells the query-builder to eager-load the nodes that are connected to
 // the "api_key" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *UsageLogQuery) WithAPIKey(opts ...func(*APIKeyQuery)) *UsageLogQuery {
-	query := (&APIKeyClient{config: _q.config}).Query()
+func (_q *UsageLogQuery) WithAPIKey(opts ...func(*ApiKeyQuery)) *UsageLogQuery {
+	query := (&ApiKeyClient{config: _q.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -533,9 +531,6 @@ func (_q *UsageLogQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Usa
 		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)
 	}
@@ -553,7 +548,7 @@ func (_q *UsageLogQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Usa
 	}
 	if query := _q.withAPIKey; query != nil {
 		if err := _q.loadAPIKey(ctx, query, nodes, nil,
-			func(n *UsageLog, e *APIKey) { n.Edges.APIKey = e }); err != nil {
+			func(n *UsageLog, e *ApiKey) { n.Edges.APIKey = e }); err != nil {
 			return nil, err
 		}
 	}
@@ -607,7 +602,7 @@ func (_q *UsageLogQuery) loadUser(ctx context.Context, query *UserQuery, nodes [
 	}
 	return nil
 }
-func (_q *UsageLogQuery) loadAPIKey(ctx context.Context, query *APIKeyQuery, nodes []*UsageLog, init func(*UsageLog), assign func(*UsageLog, *APIKey)) error {
+func (_q *UsageLogQuery) loadAPIKey(ctx context.Context, query *ApiKeyQuery, nodes []*UsageLog, init func(*UsageLog), assign func(*UsageLog, *ApiKey)) error {
 	ids := make([]int64, 0, len(nodes))
 	nodeids := make(map[int64][]*UsageLog)
 	for i := range nodes {
@@ -732,9 +727,6 @@ func (_q *UsageLogQuery) loadSubscription(ctx context.Context, query *UserSubscr
 
 func (_q *UsageLogQuery) 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
@@ -812,9 +804,6 @@ func (_q *UsageLogQuery) 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)
 	}
@@ -832,32 +821,6 @@ func (_q *UsageLogQuery) 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 *UsageLogQuery) ForUpdate(opts ...sql.LockOption) *UsageLogQuery {
-	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 *UsageLogQuery) ForShare(opts ...sql.LockOption) *UsageLogQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // UsageLogGroupBy is the group-by builder for UsageLog entities.
 type UsageLogGroupBy struct {
 	selector

backend/ent/usagelog_update.go

@@ -415,33 +415,6 @@ func (_u *UsageLogUpdate) AddRateMultiplier(v float64) *UsageLogUpdate {
 	return _u
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (_u *UsageLogUpdate) SetAccountRateMultiplier(v float64) *UsageLogUpdate {
-	_u.mutation.ResetAccountRateMultiplier()
-	_u.mutation.SetAccountRateMultiplier(v)
-	return _u
-}
-
-// SetNillableAccountRateMultiplier sets the "account_rate_multiplier" field if the given value is not nil.
-func (_u *UsageLogUpdate) SetNillableAccountRateMultiplier(v *float64) *UsageLogUpdate {
-	if v != nil {
-		_u.SetAccountRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddAccountRateMultiplier adds value to the "account_rate_multiplier" field.
-func (_u *UsageLogUpdate) AddAccountRateMultiplier(v float64) *UsageLogUpdate {
-	_u.mutation.AddAccountRateMultiplier(v)
-	return _u
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (_u *UsageLogUpdate) ClearAccountRateMultiplier() *UsageLogUpdate {
-	_u.mutation.ClearAccountRateMultiplier()
-	return _u
-}
-
 // SetBillingType sets the "billing_type" field.
 func (_u *UsageLogUpdate) SetBillingType(v int8) *UsageLogUpdate {
 	_u.mutation.ResetBillingType()
@@ -531,94 +504,13 @@ func (_u *UsageLogUpdate) ClearFirstTokenMs() *UsageLogUpdate {
 	return _u
 }
 
-// SetUserAgent sets the "user_agent" field.
-func (_u *UsageLogUpdate) SetUserAgent(v string) *UsageLogUpdate {
-	_u.mutation.SetUserAgent(v)
-	return _u
-}
-
-// SetNillableUserAgent sets the "user_agent" field if the given value is not nil.
-func (_u *UsageLogUpdate) SetNillableUserAgent(v *string) *UsageLogUpdate {
-	if v != nil {
-		_u.SetUserAgent(*v)
-	}
-	return _u
-}
-
-// ClearUserAgent clears the value of the "user_agent" field.
-func (_u *UsageLogUpdate) ClearUserAgent() *UsageLogUpdate {
-	_u.mutation.ClearUserAgent()
-	return _u
-}
-
-// SetIPAddress sets the "ip_address" field.
-func (_u *UsageLogUpdate) SetIPAddress(v string) *UsageLogUpdate {
-	_u.mutation.SetIPAddress(v)
-	return _u
-}
-
-// SetNillableIPAddress sets the "ip_address" field if the given value is not nil.
-func (_u *UsageLogUpdate) SetNillableIPAddress(v *string) *UsageLogUpdate {
-	if v != nil {
-		_u.SetIPAddress(*v)
-	}
-	return _u
-}
-
-// ClearIPAddress clears the value of the "ip_address" field.
-func (_u *UsageLogUpdate) ClearIPAddress() *UsageLogUpdate {
-	_u.mutation.ClearIPAddress()
-	return _u
-}
-
-// SetImageCount sets the "image_count" field.
-func (_u *UsageLogUpdate) SetImageCount(v int) *UsageLogUpdate {
-	_u.mutation.ResetImageCount()
-	_u.mutation.SetImageCount(v)
-	return _u
-}
-
-// SetNillableImageCount sets the "image_count" field if the given value is not nil.
-func (_u *UsageLogUpdate) SetNillableImageCount(v *int) *UsageLogUpdate {
-	if v != nil {
-		_u.SetImageCount(*v)
-	}
-	return _u
-}
-
-// AddImageCount adds value to the "image_count" field.
-func (_u *UsageLogUpdate) AddImageCount(v int) *UsageLogUpdate {
-	_u.mutation.AddImageCount(v)
-	return _u
-}
-
-// SetImageSize sets the "image_size" field.
-func (_u *UsageLogUpdate) SetImageSize(v string) *UsageLogUpdate {
-	_u.mutation.SetImageSize(v)
-	return _u
-}
-
-// SetNillableImageSize sets the "image_size" field if the given value is not nil.
-func (_u *UsageLogUpdate) SetNillableImageSize(v *string) *UsageLogUpdate {
-	if v != nil {
-		_u.SetImageSize(*v)
-	}
-	return _u
-}
-
-// ClearImageSize clears the value of the "image_size" field.
-func (_u *UsageLogUpdate) ClearImageSize() *UsageLogUpdate {
-	_u.mutation.ClearImageSize()
-	return _u
-}
-
 // SetUser sets the "user" edge to the User entity.
 func (_u *UsageLogUpdate) SetUser(v *User) *UsageLogUpdate {
 	return _u.SetUserID(v.ID)
 }
 
-// SetAPIKey sets the "api_key" edge to the APIKey entity.
-func (_u *UsageLogUpdate) SetAPIKey(v *APIKey) *UsageLogUpdate {
+// SetAPIKey sets the "api_key" edge to the ApiKey entity.
+func (_u *UsageLogUpdate) SetAPIKey(v *ApiKey) *UsageLogUpdate {
 	return _u.SetAPIKeyID(v.ID)
 }
 
@@ -648,7 +540,7 @@ func (_u *UsageLogUpdate) ClearUser() *UsageLogUpdate {
 	return _u
 }
 
-// ClearAPIKey clears the "api_key" edge to the APIKey entity.
+// ClearAPIKey clears the "api_key" edge to the ApiKey entity.
 func (_u *UsageLogUpdate) ClearAPIKey() *UsageLogUpdate {
 	_u.mutation.ClearAPIKey()
 	return _u
@@ -711,21 +603,6 @@ func (_u *UsageLogUpdate) check() error {
 			return &ValidationError{Name: "model", err: fmt.Errorf(`ent: validator failed for field "UsageLog.model": %w`, err)}
 		}
 	}
-	if v, ok := _u.mutation.UserAgent(); ok {
-		if err := usagelog.UserAgentValidator(v); err != nil {
-			return &ValidationError{Name: "user_agent", err: fmt.Errorf(`ent: validator failed for field "UsageLog.user_agent": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.IPAddress(); ok {
-		if err := usagelog.IPAddressValidator(v); err != nil {
-			return &ValidationError{Name: "ip_address", err: fmt.Errorf(`ent: validator failed for field "UsageLog.ip_address": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.ImageSize(); ok {
-		if err := usagelog.ImageSizeValidator(v); err != nil {
-			return &ValidationError{Name: "image_size", err: fmt.Errorf(`ent: validator failed for field "UsageLog.image_size": %w`, err)}
-		}
-	}
 	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
 		return errors.New(`ent: clearing a required unique edge "UsageLog.user"`)
 	}
@@ -834,15 +711,6 @@ func (_u *UsageLogUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
 		_spec.AddField(usagelog.FieldRateMultiplier, field.TypeFloat64, value)
 	}
-	if value, ok := _u.mutation.AccountRateMultiplier(); ok {
-		_spec.SetField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedAccountRateMultiplier(); ok {
-		_spec.AddField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if _u.mutation.AccountRateMultiplierCleared() {
-		_spec.ClearField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64)
-	}
 	if value, ok := _u.mutation.BillingType(); ok {
 		_spec.SetField(usagelog.FieldBillingType, field.TypeInt8, value)
 	}
@@ -870,30 +738,6 @@ func (_u *UsageLogUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if _u.mutation.FirstTokenMsCleared() {
 		_spec.ClearField(usagelog.FieldFirstTokenMs, field.TypeInt)
 	}
-	if value, ok := _u.mutation.UserAgent(); ok {
-		_spec.SetField(usagelog.FieldUserAgent, field.TypeString, value)
-	}
-	if _u.mutation.UserAgentCleared() {
-		_spec.ClearField(usagelog.FieldUserAgent, field.TypeString)
-	}
-	if value, ok := _u.mutation.IPAddress(); ok {
-		_spec.SetField(usagelog.FieldIPAddress, field.TypeString, value)
-	}
-	if _u.mutation.IPAddressCleared() {
-		_spec.ClearField(usagelog.FieldIPAddress, field.TypeString)
-	}
-	if value, ok := _u.mutation.ImageCount(); ok {
-		_spec.SetField(usagelog.FieldImageCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedImageCount(); ok {
-		_spec.AddField(usagelog.FieldImageCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.ImageSize(); ok {
-		_spec.SetField(usagelog.FieldImageSize, field.TypeString, value)
-	}
-	if _u.mutation.ImageSizeCleared() {
-		_spec.ClearField(usagelog.FieldImageSize, field.TypeString)
-	}
 	if _u.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,
@@ -1442,33 +1286,6 @@ func (_u *UsageLogUpdateOne) AddRateMultiplier(v float64) *UsageLogUpdateOne {
 	return _u
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (_u *UsageLogUpdateOne) SetAccountRateMultiplier(v float64) *UsageLogUpdateOne {
-	_u.mutation.ResetAccountRateMultiplier()
-	_u.mutation.SetAccountRateMultiplier(v)
-	return _u
-}
-
-// SetNillableAccountRateMultiplier sets the "account_rate_multiplier" field if the given value is not nil.
-func (_u *UsageLogUpdateOne) SetNillableAccountRateMultiplier(v *float64) *UsageLogUpdateOne {
-	if v != nil {
-		_u.SetAccountRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddAccountRateMultiplier adds value to the "account_rate_multiplier" field.
-func (_u *UsageLogUpdateOne) AddAccountRateMultiplier(v float64) *UsageLogUpdateOne {
-	_u.mutation.AddAccountRateMultiplier(v)
-	return _u
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (_u *UsageLogUpdateOne) ClearAccountRateMultiplier() *UsageLogUpdateOne {
-	_u.mutation.ClearAccountRateMultiplier()
-	return _u
-}
-
 // SetBillingType sets the "billing_type" field.
 func (_u *UsageLogUpdateOne) SetBillingType(v int8) *UsageLogUpdateOne {
 	_u.mutation.ResetBillingType()
@@ -1558,94 +1375,13 @@ func (_u *UsageLogUpdateOne) ClearFirstTokenMs() *UsageLogUpdateOne {
 	return _u
 }
 
-// SetUserAgent sets the "user_agent" field.
-func (_u *UsageLogUpdateOne) SetUserAgent(v string) *UsageLogUpdateOne {
-	_u.mutation.SetUserAgent(v)
-	return _u
-}
-
-// SetNillableUserAgent sets the "user_agent" field if the given value is not nil.
-func (_u *UsageLogUpdateOne) SetNillableUserAgent(v *string) *UsageLogUpdateOne {
-	if v != nil {
-		_u.SetUserAgent(*v)
-	}
-	return _u
-}
-
-// ClearUserAgent clears the value of the "user_agent" field.
-func (_u *UsageLogUpdateOne) ClearUserAgent() *UsageLogUpdateOne {
-	_u.mutation.ClearUserAgent()
-	return _u
-}
-
-// SetIPAddress sets the "ip_address" field.
-func (_u *UsageLogUpdateOne) SetIPAddress(v string) *UsageLogUpdateOne {
-	_u.mutation.SetIPAddress(v)
-	return _u
-}
-
-// SetNillableIPAddress sets the "ip_address" field if the given value is not nil.
-func (_u *UsageLogUpdateOne) SetNillableIPAddress(v *string) *UsageLogUpdateOne {
-	if v != nil {
-		_u.SetIPAddress(*v)
-	}
-	return _u
-}
-
-// ClearIPAddress clears the value of the "ip_address" field.
-func (_u *UsageLogUpdateOne) ClearIPAddress() *UsageLogUpdateOne {
-	_u.mutation.ClearIPAddress()
-	return _u
-}
-
-// SetImageCount sets the "image_count" field.
-func (_u *UsageLogUpdateOne) SetImageCount(v int) *UsageLogUpdateOne {
-	_u.mutation.ResetImageCount()
-	_u.mutation.SetImageCount(v)
-	return _u
-}
-
-// SetNillableImageCount sets the "image_count" field if the given value is not nil.
-func (_u *UsageLogUpdateOne) SetNillableImageCount(v *int) *UsageLogUpdateOne {
-	if v != nil {
-		_u.SetImageCount(*v)
-	}
-	return _u
-}
-
-// AddImageCount adds value to the "image_count" field.
-func (_u *UsageLogUpdateOne) AddImageCount(v int) *UsageLogUpdateOne {
-	_u.mutation.AddImageCount(v)
-	return _u
-}
-
-// SetImageSize sets the "image_size" field.
-func (_u *UsageLogUpdateOne) SetImageSize(v string) *UsageLogUpdateOne {
-	_u.mutation.SetImageSize(v)
-	return _u
-}
-
-// SetNillableImageSize sets the "image_size" field if the given value is not nil.
-func (_u *UsageLogUpdateOne) SetNillableImageSize(v *string) *UsageLogUpdateOne {
-	if v != nil {
-		_u.SetImageSize(*v)
-	}
-	return _u
-}
-
-// ClearImageSize clears the value of the "image_size" field.
-func (_u *UsageLogUpdateOne) ClearImageSize() *UsageLogUpdateOne {
-	_u.mutation.ClearImageSize()
-	return _u
-}
-
 // SetUser sets the "user" edge to the User entity.
 func (_u *UsageLogUpdateOne) SetUser(v *User) *UsageLogUpdateOne {
 	return _u.SetUserID(v.ID)
 }
 
-// SetAPIKey sets the "api_key" edge to the APIKey entity.
-func (_u *UsageLogUpdateOne) SetAPIKey(v *APIKey) *UsageLogUpdateOne {
+// SetAPIKey sets the "api_key" edge to the ApiKey entity.
+func (_u *UsageLogUpdateOne) SetAPIKey(v *ApiKey) *UsageLogUpdateOne {
 	return _u.SetAPIKeyID(v.ID)
 }
 
@@ -1675,7 +1411,7 @@ func (_u *UsageLogUpdateOne) ClearUser() *UsageLogUpdateOne {
 	return _u
 }
 
-// ClearAPIKey clears the "api_key" edge to the APIKey entity.
+// ClearAPIKey clears the "api_key" edge to the ApiKey entity.
 func (_u *UsageLogUpdateOne) ClearAPIKey() *UsageLogUpdateOne {
 	_u.mutation.ClearAPIKey()
 	return _u
@@ -1751,21 +1487,6 @@ func (_u *UsageLogUpdateOne) check() error {
 			return &ValidationError{Name: "model", err: fmt.Errorf(`ent: validator failed for field "UsageLog.model": %w`, err)}
 		}
 	}
-	if v, ok := _u.mutation.UserAgent(); ok {
-		if err := usagelog.UserAgentValidator(v); err != nil {
-			return &ValidationError{Name: "user_agent", err: fmt.Errorf(`ent: validator failed for field "UsageLog.user_agent": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.IPAddress(); ok {
-		if err := usagelog.IPAddressValidator(v); err != nil {
-			return &ValidationError{Name: "ip_address", err: fmt.Errorf(`ent: validator failed for field "UsageLog.ip_address": %w`, err)}
-		}
-	}
-	if v, ok := _u.mutation.ImageSize(); ok {
-		if err := usagelog.ImageSizeValidator(v); err != nil {
-			return &ValidationError{Name: "image_size", err: fmt.Errorf(`ent: validator failed for field "UsageLog.image_size": %w`, err)}
-		}
-	}
 	if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
 		return errors.New(`ent: clearing a required unique edge "UsageLog.user"`)
 	}
@@ -1891,15 +1612,6 @@ func (_u *UsageLogUpdateOne) sqlSave(ctx context.Context) (_node *UsageLog, err
 	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
 		_spec.AddField(usagelog.FieldRateMultiplier, field.TypeFloat64, value)
 	}
-	if value, ok := _u.mutation.AccountRateMultiplier(); ok {
-		_spec.SetField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedAccountRateMultiplier(); ok {
-		_spec.AddField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if _u.mutation.AccountRateMultiplierCleared() {
-		_spec.ClearField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64)
-	}
 	if value, ok := _u.mutation.BillingType(); ok {
 		_spec.SetField(usagelog.FieldBillingType, field.TypeInt8, value)
 	}
@@ -1927,30 +1639,6 @@ func (_u *UsageLogUpdateOne) sqlSave(ctx context.Context) (_node *UsageLog, err
 	if _u.mutation.FirstTokenMsCleared() {
 		_spec.ClearField(usagelog.FieldFirstTokenMs, field.TypeInt)
 	}
-	if value, ok := _u.mutation.UserAgent(); ok {
-		_spec.SetField(usagelog.FieldUserAgent, field.TypeString, value)
-	}
-	if _u.mutation.UserAgentCleared() {
-		_spec.ClearField(usagelog.FieldUserAgent, field.TypeString)
-	}
-	if value, ok := _u.mutation.IPAddress(); ok {
-		_spec.SetField(usagelog.FieldIPAddress, field.TypeString, value)
-	}
-	if _u.mutation.IPAddressCleared() {
-		_spec.ClearField(usagelog.FieldIPAddress, field.TypeString)
-	}
-	if value, ok := _u.mutation.ImageCount(); ok {
-		_spec.SetField(usagelog.FieldImageCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.AddedImageCount(); ok {
-		_spec.AddField(usagelog.FieldImageCount, field.TypeInt, value)
-	}
-	if value, ok := _u.mutation.ImageSize(); ok {
-		_spec.SetField(usagelog.FieldImageSize, field.TypeString, value)
-	}
-	if _u.mutation.ImageSizeCleared() {
-		_spec.ClearField(usagelog.FieldImageSize, field.TypeString)
-	}
 	if _u.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.M2O,

backend/ent/user.go

@@ -37,6 +37,8 @@ type User struct {
 	Status string `json:"status,omitempty"`
 	// Username holds the value of the "username" field.
 	Username string `json:"username,omitempty"`
+	// Wechat holds the value of the "wechat" field.
+	Wechat string `json:"wechat,omitempty"`
 	// Notes holds the value of the "notes" field.
 	Notes string `json:"notes,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -48,7 +50,7 @@ type User struct {
 // UserEdges holds the relations/edges for other nodes in the graph.
 type UserEdges 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.
@@ -59,20 +61,16 @@ type UserEdges struct {
 	AllowedGroups []*Group `json:"allowed_groups,omitempty"`
 	// UsageLogs holds the value of the usage_logs edge.
 	UsageLogs []*UsageLog `json:"usage_logs,omitempty"`
-	// AttributeValues holds the value of the attribute_values edge.
-	AttributeValues []*UserAttributeValue `json:"attribute_values,omitempty"`
-	// PromoCodeUsages holds the value of the promo_code_usages edge.
-	PromoCodeUsages []*PromoCodeUsage `json:"promo_code_usages,omitempty"`
 	// UserAllowedGroups holds the value of the user_allowed_groups edge.
 	UserAllowedGroups []*UserAllowedGroup `json:"user_allowed_groups,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [9]bool
+	loadedTypes [7]bool
 }
 
 // APIKeysOrErr returns the APIKeys value or an error if the edge
 // was not loaded in eager-loading.
-func (e UserEdges) APIKeysOrErr() ([]*APIKey, error) {
+func (e UserEdges) APIKeysOrErr() ([]*ApiKey, error) {
 	if e.loadedTypes[0] {
 		return e.APIKeys, nil
 	}
@@ -124,28 +122,10 @@ func (e UserEdges) UsageLogsOrErr() ([]*UsageLog, error) {
 	return nil, &NotLoadedError{edge: "usage_logs"}
 }
 
-// AttributeValuesOrErr returns the AttributeValues value or an error if the edge
-// was not loaded in eager-loading.
-func (e UserEdges) AttributeValuesOrErr() ([]*UserAttributeValue, error) {
-	if e.loadedTypes[6] {
-		return e.AttributeValues, nil
-	}
-	return nil, &NotLoadedError{edge: "attribute_values"}
-}
-
-// PromoCodeUsagesOrErr returns the PromoCodeUsages value or an error if the edge
-// was not loaded in eager-loading.
-func (e UserEdges) PromoCodeUsagesOrErr() ([]*PromoCodeUsage, error) {
-	if e.loadedTypes[7] {
-		return e.PromoCodeUsages, nil
-	}
-	return nil, &NotLoadedError{edge: "promo_code_usages"}
-}
-
 // UserAllowedGroupsOrErr returns the UserAllowedGroups value or an error if the edge
 // was not loaded in eager-loading.
 func (e UserEdges) UserAllowedGroupsOrErr() ([]*UserAllowedGroup, error) {
-	if e.loadedTypes[8] {
+	if e.loadedTypes[6] {
 		return e.UserAllowedGroups, nil
 	}
 	return nil, &NotLoadedError{edge: "user_allowed_groups"}
@@ -160,7 +140,7 @@ func (*User) scanValues(columns []string) ([]any, error) {
 			values[i] = new(sql.NullFloat64)
 		case user.FieldID, user.FieldConcurrency:
 			values[i] = new(sql.NullInt64)
-		case user.FieldEmail, user.FieldPasswordHash, user.FieldRole, user.FieldStatus, user.FieldUsername, user.FieldNotes:
+		case user.FieldEmail, user.FieldPasswordHash, user.FieldRole, user.FieldStatus, user.FieldUsername, user.FieldWechat, user.FieldNotes:
 			values[i] = new(sql.NullString)
 		case user.FieldCreatedAt, user.FieldUpdatedAt, user.FieldDeletedAt:
 			values[i] = new(sql.NullTime)
@@ -246,6 +226,12 @@ func (_m *User) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.Username = value.String
 			}
+		case user.FieldWechat:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field wechat", values[i])
+			} else if value.Valid {
+				_m.Wechat = value.String
+			}
 		case user.FieldNotes:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field notes", values[i])
@@ -266,7 +252,7 @@ func (_m *User) Value(name string) (ent.Value, error) {
 }
 
 // QueryAPIKeys queries the "api_keys" edge of the User entity.
-func (_m *User) QueryAPIKeys() *APIKeyQuery {
+func (_m *User) QueryAPIKeys() *ApiKeyQuery {
 	return NewUserClient(_m.config).QueryAPIKeys(_m)
 }
 
@@ -295,16 +281,6 @@ func (_m *User) QueryUsageLogs() *UsageLogQuery {
 	return NewUserClient(_m.config).QueryUsageLogs(_m)
 }
 
-// QueryAttributeValues queries the "attribute_values" edge of the User entity.
-func (_m *User) QueryAttributeValues() *UserAttributeValueQuery {
-	return NewUserClient(_m.config).QueryAttributeValues(_m)
-}
-
-// QueryPromoCodeUsages queries the "promo_code_usages" edge of the User entity.
-func (_m *User) QueryPromoCodeUsages() *PromoCodeUsageQuery {
-	return NewUserClient(_m.config).QueryPromoCodeUsages(_m)
-}
-
 // QueryUserAllowedGroups queries the "user_allowed_groups" edge of the User entity.
 func (_m *User) QueryUserAllowedGroups() *UserAllowedGroupQuery {
 	return NewUserClient(_m.config).QueryUserAllowedGroups(_m)
@@ -365,6 +341,9 @@ func (_m *User) String() string {
 	builder.WriteString("username=")
 	builder.WriteString(_m.Username)
 	builder.WriteString(", ")
+	builder.WriteString("wechat=")
+	builder.WriteString(_m.Wechat)
+	builder.WriteString(", ")
 	builder.WriteString("notes=")
 	builder.WriteString(_m.Notes)
 	builder.WriteByte(')')

backend/ent/user/user.go

@@ -35,6 +35,8 @@ const (
 	FieldStatus = "status"
 	// FieldUsername holds the string denoting the username field in the database.
 	FieldUsername = "username"
+	// FieldWechat holds the string denoting the wechat field in the database.
+	FieldWechat = "wechat"
 	// FieldNotes holds the string denoting the notes field in the database.
 	FieldNotes = "notes"
 	// EdgeAPIKeys holds the string denoting the api_keys edge name in mutations.
@@ -49,17 +51,13 @@ const (
 	EdgeAllowedGroups = "allowed_groups"
 	// EdgeUsageLogs holds the string denoting the usage_logs edge name in mutations.
 	EdgeUsageLogs = "usage_logs"
-	// EdgeAttributeValues holds the string denoting the attribute_values edge name in mutations.
-	EdgeAttributeValues = "attribute_values"
-	// EdgePromoCodeUsages holds the string denoting the promo_code_usages edge name in mutations.
-	EdgePromoCodeUsages = "promo_code_usages"
 	// EdgeUserAllowedGroups holds the string denoting the user_allowed_groups edge name in mutations.
 	EdgeUserAllowedGroups = "user_allowed_groups"
 	// Table holds the table name of the user in the database.
 	Table = "users"
 	// 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.
@@ -97,20 +95,6 @@ const (
 	UsageLogsInverseTable = "usage_logs"
 	// UsageLogsColumn is the table column denoting the usage_logs relation/edge.
 	UsageLogsColumn = "user_id"
-	// AttributeValuesTable is the table that holds the attribute_values relation/edge.
-	AttributeValuesTable = "user_attribute_values"
-	// AttributeValuesInverseTable is the table name for the UserAttributeValue entity.
-	// It exists in this package in order to avoid circular dependency with the "userattributevalue" package.
-	AttributeValuesInverseTable = "user_attribute_values"
-	// AttributeValuesColumn is the table column denoting the attribute_values relation/edge.
-	AttributeValuesColumn = "user_id"
-	// PromoCodeUsagesTable is the table that holds the promo_code_usages relation/edge.
-	PromoCodeUsagesTable = "promo_code_usages"
-	// PromoCodeUsagesInverseTable is the table name for the PromoCodeUsage entity.
-	// It exists in this package in order to avoid circular dependency with the "promocodeusage" package.
-	PromoCodeUsagesInverseTable = "promo_code_usages"
-	// PromoCodeUsagesColumn is the table column denoting the promo_code_usages relation/edge.
-	PromoCodeUsagesColumn = "user_id"
 	// UserAllowedGroupsTable is the table that holds the user_allowed_groups relation/edge.
 	UserAllowedGroupsTable = "user_allowed_groups"
 	// UserAllowedGroupsInverseTable is the table name for the UserAllowedGroup entity.
@@ -133,6 +117,7 @@ var Columns = []string{
 	FieldConcurrency,
 	FieldStatus,
 	FieldUsername,
+	FieldWechat,
 	FieldNotes,
 }
 
@@ -186,6 +171,10 @@ var (
 	DefaultUsername string
 	// UsernameValidator is a validator for the "username" field. It is called by the builders before save.
 	UsernameValidator func(string) error
+	// DefaultWechat holds the default value on creation for the "wechat" field.
+	DefaultWechat string
+	// WechatValidator is a validator for the "wechat" field. It is called by the builders before save.
+	WechatValidator func(string) error
 	// DefaultNotes holds the default value on creation for the "notes" field.
 	DefaultNotes string
 )
@@ -248,6 +237,11 @@ func ByUsername(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldUsername, opts...).ToFunc()
 }
 
+// ByWechat orders the results by the wechat field.
+func ByWechat(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldWechat, opts...).ToFunc()
+}
+
 // ByNotes orders the results by the notes field.
 func ByNotes(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldNotes, opts...).ToFunc()
@@ -337,34 +331,6 @@ func ByUsageLogs(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 	}
 }
 
-// ByAttributeValuesCount orders the results by attribute_values count.
-func ByAttributeValuesCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newAttributeValuesStep(), opts...)
-	}
-}
-
-// ByAttributeValues orders the results by attribute_values terms.
-func ByAttributeValues(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newAttributeValuesStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-
-// ByPromoCodeUsagesCount orders the results by promo_code_usages count.
-func ByPromoCodeUsagesCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newPromoCodeUsagesStep(), opts...)
-	}
-}
-
-// ByPromoCodeUsages orders the results by promo_code_usages terms.
-func ByPromoCodeUsages(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newPromoCodeUsagesStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-
 // ByUserAllowedGroupsCount orders the results by user_allowed_groups count.
 func ByUserAllowedGroupsCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
@@ -420,20 +386,6 @@ func newUsageLogsStep() *sqlgraph.Step {
 		sqlgraph.Edge(sqlgraph.O2M, false, UsageLogsTable, UsageLogsColumn),
 	)
 }
-func newAttributeValuesStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(AttributeValuesInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, AttributeValuesTable, AttributeValuesColumn),
-	)
-}
-func newPromoCodeUsagesStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(PromoCodeUsagesInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, PromoCodeUsagesTable, PromoCodeUsagesColumn),
-	)
-}
 func newUserAllowedGroupsStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),

backend/ent/user/where.go

@@ -105,6 +105,11 @@ func Username(v string) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldUsername, v))
 }
 
+// Wechat applies equality check predicate on the "wechat" field. It's identical to WechatEQ.
+func Wechat(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldWechat, v))
+}
+
 // Notes applies equality check predicate on the "notes" field. It's identical to NotesEQ.
 func Notes(v string) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldNotes, v))
@@ -645,6 +650,71 @@ func UsernameContainsFold(v string) predicate.User {
 	return predicate.User(sql.FieldContainsFold(FieldUsername, v))
 }
 
+// WechatEQ applies the EQ predicate on the "wechat" field.
+func WechatEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldWechat, v))
+}
+
+// WechatNEQ applies the NEQ predicate on the "wechat" field.
+func WechatNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldWechat, v))
+}
+
+// WechatIn applies the In predicate on the "wechat" field.
+func WechatIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldWechat, vs...))
+}
+
+// WechatNotIn applies the NotIn predicate on the "wechat" field.
+func WechatNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldWechat, vs...))
+}
+
+// WechatGT applies the GT predicate on the "wechat" field.
+func WechatGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldWechat, v))
+}
+
+// WechatGTE applies the GTE predicate on the "wechat" field.
+func WechatGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldWechat, v))
+}
+
+// WechatLT applies the LT predicate on the "wechat" field.
+func WechatLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldWechat, v))
+}
+
+// WechatLTE applies the LTE predicate on the "wechat" field.
+func WechatLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldWechat, v))
+}
+
+// WechatContains applies the Contains predicate on the "wechat" field.
+func WechatContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldWechat, v))
+}
+
+// WechatHasPrefix applies the HasPrefix predicate on the "wechat" field.
+func WechatHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldWechat, v))
+}
+
+// WechatHasSuffix applies the HasSuffix predicate on the "wechat" field.
+func WechatHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldWechat, v))
+}
+
+// WechatEqualFold applies the EqualFold predicate on the "wechat" field.
+func WechatEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldWechat, v))
+}
+
+// WechatContainsFold applies the ContainsFold predicate on the "wechat" field.
+func WechatContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldWechat, v))
+}
+
 // NotesEQ applies the EQ predicate on the "notes" field.
 func NotesEQ(v string) predicate.User {
 	return predicate.User(sql.FieldEQ(FieldNotes, v))
@@ -722,7 +792,7 @@ func HasAPIKeys() predicate.User {
 }
 
 // HasAPIKeysWith applies the HasEdge predicate on the "api_keys" edge with a given conditions (other predicates).
-func HasAPIKeysWith(preds ...predicate.APIKey) predicate.User {
+func HasAPIKeysWith(preds ...predicate.ApiKey) predicate.User {
 	return predicate.User(func(s *sql.Selector) {
 		step := newAPIKeysStep()
 		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
@@ -848,52 +918,6 @@ func HasUsageLogsWith(preds ...predicate.UsageLog) predicate.User {
 	})
 }
 
-// HasAttributeValues applies the HasEdge predicate on the "attribute_values" edge.
-func HasAttributeValues() predicate.User {
-	return predicate.User(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, AttributeValuesTable, AttributeValuesColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasAttributeValuesWith applies the HasEdge predicate on the "attribute_values" edge with a given conditions (other predicates).
-func HasAttributeValuesWith(preds ...predicate.UserAttributeValue) predicate.User {
-	return predicate.User(func(s *sql.Selector) {
-		step := newAttributeValuesStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// HasPromoCodeUsages applies the HasEdge predicate on the "promo_code_usages" edge.
-func HasPromoCodeUsages() predicate.User {
-	return predicate.User(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, PromoCodeUsagesTable, PromoCodeUsagesColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasPromoCodeUsagesWith applies the HasEdge predicate on the "promo_code_usages" edge with a given conditions (other predicates).
-func HasPromoCodeUsagesWith(preds ...predicate.PromoCodeUsage) predicate.User {
-	return predicate.User(func(s *sql.Selector) {
-		step := newPromoCodeUsagesStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
 // HasUserAllowedGroups applies the HasEdge predicate on the "user_allowed_groups" edge.
 func HasUserAllowedGroups() predicate.User {
 	return predicate.User(func(s *sql.Selector) {

backend/ent/user_create.go

@@ -13,11 +13,9 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
 	"github.com/Wei-Shaw/sub2api/ent/group"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
 	"github.com/Wei-Shaw/sub2api/ent/redeemcode"
 	"github.com/Wei-Shaw/sub2api/ent/usagelog"
 	"github.com/Wei-Shaw/sub2api/ent/user"
-	"github.com/Wei-Shaw/sub2api/ent/userattributevalue"
 	"github.com/Wei-Shaw/sub2api/ent/usersubscription"
 )
 
@@ -153,6 +151,20 @@ func (_c *UserCreate) SetNillableUsername(v *string) *UserCreate {
 	return _c
 }
 
+// SetWechat sets the "wechat" field.
+func (_c *UserCreate) SetWechat(v string) *UserCreate {
+	_c.mutation.SetWechat(v)
+	return _c
+}
+
+// SetNillableWechat sets the "wechat" field if the given value is not nil.
+func (_c *UserCreate) SetNillableWechat(v *string) *UserCreate {
+	if v != nil {
+		_c.SetWechat(*v)
+	}
+	return _c
+}
+
 // SetNotes sets the "notes" field.
 func (_c *UserCreate) SetNotes(v string) *UserCreate {
 	_c.mutation.SetNotes(v)
@@ -167,14 +179,14 @@ func (_c *UserCreate) SetNillableNotes(v *string) *UserCreate {
 	return _c
 }
 
-// AddAPIKeyIDs adds the "api_keys" edge to the APIKey entity by IDs.
+// AddAPIKeyIDs adds the "api_keys" edge to the ApiKey entity by IDs.
 func (_c *UserCreate) AddAPIKeyIDs(ids ...int64) *UserCreate {
 	_c.mutation.AddAPIKeyIDs(ids...)
 	return _c
 }
 
-// AddAPIKeys adds the "api_keys" edges to the APIKey entity.
-func (_c *UserCreate) AddAPIKeys(v ...*APIKey) *UserCreate {
+// AddAPIKeys adds the "api_keys" edges to the ApiKey entity.
+func (_c *UserCreate) AddAPIKeys(v ...*ApiKey) *UserCreate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -257,36 +269,6 @@ func (_c *UserCreate) AddUsageLogs(v ...*UsageLog) *UserCreate {
 	return _c.AddUsageLogIDs(ids...)
 }
 
-// AddAttributeValueIDs adds the "attribute_values" edge to the UserAttributeValue entity by IDs.
-func (_c *UserCreate) AddAttributeValueIDs(ids ...int64) *UserCreate {
-	_c.mutation.AddAttributeValueIDs(ids...)
-	return _c
-}
-
-// AddAttributeValues adds the "attribute_values" edges to the UserAttributeValue entity.
-func (_c *UserCreate) AddAttributeValues(v ...*UserAttributeValue) *UserCreate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _c.AddAttributeValueIDs(ids...)
-}
-
-// AddPromoCodeUsageIDs adds the "promo_code_usages" edge to the PromoCodeUsage entity by IDs.
-func (_c *UserCreate) AddPromoCodeUsageIDs(ids ...int64) *UserCreate {
-	_c.mutation.AddPromoCodeUsageIDs(ids...)
-	return _c
-}
-
-// AddPromoCodeUsages adds the "promo_code_usages" edges to the PromoCodeUsage entity.
-func (_c *UserCreate) AddPromoCodeUsages(v ...*PromoCodeUsage) *UserCreate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _c.AddPromoCodeUsageIDs(ids...)
-}
-
 // Mutation returns the UserMutation object of the builder.
 func (_c *UserCreate) Mutation() *UserMutation {
 	return _c.mutation
@@ -358,6 +340,10 @@ func (_c *UserCreate) defaults() error {
 		v := user.DefaultUsername
 		_c.mutation.SetUsername(v)
 	}
+	if _, ok := _c.mutation.Wechat(); !ok {
+		v := user.DefaultWechat
+		_c.mutation.SetWechat(v)
+	}
 	if _, ok := _c.mutation.Notes(); !ok {
 		v := user.DefaultNotes
 		_c.mutation.SetNotes(v)
@@ -419,6 +405,14 @@ func (_c *UserCreate) check() error {
 			return &ValidationError{Name: "username", err: fmt.Errorf(`ent: validator failed for field "User.username": %w`, err)}
 		}
 	}
+	if _, ok := _c.mutation.Wechat(); !ok {
+		return &ValidationError{Name: "wechat", err: errors.New(`ent: missing required field "User.wechat"`)}
+	}
+	if v, ok := _c.mutation.Wechat(); ok {
+		if err := user.WechatValidator(v); err != nil {
+			return &ValidationError{Name: "wechat", err: fmt.Errorf(`ent: validator failed for field "User.wechat": %w`, err)}
+		}
+	}
 	if _, ok := _c.mutation.Notes(); !ok {
 		return &ValidationError{Name: "notes", err: errors.New(`ent: missing required field "User.notes"`)}
 	}
@@ -489,6 +483,10 @@ func (_c *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		_spec.SetField(user.FieldUsername, field.TypeString, value)
 		_node.Username = value
 	}
+	if value, ok := _c.mutation.Wechat(); ok {
+		_spec.SetField(user.FieldWechat, field.TypeString, value)
+		_node.Wechat = value
+	}
 	if value, ok := _c.mutation.Notes(); ok {
 		_spec.SetField(user.FieldNotes, field.TypeString, value)
 		_node.Notes = value
@@ -593,38 +591,6 @@ func (_c *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
-	if nodes := _c.mutation.AttributeValuesIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.AttributeValuesTable,
-			Columns: []string{user.AttributeValuesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(userattributevalue.FieldID, field.TypeInt64),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	if nodes := _c.mutation.PromoCodeUsagesIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.PromoCodeUsagesTable,
-			Columns: []string{user.PromoCodeUsagesColumn},
-			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 = append(_spec.Edges, edge)
-	}
 	return _node, _spec
 }
 
@@ -803,6 +769,18 @@ func (u *UserUpsert) UpdateUsername() *UserUpsert {
 	return u
 }
 
+// SetWechat sets the "wechat" field.
+func (u *UserUpsert) SetWechat(v string) *UserUpsert {
+	u.Set(user.FieldWechat, v)
+	return u
+}
+
+// UpdateWechat sets the "wechat" field to the value that was provided on create.
+func (u *UserUpsert) UpdateWechat() *UserUpsert {
+	u.SetExcluded(user.FieldWechat)
+	return u
+}
+
 // SetNotes sets the "notes" field.
 func (u *UserUpsert) SetNotes(v string) *UserUpsert {
 	u.Set(user.FieldNotes, v)
@@ -1007,6 +985,20 @@ func (u *UserUpsertOne) UpdateUsername() *UserUpsertOne {
 	})
 }
 
+// SetWechat sets the "wechat" field.
+func (u *UserUpsertOne) SetWechat(v string) *UserUpsertOne {
+	return u.Update(func(s *UserUpsert) {
+		s.SetWechat(v)
+	})
+}
+
+// UpdateWechat sets the "wechat" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateWechat() *UserUpsertOne {
+	return u.Update(func(s *UserUpsert) {
+		s.UpdateWechat()
+	})
+}
+
 // SetNotes sets the "notes" field.
 func (u *UserUpsertOne) SetNotes(v string) *UserUpsertOne {
 	return u.Update(func(s *UserUpsert) {
@@ -1379,6 +1371,20 @@ func (u *UserUpsertBulk) UpdateUsername() *UserUpsertBulk {
 	})
 }
 
+// SetWechat sets the "wechat" field.
+func (u *UserUpsertBulk) SetWechat(v string) *UserUpsertBulk {
+	return u.Update(func(s *UserUpsert) {
+		s.SetWechat(v)
+	})
+}
+
+// UpdateWechat sets the "wechat" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateWechat() *UserUpsertBulk {
+	return u.Update(func(s *UserUpsert) {
+		s.UpdateWechat()
+	})
+}
+
 // SetNotes sets the "notes" field.
 func (u *UserUpsertBulk) SetNotes(v string) *UserUpsertBulk {
 	return u.Update(func(s *UserUpsert) {

backend/ent/user_query.go

@@ -9,19 +9,16 @@ 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"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
 	"github.com/Wei-Shaw/sub2api/ent/group"
 	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
 	"github.com/Wei-Shaw/sub2api/ent/redeemcode"
 	"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/userattributevalue"
 	"github.com/Wei-Shaw/sub2api/ent/usersubscription"
 )
 
@@ -32,16 +29,13 @@ type UserQuery struct {
 	order                     []user.OrderOption
 	inters                    []Interceptor
 	predicates                []predicate.User
-	withAPIKeys               *APIKeyQuery
+	withAPIKeys               *ApiKeyQuery
 	withRedeemCodes           *RedeemCodeQuery
 	withSubscriptions         *UserSubscriptionQuery
 	withAssignedSubscriptions *UserSubscriptionQuery
 	withAllowedGroups         *GroupQuery
 	withUsageLogs             *UsageLogQuery
-	withAttributeValues       *UserAttributeValueQuery
-	withPromoCodeUsages       *PromoCodeUsageQuery
 	withUserAllowedGroups     *UserAllowedGroupQuery
-	modifiers                 []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -79,8 +73,8 @@ func (_q *UserQuery) Order(o ...user.OrderOption) *UserQuery {
 }
 
 // QueryAPIKeys chains the current query on the "api_keys" edge.
-func (_q *UserQuery) QueryAPIKeys() *APIKeyQuery {
-	query := (&APIKeyClient{config: _q.config}).Query()
+func (_q *UserQuery) 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
@@ -210,50 +204,6 @@ func (_q *UserQuery) QueryUsageLogs() *UsageLogQuery {
 	return query
 }
 
-// QueryAttributeValues chains the current query on the "attribute_values" edge.
-func (_q *UserQuery) QueryAttributeValues() *UserAttributeValueQuery {
-	query := (&UserAttributeValueClient{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(user.Table, user.FieldID, selector),
-			sqlgraph.To(userattributevalue.Table, userattributevalue.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, user.AttributeValuesTable, user.AttributeValuesColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// QueryPromoCodeUsages chains the current query on the "promo_code_usages" edge.
-func (_q *UserQuery) QueryPromoCodeUsages() *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(user.Table, user.FieldID, selector),
-			sqlgraph.To(promocodeusage.Table, promocodeusage.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, user.PromoCodeUsagesTable, user.PromoCodeUsagesColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
 // QueryUserAllowedGroups chains the current query on the "user_allowed_groups" edge.
 func (_q *UserQuery) QueryUserAllowedGroups() *UserAllowedGroupQuery {
 	query := (&UserAllowedGroupClient{config: _q.config}).Query()
@@ -474,8 +424,6 @@ func (_q *UserQuery) Clone() *UserQuery {
 		withAssignedSubscriptions: _q.withAssignedSubscriptions.Clone(),
 		withAllowedGroups:         _q.withAllowedGroups.Clone(),
 		withUsageLogs:             _q.withUsageLogs.Clone(),
-		withAttributeValues:       _q.withAttributeValues.Clone(),
-		withPromoCodeUsages:       _q.withPromoCodeUsages.Clone(),
 		withUserAllowedGroups:     _q.withUserAllowedGroups.Clone(),
 		// clone intermediate query.
 		sql:  _q.sql.Clone(),
@@ -485,8 +433,8 @@ func (_q *UserQuery) Clone() *UserQuery {
 
 // 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 *UserQuery) WithAPIKeys(opts ...func(*APIKeyQuery)) *UserQuery {
-	query := (&APIKeyClient{config: _q.config}).Query()
+func (_q *UserQuery) WithAPIKeys(opts ...func(*ApiKeyQuery)) *UserQuery {
+	query := (&ApiKeyClient{config: _q.config}).Query()
 	for _, opt := range opts {
 		opt(query)
 	}
@@ -549,28 +497,6 @@ func (_q *UserQuery) WithUsageLogs(opts ...func(*UsageLogQuery)) *UserQuery {
 	return _q
 }
 
-// WithAttributeValues tells the query-builder to eager-load the nodes that are connected to
-// the "attribute_values" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *UserQuery) WithAttributeValues(opts ...func(*UserAttributeValueQuery)) *UserQuery {
-	query := (&UserAttributeValueClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withAttributeValues = query
-	return _q
-}
-
-// WithPromoCodeUsages tells the query-builder to eager-load the nodes that are connected to
-// the "promo_code_usages" edge. The optional arguments are used to configure the query builder of the edge.
-func (_q *UserQuery) WithPromoCodeUsages(opts ...func(*PromoCodeUsageQuery)) *UserQuery {
-	query := (&PromoCodeUsageClient{config: _q.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	_q.withPromoCodeUsages = query
-	return _q
-}
-
 // WithUserAllowedGroups tells the query-builder to eager-load the nodes that are connected to
 // the "user_allowed_groups" edge. The optional arguments are used to configure the query builder of the edge.
 func (_q *UserQuery) WithUserAllowedGroups(opts ...func(*UserAllowedGroupQuery)) *UserQuery {
@@ -660,15 +586,13 @@ func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 	var (
 		nodes       = []*User{}
 		_spec       = _q.querySpec()
-		loadedTypes = [9]bool{
+		loadedTypes = [7]bool{
 			_q.withAPIKeys != nil,
 			_q.withRedeemCodes != nil,
 			_q.withSubscriptions != nil,
 			_q.withAssignedSubscriptions != nil,
 			_q.withAllowedGroups != nil,
 			_q.withUsageLogs != nil,
-			_q.withAttributeValues != nil,
-			_q.withPromoCodeUsages != nil,
 			_q.withUserAllowedGroups != nil,
 		}
 	)
@@ -681,9 +605,6 @@ func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 		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,8 +616,8 @@ func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 	}
 	if query := _q.withAPIKeys; query != nil {
 		if err := _q.loadAPIKeys(ctx, query, nodes,
-			func(n *User) { n.Edges.APIKeys = []*APIKey{} },
-			func(n *User, e *APIKey) { n.Edges.APIKeys = append(n.Edges.APIKeys, e) }); err != nil {
+			func(n *User) { n.Edges.APIKeys = []*ApiKey{} },
+			func(n *User, e *ApiKey) { n.Edges.APIKeys = append(n.Edges.APIKeys, e) }); err != nil {
 			return nil, err
 		}
 	}
@@ -737,20 +658,6 @@ func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 			return nil, err
 		}
 	}
-	if query := _q.withAttributeValues; query != nil {
-		if err := _q.loadAttributeValues(ctx, query, nodes,
-			func(n *User) { n.Edges.AttributeValues = []*UserAttributeValue{} },
-			func(n *User, e *UserAttributeValue) { n.Edges.AttributeValues = append(n.Edges.AttributeValues, e) }); err != nil {
-			return nil, err
-		}
-	}
-	if query := _q.withPromoCodeUsages; query != nil {
-		if err := _q.loadPromoCodeUsages(ctx, query, nodes,
-			func(n *User) { n.Edges.PromoCodeUsages = []*PromoCodeUsage{} },
-			func(n *User, e *PromoCodeUsage) { n.Edges.PromoCodeUsages = append(n.Edges.PromoCodeUsages, e) }); err != nil {
-			return nil, err
-		}
-	}
 	if query := _q.withUserAllowedGroups; query != nil {
 		if err := _q.loadUserAllowedGroups(ctx, query, nodes,
 			func(n *User) { n.Edges.UserAllowedGroups = []*UserAllowedGroup{} },
@@ -761,7 +668,7 @@ func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 	return nodes, nil
 }
 
-func (_q *UserQuery) loadAPIKeys(ctx context.Context, query *APIKeyQuery, nodes []*User, init func(*User), assign func(*User, *APIKey)) error {
+func (_q *UserQuery) loadAPIKeys(ctx context.Context, query *ApiKeyQuery, nodes []*User, init func(*User), assign func(*User, *ApiKey)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[int64]*User)
 	for i := range nodes {
@@ -774,7 +681,7 @@ func (_q *UserQuery) loadAPIKeys(ctx context.Context, query *APIKeyQuery, nodes
 	if len(query.ctx.Fields) > 0 {
 		query.ctx.AppendFieldOnce(apikey.FieldUserID)
 	}
-	query.Where(predicate.APIKey(func(s *sql.Selector) {
+	query.Where(predicate.ApiKey(func(s *sql.Selector) {
 		s.Where(sql.InValues(s.C(user.APIKeysColumn), fks...))
 	}))
 	neighbors, err := query.All(ctx)
@@ -978,66 +885,6 @@ func (_q *UserQuery) loadUsageLogs(ctx context.Context, query *UsageLogQuery, no
 	}
 	return nil
 }
-func (_q *UserQuery) loadAttributeValues(ctx context.Context, query *UserAttributeValueQuery, nodes []*User, init func(*User), assign func(*User, *UserAttributeValue)) error {
-	fks := make([]driver.Value, 0, len(nodes))
-	nodeids := make(map[int64]*User)
-	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(userattributevalue.FieldUserID)
-	}
-	query.Where(predicate.UserAttributeValue(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(user.AttributeValuesColumn), fks...))
-	}))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		fk := n.UserID
-		node, ok := nodeids[fk]
-		if !ok {
-			return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
-		}
-		assign(node, n)
-	}
-	return nil
-}
-func (_q *UserQuery) loadPromoCodeUsages(ctx context.Context, query *PromoCodeUsageQuery, nodes []*User, init func(*User), assign func(*User, *PromoCodeUsage)) error {
-	fks := make([]driver.Value, 0, len(nodes))
-	nodeids := make(map[int64]*User)
-	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.FieldUserID)
-	}
-	query.Where(predicate.PromoCodeUsage(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(user.PromoCodeUsagesColumn), fks...))
-	}))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		fk := n.UserID
-		node, ok := nodeids[fk]
-		if !ok {
-			return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
-		}
-		assign(node, n)
-	}
-	return nil
-}
 func (_q *UserQuery) loadUserAllowedGroups(ctx context.Context, query *UserAllowedGroupQuery, nodes []*User, init func(*User), assign func(*User, *UserAllowedGroup)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[int64]*User)
@@ -1071,9 +918,6 @@ func (_q *UserQuery) loadUserAllowedGroups(ctx context.Context, query *UserAllow
 
 func (_q *UserQuery) 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
@@ -1136,9 +980,6 @@ func (_q *UserQuery) 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)
 	}
@@ -1156,32 +997,6 @@ func (_q *UserQuery) 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 *UserQuery) ForUpdate(opts ...sql.LockOption) *UserQuery {
-	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 *UserQuery) ForShare(opts ...sql.LockOption) *UserQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // UserGroupBy is the group-by builder for User entities.
 type UserGroupBy struct {
 	selector

backend/ent/user_update.go

@@ -14,11 +14,9 @@ import (
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
 	"github.com/Wei-Shaw/sub2api/ent/group"
 	"github.com/Wei-Shaw/sub2api/ent/predicate"
-	"github.com/Wei-Shaw/sub2api/ent/promocodeusage"
 	"github.com/Wei-Shaw/sub2api/ent/redeemcode"
 	"github.com/Wei-Shaw/sub2api/ent/usagelog"
 	"github.com/Wei-Shaw/sub2api/ent/user"
-	"github.com/Wei-Shaw/sub2api/ent/userattributevalue"
 	"github.com/Wei-Shaw/sub2api/ent/usersubscription"
 )
 
@@ -173,6 +171,20 @@ func (_u *UserUpdate) SetNillableUsername(v *string) *UserUpdate {
 	return _u
 }
 
+// SetWechat sets the "wechat" field.
+func (_u *UserUpdate) SetWechat(v string) *UserUpdate {
+	_u.mutation.SetWechat(v)
+	return _u
+}
+
+// SetNillableWechat sets the "wechat" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableWechat(v *string) *UserUpdate {
+	if v != nil {
+		_u.SetWechat(*v)
+	}
+	return _u
+}
+
 // SetNotes sets the "notes" field.
 func (_u *UserUpdate) SetNotes(v string) *UserUpdate {
 	_u.mutation.SetNotes(v)
@@ -187,14 +199,14 @@ func (_u *UserUpdate) SetNillableNotes(v *string) *UserUpdate {
 	return _u
 }
 
-// AddAPIKeyIDs adds the "api_keys" edge to the APIKey entity by IDs.
+// AddAPIKeyIDs adds the "api_keys" edge to the ApiKey entity by IDs.
 func (_u *UserUpdate) AddAPIKeyIDs(ids ...int64) *UserUpdate {
 	_u.mutation.AddAPIKeyIDs(ids...)
 	return _u
 }
 
-// AddAPIKeys adds the "api_keys" edges to the APIKey entity.
-func (_u *UserUpdate) AddAPIKeys(v ...*APIKey) *UserUpdate {
+// AddAPIKeys adds the "api_keys" edges to the ApiKey entity.
+func (_u *UserUpdate) AddAPIKeys(v ...*ApiKey) *UserUpdate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -277,55 +289,25 @@ func (_u *UserUpdate) AddUsageLogs(v ...*UsageLog) *UserUpdate {
 	return _u.AddUsageLogIDs(ids...)
 }
 
-// AddAttributeValueIDs adds the "attribute_values" edge to the UserAttributeValue entity by IDs.
-func (_u *UserUpdate) AddAttributeValueIDs(ids ...int64) *UserUpdate {
-	_u.mutation.AddAttributeValueIDs(ids...)
-	return _u
-}
-
-// AddAttributeValues adds the "attribute_values" edges to the UserAttributeValue entity.
-func (_u *UserUpdate) AddAttributeValues(v ...*UserAttributeValue) *UserUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddAttributeValueIDs(ids...)
-}
-
-// AddPromoCodeUsageIDs adds the "promo_code_usages" edge to the PromoCodeUsage entity by IDs.
-func (_u *UserUpdate) AddPromoCodeUsageIDs(ids ...int64) *UserUpdate {
-	_u.mutation.AddPromoCodeUsageIDs(ids...)
-	return _u
-}
-
-// AddPromoCodeUsages adds the "promo_code_usages" edges to the PromoCodeUsage entity.
-func (_u *UserUpdate) AddPromoCodeUsages(v ...*PromoCodeUsage) *UserUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddPromoCodeUsageIDs(ids...)
-}
-
 // Mutation returns the UserMutation object of the builder.
 func (_u *UserUpdate) Mutation() *UserMutation {
 	return _u.mutation
 }
 
-// ClearAPIKeys clears all "api_keys" edges to the APIKey entity.
+// ClearAPIKeys clears all "api_keys" edges to the ApiKey entity.
 func (_u *UserUpdate) ClearAPIKeys() *UserUpdate {
 	_u.mutation.ClearAPIKeys()
 	return _u
 }
 
-// RemoveAPIKeyIDs removes the "api_keys" edge to APIKey entities by IDs.
+// RemoveAPIKeyIDs removes the "api_keys" edge to ApiKey entities by IDs.
 func (_u *UserUpdate) RemoveAPIKeyIDs(ids ...int64) *UserUpdate {
 	_u.mutation.RemoveAPIKeyIDs(ids...)
 	return _u
 }
 
-// RemoveAPIKeys removes "api_keys" edges to APIKey entities.
-func (_u *UserUpdate) RemoveAPIKeys(v ...*APIKey) *UserUpdate {
+// RemoveAPIKeys removes "api_keys" edges to ApiKey entities.
+func (_u *UserUpdate) RemoveAPIKeys(v ...*ApiKey) *UserUpdate {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -438,48 +420,6 @@ func (_u *UserUpdate) RemoveUsageLogs(v ...*UsageLog) *UserUpdate {
 	return _u.RemoveUsageLogIDs(ids...)
 }
 
-// ClearAttributeValues clears all "attribute_values" edges to the UserAttributeValue entity.
-func (_u *UserUpdate) ClearAttributeValues() *UserUpdate {
-	_u.mutation.ClearAttributeValues()
-	return _u
-}
-
-// RemoveAttributeValueIDs removes the "attribute_values" edge to UserAttributeValue entities by IDs.
-func (_u *UserUpdate) RemoveAttributeValueIDs(ids ...int64) *UserUpdate {
-	_u.mutation.RemoveAttributeValueIDs(ids...)
-	return _u
-}
-
-// RemoveAttributeValues removes "attribute_values" edges to UserAttributeValue entities.
-func (_u *UserUpdate) RemoveAttributeValues(v ...*UserAttributeValue) *UserUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemoveAttributeValueIDs(ids...)
-}
-
-// ClearPromoCodeUsages clears all "promo_code_usages" edges to the PromoCodeUsage entity.
-func (_u *UserUpdate) ClearPromoCodeUsages() *UserUpdate {
-	_u.mutation.ClearPromoCodeUsages()
-	return _u
-}
-
-// RemovePromoCodeUsageIDs removes the "promo_code_usages" edge to PromoCodeUsage entities by IDs.
-func (_u *UserUpdate) RemovePromoCodeUsageIDs(ids ...int64) *UserUpdate {
-	_u.mutation.RemovePromoCodeUsageIDs(ids...)
-	return _u
-}
-
-// RemovePromoCodeUsages removes "promo_code_usages" edges to PromoCodeUsage entities.
-func (_u *UserUpdate) RemovePromoCodeUsages(v ...*PromoCodeUsage) *UserUpdate {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemovePromoCodeUsageIDs(ids...)
-}
-
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (_u *UserUpdate) Save(ctx context.Context) (int, error) {
 	if err := _u.defaults(); err != nil {
@@ -549,6 +489,11 @@ func (_u *UserUpdate) check() error {
 			return &ValidationError{Name: "username", err: fmt.Errorf(`ent: validator failed for field "User.username": %w`, err)}
 		}
 	}
+	if v, ok := _u.mutation.Wechat(); ok {
+		if err := user.WechatValidator(v); err != nil {
+			return &ValidationError{Name: "wechat", err: fmt.Errorf(`ent: validator failed for field "User.wechat": %w`, err)}
+		}
+	}
 	return nil
 }
 
@@ -600,6 +545,9 @@ func (_u *UserUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.Username(); ok {
 		_spec.SetField(user.FieldUsername, field.TypeString, value)
 	}
+	if value, ok := _u.mutation.Wechat(); ok {
+		_spec.SetField(user.FieldWechat, field.TypeString, value)
+	}
 	if value, ok := _u.mutation.Notes(); ok {
 		_spec.SetField(user.FieldNotes, field.TypeString, value)
 	}
@@ -885,96 +833,6 @@ func (_u *UserUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if _u.mutation.AttributeValuesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.AttributeValuesTable,
-			Columns: []string{user.AttributeValuesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(userattributevalue.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedAttributeValuesIDs(); len(nodes) > 0 && !_u.mutation.AttributeValuesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.AttributeValuesTable,
-			Columns: []string{user.AttributeValuesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(userattributevalue.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.AttributeValuesIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.AttributeValuesTable,
-			Columns: []string{user.AttributeValuesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(userattributevalue.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.PromoCodeUsagesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.PromoCodeUsagesTable,
-			Columns: []string{user.PromoCodeUsagesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedPromoCodeUsagesIDs(); len(nodes) > 0 && !_u.mutation.PromoCodeUsagesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.PromoCodeUsagesTable,
-			Columns: []string{user.PromoCodeUsagesColumn},
-			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.PromoCodeUsagesIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.PromoCodeUsagesTable,
-			Columns: []string{user.PromoCodeUsagesColumn},
-			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{user.Label}
@@ -1133,6 +991,20 @@ func (_u *UserUpdateOne) SetNillableUsername(v *string) *UserUpdateOne {
 	return _u
 }
 
+// SetWechat sets the "wechat" field.
+func (_u *UserUpdateOne) SetWechat(v string) *UserUpdateOne {
+	_u.mutation.SetWechat(v)
+	return _u
+}
+
+// SetNillableWechat sets the "wechat" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableWechat(v *string) *UserUpdateOne {
+	if v != nil {
+		_u.SetWechat(*v)
+	}
+	return _u
+}
+
 // SetNotes sets the "notes" field.
 func (_u *UserUpdateOne) SetNotes(v string) *UserUpdateOne {
 	_u.mutation.SetNotes(v)
@@ -1147,14 +1019,14 @@ func (_u *UserUpdateOne) SetNillableNotes(v *string) *UserUpdateOne {
 	return _u
 }
 
-// AddAPIKeyIDs adds the "api_keys" edge to the APIKey entity by IDs.
+// AddAPIKeyIDs adds the "api_keys" edge to the ApiKey entity by IDs.
 func (_u *UserUpdateOne) AddAPIKeyIDs(ids ...int64) *UserUpdateOne {
 	_u.mutation.AddAPIKeyIDs(ids...)
 	return _u
 }
 
-// AddAPIKeys adds the "api_keys" edges to the APIKey entity.
-func (_u *UserUpdateOne) AddAPIKeys(v ...*APIKey) *UserUpdateOne {
+// AddAPIKeys adds the "api_keys" edges to the ApiKey entity.
+func (_u *UserUpdateOne) AddAPIKeys(v ...*ApiKey) *UserUpdateOne {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -1237,55 +1109,25 @@ func (_u *UserUpdateOne) AddUsageLogs(v ...*UsageLog) *UserUpdateOne {
 	return _u.AddUsageLogIDs(ids...)
 }
 
-// AddAttributeValueIDs adds the "attribute_values" edge to the UserAttributeValue entity by IDs.
-func (_u *UserUpdateOne) AddAttributeValueIDs(ids ...int64) *UserUpdateOne {
-	_u.mutation.AddAttributeValueIDs(ids...)
-	return _u
-}
-
-// AddAttributeValues adds the "attribute_values" edges to the UserAttributeValue entity.
-func (_u *UserUpdateOne) AddAttributeValues(v ...*UserAttributeValue) *UserUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddAttributeValueIDs(ids...)
-}
-
-// AddPromoCodeUsageIDs adds the "promo_code_usages" edge to the PromoCodeUsage entity by IDs.
-func (_u *UserUpdateOne) AddPromoCodeUsageIDs(ids ...int64) *UserUpdateOne {
-	_u.mutation.AddPromoCodeUsageIDs(ids...)
-	return _u
-}
-
-// AddPromoCodeUsages adds the "promo_code_usages" edges to the PromoCodeUsage entity.
-func (_u *UserUpdateOne) AddPromoCodeUsages(v ...*PromoCodeUsage) *UserUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.AddPromoCodeUsageIDs(ids...)
-}
-
 // Mutation returns the UserMutation object of the builder.
 func (_u *UserUpdateOne) Mutation() *UserMutation {
 	return _u.mutation
 }
 
-// ClearAPIKeys clears all "api_keys" edges to the APIKey entity.
+// ClearAPIKeys clears all "api_keys" edges to the ApiKey entity.
 func (_u *UserUpdateOne) ClearAPIKeys() *UserUpdateOne {
 	_u.mutation.ClearAPIKeys()
 	return _u
 }
 
-// RemoveAPIKeyIDs removes the "api_keys" edge to APIKey entities by IDs.
+// RemoveAPIKeyIDs removes the "api_keys" edge to ApiKey entities by IDs.
 func (_u *UserUpdateOne) RemoveAPIKeyIDs(ids ...int64) *UserUpdateOne {
 	_u.mutation.RemoveAPIKeyIDs(ids...)
 	return _u
 }
 
-// RemoveAPIKeys removes "api_keys" edges to APIKey entities.
-func (_u *UserUpdateOne) RemoveAPIKeys(v ...*APIKey) *UserUpdateOne {
+// RemoveAPIKeys removes "api_keys" edges to ApiKey entities.
+func (_u *UserUpdateOne) RemoveAPIKeys(v ...*ApiKey) *UserUpdateOne {
 	ids := make([]int64, len(v))
 	for i := range v {
 		ids[i] = v[i].ID
@@ -1398,48 +1240,6 @@ func (_u *UserUpdateOne) RemoveUsageLogs(v ...*UsageLog) *UserUpdateOne {
 	return _u.RemoveUsageLogIDs(ids...)
 }
 
-// ClearAttributeValues clears all "attribute_values" edges to the UserAttributeValue entity.
-func (_u *UserUpdateOne) ClearAttributeValues() *UserUpdateOne {
-	_u.mutation.ClearAttributeValues()
-	return _u
-}
-
-// RemoveAttributeValueIDs removes the "attribute_values" edge to UserAttributeValue entities by IDs.
-func (_u *UserUpdateOne) RemoveAttributeValueIDs(ids ...int64) *UserUpdateOne {
-	_u.mutation.RemoveAttributeValueIDs(ids...)
-	return _u
-}
-
-// RemoveAttributeValues removes "attribute_values" edges to UserAttributeValue entities.
-func (_u *UserUpdateOne) RemoveAttributeValues(v ...*UserAttributeValue) *UserUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemoveAttributeValueIDs(ids...)
-}
-
-// ClearPromoCodeUsages clears all "promo_code_usages" edges to the PromoCodeUsage entity.
-func (_u *UserUpdateOne) ClearPromoCodeUsages() *UserUpdateOne {
-	_u.mutation.ClearPromoCodeUsages()
-	return _u
-}
-
-// RemovePromoCodeUsageIDs removes the "promo_code_usages" edge to PromoCodeUsage entities by IDs.
-func (_u *UserUpdateOne) RemovePromoCodeUsageIDs(ids ...int64) *UserUpdateOne {
-	_u.mutation.RemovePromoCodeUsageIDs(ids...)
-	return _u
-}
-
-// RemovePromoCodeUsages removes "promo_code_usages" edges to PromoCodeUsage entities.
-func (_u *UserUpdateOne) RemovePromoCodeUsages(v ...*PromoCodeUsage) *UserUpdateOne {
-	ids := make([]int64, len(v))
-	for i := range v {
-		ids[i] = v[i].ID
-	}
-	return _u.RemovePromoCodeUsageIDs(ids...)
-}
-
 // Where appends a list predicates to the UserUpdate builder.
 func (_u *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
 	_u.mutation.Where(ps...)
@@ -1522,6 +1322,11 @@ func (_u *UserUpdateOne) check() error {
 			return &ValidationError{Name: "username", err: fmt.Errorf(`ent: validator failed for field "User.username": %w`, err)}
 		}
 	}
+	if v, ok := _u.mutation.Wechat(); ok {
+		if err := user.WechatValidator(v); err != nil {
+			return &ValidationError{Name: "wechat", err: fmt.Errorf(`ent: validator failed for field "User.wechat": %w`, err)}
+		}
+	}
 	return nil
 }
 
@@ -1590,6 +1395,9 @@ func (_u *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) {
 	if value, ok := _u.mutation.Username(); ok {
 		_spec.SetField(user.FieldUsername, field.TypeString, value)
 	}
+	if value, ok := _u.mutation.Wechat(); ok {
+		_spec.SetField(user.FieldWechat, field.TypeString, value)
+	}
 	if value, ok := _u.mutation.Notes(); ok {
 		_spec.SetField(user.FieldNotes, field.TypeString, value)
 	}
@@ -1875,96 +1683,6 @@ func (_u *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
-	if _u.mutation.AttributeValuesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.AttributeValuesTable,
-			Columns: []string{user.AttributeValuesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(userattributevalue.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedAttributeValuesIDs(); len(nodes) > 0 && !_u.mutation.AttributeValuesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.AttributeValuesTable,
-			Columns: []string{user.AttributeValuesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(userattributevalue.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.AttributeValuesIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.AttributeValuesTable,
-			Columns: []string{user.AttributeValuesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(userattributevalue.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.PromoCodeUsagesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.PromoCodeUsagesTable,
-			Columns: []string{user.PromoCodeUsagesColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(promocodeusage.FieldID, field.TypeInt64),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := _u.mutation.RemovedPromoCodeUsagesIDs(); len(nodes) > 0 && !_u.mutation.PromoCodeUsagesCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.PromoCodeUsagesTable,
-			Columns: []string{user.PromoCodeUsagesColumn},
-			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.PromoCodeUsagesIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   user.PromoCodeUsagesTable,
-			Columns: []string{user.PromoCodeUsagesColumn},
-			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 = &User{config: _u.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues

backend/ent/userallowedgroup_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/group"
@@ -26,7 +25,6 @@ type UserAllowedGroupQuery struct {
 	predicates []predicate.UserAllowedGroup
 	withUser   *UserQuery
 	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 *UserAllowedGroupQuery) 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 *UserAllowedGroupQuery) loadGroup(ctx context.Context, query *GroupQuer
 
 func (_q *UserAllowedGroupQuery) 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 *UserAllowedGroupQuery) 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 *UserAllowedGroupQuery) 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 *UserAllowedGroupQuery) ForUpdate(opts ...sql.LockOption) *UserAllowedGroupQuery {
-	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 *UserAllowedGroupQuery) ForShare(opts ...sql.LockOption) *UserAllowedGroupQuery {
-	if _q.driver.Dialect() == dialect.Postgres {
-		_q.Unique(false)
-	}
-	_q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
-		s.ForShare(opts...)
-	})
-	return _q
-}
-
 // UserAllowedGroupGroupBy is the group-by builder for UserAllowedGroup entities.
 type UserAllowedGroupGroupBy struct {
 	selector