inkreachhub/inkreach-official-website
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(deploy): production deployment setup and fixes

Browse Source 
- Debian-based api image (bookworm-slim), docker/debian mirrors, prisma
  binaryTargets for openssl 3.0
- nginx: admin SPA under /admin, TLS via acme.sh (ZeroSSL) + auto-renewal
  cron, http->https redirect
- prisma: add origin_goods.delisted migration, sync missing schema
  (good_image/tag_font_color/good_tags), fix users.createdAt Timestamptz
- api: CORS wildcard reflection, helmet CORP cross-origin, price
  backfill in persistProductDetail, categoryIcon ancestor fallback,
  mediaByColor per-color gallery in public goods detail
- admin: /admin base path (vite + router)
- import-data.mjs: udt_name casting, serial sequence advance fix
This commit is contained in:
yeuimu
2026-08-26 14:23:09 +08:00
parent be0b90e68f
commit 6c61a4e871
982 changed files with 74156 additions and 179393 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.agents/skills/prisma-postgres/references/console-and-connections.md
-67
View File
@@ -1,67 +0,0 @@
# console-and-connections
Use Prisma Console workflows for project visibility, data inspection, and connection setup.
## Priority
HIGH
## Why It Matters
Many Prisma Postgres tasks are quickest in the Console: viewing Studio data, checking metrics, and retrieving connection details. This avoids unnecessary API or CLI work for simple operational tasks.
## Console workflow
1. Open `https://console.prisma.io`.
2. Select workspace and project.
3. Use dashboard metrics for usage and billing visibility.
4. Open the **Studio** tab in the sidebar to inspect and edit data.
## Local Studio
You can also inspect data locally:
```bash
npx prisma studio
```
## Linking an existing project
If the Prisma Postgres database already exists, link the local project instead of provisioning a new one:
```bash
prisma postgres link
```
For CI or non-interactive usage:
```bash
prisma postgres link --api-key "<your-api-key>" --database "db_..."
```
This command updates or creates `.env` with `DATABASE_URL`. If the project is already linked, use `--force` to re-link. After linking, run `prisma generate`, then `prisma migrate dev` if you need to apply the schema.
## Connection setup
For direct PostgreSQL tools and drivers:
- Generate/copy direct connection credentials from the project connection UI.
- Use the resulting PostgreSQL URL as `DATABASE_URL` for `pg` and `@prisma/adapter-pg`.
- For Prisma Postgres direct TCP, include `sslmode=require`.
Typical direct TCP format:
```env
DATABASE_URL="postgres://identifier:key@db.prisma.io:5432/postgres?sslmode=require"
```
## Adapter choices
- Standard Node.js apps: prefer `@prisma/adapter-pg` with the direct TCP URL above.
- Edge/serverless runtimes: use `@prisma/adapter-ppg` with `@prisma/ppg` only when you specifically need the Prisma Postgres serverless driver.
## References
- [Prisma Postgres overview](https://www.prisma.io/docs/postgres/introduction/overview)
- [Viewing data](https://www.prisma.io/docs/postgres/integrations/viewing-data)
- [Direct connections](https://www.prisma.io/docs/postgres/database/direct-connections)
.agents/skills/prisma-postgres/references/create-db-cli.md
-136
View File
@@ -1,136 +0,0 @@
# create-db-cli
Use `create-db` for instant Prisma Postgres provisioning from the terminal.
## Priority
CRITICAL
## Why It Matters
`create-db` is the fastest way to get a working Prisma Postgres instance for development, demos, and CI previews. It can also emit machine-readable output and write env variables directly.
## Commands
```bash
npx create-db@latest
npx create-db@latest create [options]
npx create-db@latest regions
```
Aliases:
```bash
npx create-pg@latest
npx create-postgres@latest
```
## Command discovery (`--help`)
Always use `--help` first when integrating CLI commands:
```bash
npx create-db@latest --help
npx create-db@latest create --help
npx create-db@latest regions --help
```
Top-level commands currently exposed:
- `create` (default) to provision a database
- `regions` to list available regions
## `create` options
| Flag | Shorthand | Description |
|---|---|---|
| `--region [string]` | `-r` | Region choice: `ap-southeast-1`, `ap-northeast-1`, `eu-central-1`, `eu-west-3`, `us-east-1`, `us-west-1` |
| `--interactive [boolean]` | `-i` | Open region selector |
| `--json [boolean]` | `-j` | Output machine-readable JSON |
| `--env [string]` | `-e` | Write `DATABASE_URL` and `CLAIM_URL` into a target `.env` |
| `--ttl [string]` | `-t` | Auto-delete after a TTL like `30m` or `1h-24h` |
| `--copy [boolean]` | `-c` | Copy the connection string to the clipboard |
| `--quiet [boolean]` | `-q` | Only print the connection string |
| `--open [boolean]` | `-o` | Open the claim URL in your browser |
## Lifecycle and claim flow
- Databases are temporary by default.
- Unclaimed databases are auto-deleted after ~24 hours.
- Claim the database using the URL shown in command output to keep it permanently.
## Programmatic usage (library API)
You can also use `create-db` programmatically in Node.js/Bun instead of shelling out to the CLI.
Install:
```bash
npm install create-db
# or
bun add create-db
```
Create a database:
```ts
import { create, isDatabaseSuccess, isDatabaseError } from "create-db";
const result = await create({
region: "us-east-1",
userAgent: "my-app/1.0.0",
});
if (isDatabaseSuccess(result)) {
console.log(result.connectionString);
console.log(result.claimUrl);
console.log(result.deletionDate);
}
if (isDatabaseError(result)) {
console.error(result.error, result.message);
}
```
List regions programmatically:
```ts
import { regions } from "create-db";
const available = await regions();
console.log(available);
```
Programmatic `create()` defaults to `us-east-1` if no region is passed.
## Common patterns
```bash
# quick database
npx create-db@latest
# region-specific database
npx create-db@latest --region eu-central-1
# interactive region selection
npx create-db@latest --interactive
# write env vars for app bootstrap
npx create-db@latest --env .env
# auto-delete sooner
npx create-db@latest --ttl 2h
# copy connection string to clipboard
npx create-db@latest --copy
# print only the connection string
npx create-db@latest --quiet
# CI-friendly output
npx create-db@latest --json
```
## References
- [npx create-db docs](https://www.prisma.io/docs/postgres/introduction/npx-create-db)
.agents/skills/prisma-postgres/references/management-api-sdk.md
-56
View File
@@ -1,56 +0,0 @@
# management-api-sdk
Use `@prisma/management-api-sdk` for typed API integration with optional OAuth and token refresh.
## Priority
HIGH
## Why It Matters
The SDK provides typed endpoint methods and removes boilerplate around auth and refresh handling, which reduces errors in production provisioning flows.
## Install
```bash
npm install @prisma/management-api-sdk
```
## Simple client (existing token)
```typescript
import { createManagementApiClient } from '@prisma/management-api-sdk'
const client = createManagementApiClient({ token: process.env.PRISMA_SERVICE_TOKEN! })
const { data: workspaces } = await client.GET('/v1/workspaces')
```
## Full SDK (OAuth + refresh)
```typescript
import { createManagementApiSdk, type TokenStorage } from '@prisma/management-api-sdk'
const tokenStorage: TokenStorage = {
async getTokens() { return null },
async setTokens(tokens) {},
async clearTokens() {},
}
const api = createManagementApiSdk({
clientId: process.env.PRISMA_CLIENT_ID!,
redirectUri: 'https://your-app.com/auth/callback',
tokenStorage,
})
```
## OAuth SDK flow
1. Call `getLoginUrl()` and persist `state` + `verifier`.
2. Redirect user to login URL.
3. Handle callback with `handleCallback()`.
4. Use `api.client` for typed endpoint calls.
5. Call `logout()` when needed.
## References
- [Management API SDK docs](https://www.prisma.io/docs/postgres/introduction/management-api-sdk)
.agents/skills/prisma-postgres/references/management-api.md
-61
View File
@@ -1,61 +0,0 @@
# management-api
Use Prisma Management API for programmatic provisioning and workspace/project/database management.
## Priority
CRITICAL
## Why It Matters
When you need backend automation, multi-tenant onboarding flows, or controlled resource provisioning, the Management API is the source of truth and is more reliable than interactive workflows.
## Base URL
```text
https://api.prisma.io/v1
```
## API exploration
- OpenAPI docs: `https://api.prisma.io/v1/doc`
- Swagger Editor: `https://api.prisma.io/v1/swagger-editor`
## Authentication methods
- Service token: best for server-to-server operations in your own workspace
- OAuth 2.0: best for acting on behalf of users across workspaces
## Service token flow
1. Create token in Prisma Console workspace settings.
2. Send token as Bearer auth:
```text
Authorization: Bearer $TOKEN
```
## OAuth flow summary
1. Redirect user to `https://auth.prisma.io/authorize` with `client_id`, `redirect_uri`, `response_type=code`, and scopes.
2. Receive `code` on callback.
3. Exchange code at `https://auth.prisma.io/token`.
4. Use returned access token in Management API requests.
## Common endpoints
- `GET /workspaces`
- `GET /projects`
- `POST /projects`
- Database management endpoints under project/database paths
## Notes
- Management API responses may include direct connection credentials for databases.
- Build PostgreSQL `DATABASE_URL` from direct connection values when needed.
## References
- [Management API docs](https://www.prisma.io/docs/postgres/introduction/management-api)
- [OpenAPI docs](https://api.prisma.io/v1/doc)
- [Swagger Editor](https://api.prisma.io/v1/swagger-editor)