4413045f-d05e-4d7a-a70d-81d6be253c85
This commit is contained in:
Z User committed
1 parent
762f3d7373
commit
c6adc67479
18 files changed
+5263
-1
No files matched your search
@@ -0,0 +1,392 @@
|
||||
/**
|
||||
* Dokploy API Client
|
||||
* -------------------
|
||||
* Manages tenant instances on the Dokploy server: create applications from
|
||||
* a Git repo, deploy, attach domains, create databases, suspend/delete.
|
||||
*
|
||||
* Config (env):
|
||||
* DOKPLOY_URL - e.g. https://cp.project-url.eu
|
||||
* DOKPLOY_API_KEY - bearer token
|
||||
* DOKPLOY_SERVER_ID - the Dokploy server ID to deploy to (default "default")
|
||||
* DOKPLOY_PROJECT_ID - the Dokploy project to put tenant apps under
|
||||
*
|
||||
* NOTE: Dokploy API endpoints should be verified against the current API docs
|
||||
* at implementation time. The endpoints below are based on the Dokploy REST API.
|
||||
* See: https://docs.dokploy.com/docs/api
|
||||
*/
|
||||
|
||||
export interface DokployConfig {
|
||||
url: string
|
||||
apiKey: string
|
||||
serverId?: string
|
||||
projectId?: string
|
||||
}
|
||||
|
||||
export interface DokployApp {
|
||||
applicationId: string
|
||||
name: string
|
||||
status?: string
|
||||
url?: string
|
||||
createdAt?: string
|
||||
}
|
||||
|
||||
export interface DokployDatabase {
|
||||
databaseId: string
|
||||
name: string
|
||||
type: string // postgres|mysql|redis|...
|
||||
host: string
|
||||
port: number
|
||||
database: string
|
||||
username: string
|
||||
password: string
|
||||
externalUrl?: string
|
||||
}
|
||||
|
||||
export interface DokployDomain {
|
||||
domainId: string
|
||||
hostName: string
|
||||
applicationId: string
|
||||
https: boolean
|
||||
certificateStatus?: string
|
||||
}
|
||||
|
||||
export interface ProvisionInstanceInput {
|
||||
name: string
|
||||
subdomain: string
|
||||
gitRepo: string // e.g. https://github.com/cetinmustafa83/restov1
|
||||
gitBranch: string // e.g. main
|
||||
buildPath?: string // e.g. / (repo root, default)
|
||||
envVars: Record<string, string>
|
||||
// Resource limits (Dokploy applies these as container constraints)
|
||||
cpuLimit?: string // e.g. "0.5" = 50% of one core
|
||||
memoryLimit?: string // e.g. "512m"
|
||||
// Database
|
||||
databaseName?: string // if set, a Postgres DB is created for this instance
|
||||
}
|
||||
|
||||
export interface ProvisionInstanceResult {
|
||||
app: DokployApp
|
||||
database?: DokployDatabase
|
||||
domain: DokployDomain
|
||||
url: string
|
||||
}
|
||||
|
||||
class DokployError extends Error {
|
||||
constructor(
|
||||
message: string,
|
||||
public status: number,
|
||||
public endpoint: string,
|
||||
public body?: unknown
|
||||
) {
|
||||
super(message)
|
||||
this.name = 'DokployError'
|
||||
}
|
||||
}
|
||||
|
||||
export function createDokployClient(config: DokployConfig) {
|
||||
const baseUrl = config.url.replace(/\/$/, '')
|
||||
const serverId = config.serverId ?? 'default'
|
||||
const headers: Record<string, string> = {
|
||||
'Content-Type': 'application/json',
|
||||
Authorization: `Bearer ${config.apiKey}`,
|
||||
}
|
||||
|
||||
async function call<T = unknown>(endpoint: string, body?: Record<string, unknown>, method = 'POST'): Promise<T> {
|
||||
const url = `${baseUrl}${endpoint}`
|
||||
const res = await fetch(url, {
|
||||
method,
|
||||
headers,
|
||||
body: body ? JSON.stringify(body) : undefined,
|
||||
})
|
||||
const text = await res.text()
|
||||
let json: unknown
|
||||
try {
|
||||
json = text ? JSON.parse(text) : null
|
||||
} catch {
|
||||
json = text
|
||||
}
|
||||
if (!res.ok) {
|
||||
throw new DokployError(
|
||||
`Dokploy API ${endpoint} failed: HTTP ${res.status}`,
|
||||
res.status,
|
||||
endpoint,
|
||||
json
|
||||
)
|
||||
}
|
||||
return json as T
|
||||
}
|
||||
|
||||
// --- Applications ---
|
||||
|
||||
async function createApplication(input: {
|
||||
name: string
|
||||
description?: string
|
||||
gitRepo: string
|
||||
gitBranch: string
|
||||
buildPath?: string
|
||||
envVars?: Record<string, string>
|
||||
cpuLimit?: string
|
||||
memoryLimit?: string
|
||||
}): Promise<DokployApp> {
|
||||
const body: Record<string, unknown> = {
|
||||
name: input.name,
|
||||
description: input.description ?? `Tenant instance: ${input.name}`,
|
||||
serverId,
|
||||
projectName: config.projectId ?? 'default',
|
||||
sourceType: 'git',
|
||||
gitRepository: input.gitRepo,
|
||||
gitBranch: input.gitBranch,
|
||||
buildPath: input.buildPath ?? '/',
|
||||
// Dokploy expects env vars as a JSON string
|
||||
env: JSON.stringify(input.envVars ?? {}),
|
||||
cpuLimit: input.cpuLimit ?? '0.5',
|
||||
memoryLimit: input.memoryLimit ?? '512m',
|
||||
}
|
||||
const res = await call<{ applicationId?: string; app?: { applicationId: string }; [k: string]: unknown }>('/api/application.create', body)
|
||||
const applicationId = res.applicationId ?? (res.app as { applicationId: string } | undefined)?.applicationId
|
||||
if (!applicationId) {
|
||||
throw new DokployError('Dokploy createApplication returned no applicationId', 200, '/api/application.create', res)
|
||||
}
|
||||
return { applicationId, name: input.name, status: 'created' }
|
||||
}
|
||||
|
||||
async function deployApplication(applicationId: string): Promise<{ deployId: string; status: string }> {
|
||||
const res = await call<{ deployId?: string; jobId?: string; status?: string }>('/api/application.deploy', { applicationId })
|
||||
return { deployId: res.deployId ?? res.jobId ?? '', status: res.status ?? 'deploying' }
|
||||
}
|
||||
|
||||
async function getApplication(applicationId: string): Promise<DokployApp & { status?: string; url?: string }> {
|
||||
const res = await call<DokployApp & { applicationStatus?: string; previewDomain?: string }>(
|
||||
`/api/application.one`,
|
||||
{ applicationId },
|
||||
)
|
||||
return {
|
||||
applicationId: res.applicationId,
|
||||
name: res.name,
|
||||
status: res.applicationStatus ?? res.status,
|
||||
url: res.previewDomain ?? res.url,
|
||||
createdAt: res.createdAt,
|
||||
}
|
||||
}
|
||||
|
||||
async function deleteApplication(applicationId: string): Promise<void> {
|
||||
await call('/api/application.delete', { applicationId, deleteVolumes: true })
|
||||
}
|
||||
|
||||
async function stopApplication(applicationId: string): Promise<void> {
|
||||
await call('/api/application.stop', { applicationId })
|
||||
}
|
||||
|
||||
async function startApplication(applicationId: string): Promise<void> {
|
||||
await call('/api/application.start', { applicationId })
|
||||
}
|
||||
|
||||
async function updateEnv(applicationId: string, envVars: Record<string, string>): Promise<void> {
|
||||
await call('/api/application.update', {
|
||||
applicationId,
|
||||
env: JSON.stringify(envVars),
|
||||
})
|
||||
}
|
||||
|
||||
// --- Databases (Postgres) ---
|
||||
|
||||
async function createPostgresDatabase(input: {
|
||||
name: string
|
||||
appName: string // the application this DB belongs to
|
||||
description?: string
|
||||
externalUrl?: boolean
|
||||
}): Promise<DokployDatabase> {
|
||||
const body: Record<string, unknown> = {
|
||||
name: input.name,
|
||||
appName: input.appName,
|
||||
description: input.description ?? `DB for ${input.appName}`,
|
||||
serverId,
|
||||
projectName: config.projectId ?? 'default',
|
||||
externalUrl: input.externalUrl ?? false,
|
||||
}
|
||||
const res = await call<Record<string, unknown>>('/api/database.postgres.create', body)
|
||||
// The response shape varies between Dokploy versions; handle both.
|
||||
const db = (res.database as Record<string, unknown> | undefined) ?? res
|
||||
const databaseId = (db.databaseId as string | undefined) ?? (res.databaseId as string | undefined)
|
||||
if (!databaseId) {
|
||||
throw new DokployError('Dokploy createDatabase returned no databaseId', 200, '/api/database.postgres.create', res)
|
||||
}
|
||||
return {
|
||||
databaseId,
|
||||
name: (db.name as string | undefined) ?? input.name,
|
||||
type: 'postgres',
|
||||
host: (db.host as string | undefined) ?? 'postgres',
|
||||
port: (db.port as number | undefined) ?? 5432,
|
||||
database: (db.database as string | undefined) ?? input.name,
|
||||
username: (db.username as string | undefined) ?? 'postgres',
|
||||
password: (db.password as string | undefined) ?? '',
|
||||
}
|
||||
}
|
||||
|
||||
async function deleteDatabase(databaseId: string): Promise<void> {
|
||||
await call('/api/database.postgres.delete', { databaseId })
|
||||
}
|
||||
|
||||
// --- Domains ---
|
||||
|
||||
async function createDomain(input: {
|
||||
applicationId: string
|
||||
hostName: string
|
||||
path?: string
|
||||
port?: number
|
||||
https?: boolean
|
||||
certificateType?: 'letsencrypt' | 'none'
|
||||
}): Promise<DokployDomain> {
|
||||
const body: Record<string, unknown> = {
|
||||
applicationId: input.applicationId,
|
||||
hostName: input.hostName,
|
||||
path: input.path ?? '/',
|
||||
port: input.port ?? 3000,
|
||||
https: input.https ?? true,
|
||||
certificateType: input.certificateType ?? 'letsencrypt',
|
||||
}
|
||||
const res = await call<{ domainId?: string; id?: string; hostName?: string; https?: boolean }>('/api/domain.create', body)
|
||||
const domainId = res.domainId ?? res.id
|
||||
if (!domainId) {
|
||||
throw new DokployError('Dokploy createDomain returned no domainId', 200, '/api/domain.create', res)
|
||||
}
|
||||
return {
|
||||
domainId,
|
||||
hostName: input.hostName,
|
||||
applicationId: input.applicationId,
|
||||
https: input.https ?? true,
|
||||
}
|
||||
}
|
||||
|
||||
async function deleteDomain(domainId: string): Promise<void> {
|
||||
await call('/api/domain.delete', { domainId })
|
||||
}
|
||||
|
||||
// --- High-level: provision a full instance ---
|
||||
|
||||
async function provisionInstance(input: ProvisionInstanceInput): Promise<ProvisionInstanceResult> {
|
||||
// 1. Create application from Git repo
|
||||
const app = await createApplication({
|
||||
name: input.name,
|
||||
gitRepo: input.gitRepo,
|
||||
gitBranch: input.gitBranch,
|
||||
buildPath: '/',
|
||||
envVars: input.envVars,
|
||||
cpuLimit: input.cpuLimit,
|
||||
memoryLimit: input.memoryLimit,
|
||||
})
|
||||
|
||||
// 2. (Optional) Create Postgres database
|
||||
let database: DokployDatabase | undefined
|
||||
if (input.databaseName) {
|
||||
database = await createPostgresDatabase({
|
||||
name: input.databaseName,
|
||||
appName: input.name,
|
||||
})
|
||||
// Inject DATABASE_URL into the app's env
|
||||
const dbUrl = `postgresql://${database.username}:${database.password}@${database.host}:${database.port}/${database.database}`
|
||||
await updateEnv(app.applicationId, {
|
||||
...input.envVars,
|
||||
DATABASE_URL: dbUrl,
|
||||
})
|
||||
}
|
||||
|
||||
// 3. Attach domain (subdomain.platform-domain)
|
||||
const hostName = input.subdomain
|
||||
const domain = await createDomain({
|
||||
applicationId: app.applicationId,
|
||||
hostName,
|
||||
port: 3000,
|
||||
https: true,
|
||||
})
|
||||
|
||||
// 4. Trigger deploy
|
||||
await deployApplication(app.applicationId)
|
||||
|
||||
return {
|
||||
app,
|
||||
database,
|
||||
domain,
|
||||
url: `https://${hostName}`,
|
||||
}
|
||||
}
|
||||
|
||||
// --- High-level: teardown an instance (idempotent) ---
|
||||
|
||||
async function teardownInstance(input: {
|
||||
dokployAppId?: string
|
||||
dokployDbId?: string
|
||||
dnsDomainId?: string // Dokploy domain ID
|
||||
}): Promise<{ steps: string[] }> {
|
||||
const steps: string[] = []
|
||||
// Remove domain first (stop traffic)
|
||||
if (input.dnsDomainId) {
|
||||
try {
|
||||
await deleteDomain(input.dnsDomainId)
|
||||
steps.push('domain.removed')
|
||||
} catch (e) {
|
||||
if (e instanceof DokployError && e.status !== 404) {
|
||||
steps.push(`domain.error: ${e.message}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
// Delete database
|
||||
if (input.dokployDbId) {
|
||||
try {
|
||||
await deleteDatabase(input.dokployDbId)
|
||||
steps.push('database.removed')
|
||||
} catch (e) {
|
||||
if (e instanceof DokployError && e.status !== 404) {
|
||||
steps.push(`database.error: ${e.message}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
// Delete application (+ volumes)
|
||||
if (input.dokployAppId) {
|
||||
try {
|
||||
await deleteApplication(input.dokployAppId)
|
||||
steps.push('application.removed')
|
||||
} catch (e) {
|
||||
if (e instanceof DokployError && e.status !== 404) {
|
||||
steps.push(`application.error: ${e.message}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
return { steps }
|
||||
}
|
||||
|
||||
return {
|
||||
// Low-level
|
||||
createApplication,
|
||||
deployApplication,
|
||||
getApplication,
|
||||
deleteApplication,
|
||||
stopApplication,
|
||||
startApplication,
|
||||
updateEnv,
|
||||
createPostgresDatabase,
|
||||
deleteDatabase,
|
||||
createDomain,
|
||||
deleteDomain,
|
||||
call,
|
||||
// High-level
|
||||
provisionInstance,
|
||||
teardownInstance,
|
||||
}
|
||||
}
|
||||
|
||||
export type DokployClient = ReturnType<typeof createDokployClient>
|
||||
|
||||
// --- Factory: create from env ---
|
||||
|
||||
export function createDokployClientFromEnv(): DokployClient | null {
|
||||
const url = process.env.DOKPLOY_URL
|
||||
const apiKey = process.env.DOKPLOY_API_KEY
|
||||
if (!url || !apiKey) return null
|
||||
return createDokployClient({
|
||||
url,
|
||||
apiKey,
|
||||
serverId: process.env.DOKPLOY_SERVER_ID,
|
||||
projectId: process.env.DOKPLOY_PROJECT_ID,
|
||||
})
|
||||
}
|
||||
Reference in new issue
Block a user