138 lines
3.8 KiB
TypeScript
138 lines
3.8 KiB
TypeScript
import type { SQL } from "drizzle-orm";
|
|
import { drizzle as drizzleMysql } from "drizzle-orm/mysql2";
|
|
import { drizzle as drizzlePg } from "drizzle-orm/node-postgres";
|
|
import type { ResultSetHeader } from "mysql2";
|
|
import mysql from "mysql2/promise";
|
|
import pg from "pg";
|
|
import * as relations from "@/db/relations";
|
|
import * as schema from "@/db/schema";
|
|
import { env } from "@/env";
|
|
import { resolveConnectionLimit } from "@/lib/db-pool";
|
|
|
|
import { instrumentDatabase } from "@/lib/performance-diagnostics";
|
|
|
|
const fullSchema = { ...schema, ...relations };
|
|
|
|
const globalForDb = globalThis as unknown as {
|
|
db?: ReturnType<typeof createDb>;
|
|
};
|
|
|
|
function createDb() {
|
|
const urlStr = env.DATABASE_URL;
|
|
const isPostgres =
|
|
urlStr.startsWith("postgres://") || urlStr.startsWith("postgresql://");
|
|
const url = new URL(urlStr);
|
|
const isBuild =
|
|
process.env.NEXT_PHASE === "phase-production-build" ||
|
|
process.env.NEXT_PHASE === "phase-production-compile";
|
|
const connectionLimit = resolveConnectionLimit(env.DATABASE_POOL_SIZE);
|
|
// Fail fast during SSG so Next can retry/fallback instead of hanging 30s+.
|
|
const connectTimeout = isBuild
|
|
? Math.min(env.DATABASE_CONNECT_TIMEOUT_MS, 5_000)
|
|
: env.DATABASE_CONNECT_TIMEOUT_MS;
|
|
|
|
if (isPostgres) {
|
|
const { Pool } = pg;
|
|
const pool = new Pool({
|
|
connectionString: urlStr,
|
|
max: connectionLimit,
|
|
idleTimeoutMillis: env.DATABASE_IDLE_TIMEOUT_MS,
|
|
connectionTimeoutMillis: connectTimeout,
|
|
});
|
|
|
|
return drizzlePg(instrumentDatabase(pool) as unknown as pg.Pool, {
|
|
schema: fullSchema,
|
|
logger: false,
|
|
}) as unknown as ReturnType<typeof drizzleMysql>;
|
|
}
|
|
|
|
const pool = mysql.createPool({
|
|
host: url.hostname,
|
|
port: Number(url.port) || 3306,
|
|
user: decodeURIComponent(url.username),
|
|
password: decodeURIComponent(url.password),
|
|
database: url.pathname.replace(/^\//, ""),
|
|
charset: "utf8mb4",
|
|
waitForConnections: true,
|
|
connectionLimit,
|
|
queueLimit: 0,
|
|
connectTimeout,
|
|
idleTimeout: env.DATABASE_IDLE_TIMEOUT_MS,
|
|
enableKeepAlive: true,
|
|
// Allow :placeholder syntax for raw SQL helpers.
|
|
namedPlaceholders: true,
|
|
// Reject multiple statements (SQL injection hardening).
|
|
multipleStatements: false,
|
|
supportBigNumbers: true,
|
|
});
|
|
|
|
return drizzleMysql(instrumentDatabase(pool), {
|
|
schema: fullSchema,
|
|
mode: "default",
|
|
logger: false,
|
|
});
|
|
}
|
|
|
|
export const db = globalForDb.db ?? createDb();
|
|
|
|
if (env.NODE_ENV !== "production") globalForDb.db = db;
|
|
|
|
export function rowsFrom<T>(result: unknown): T[] {
|
|
if (!result) return [];
|
|
if (Array.isArray(result)) {
|
|
const [first] = result as [unknown, unknown];
|
|
return (Array.isArray(first) ? first : []) as T[];
|
|
}
|
|
if (
|
|
typeof result === "object" &&
|
|
"rows" in result &&
|
|
Array.isArray((result as { rows: unknown }).rows)
|
|
) {
|
|
return (result as { rows: T[] }).rows;
|
|
}
|
|
return [];
|
|
}
|
|
|
|
export async function queryRows<T>(query: SQL | string): Promise<T[]> {
|
|
return rowsFrom<T>(await db.execute(query));
|
|
}
|
|
|
|
export async function execResult(
|
|
query: SQL | string,
|
|
): Promise<ResultSetHeader> {
|
|
const res = await db.execute(query);
|
|
if (Array.isArray(res)) {
|
|
const [first] = res as [unknown, unknown];
|
|
return first as ResultSetHeader;
|
|
}
|
|
if (typeof res === "object" && res !== null) {
|
|
const r = res as Record<string, unknown>;
|
|
return {
|
|
affectedRows: typeof r.rowCount === "number" ? r.rowCount : 0,
|
|
insertId: typeof r.insertId === "number" ? r.insertId : 0,
|
|
fieldCount: 0,
|
|
info: "",
|
|
serverStatus: 0,
|
|
warningStatus: 0,
|
|
changedRows: 0,
|
|
} as unknown as ResultSetHeader;
|
|
}
|
|
return {
|
|
affectedRows: 0,
|
|
insertId: 0,
|
|
fieldCount: 0,
|
|
info: "",
|
|
serverStatus: 0,
|
|
warningStatus: 0,
|
|
changedRows: 0,
|
|
} as unknown as ResultSetHeader;
|
|
}
|
|
|
|
export async function affectedRows(query: SQL | string): Promise<number> {
|
|
return (await execResult(query)).affectedRows;
|
|
}
|
|
|
|
export type Db = ReturnType<typeof createDb>;
|
|
|
|
export * from "@/db/schema";
|