@pelican.ts/sdk 0.2.3 → 0.2.5

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@pelican.ts/sdk",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Pelican panel SDK for TypeScript",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "exports": {
+    "./types": {
+      "types": "./dist/types.d.ts"
+    }
+  },
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --sourcemap --target esnext",
-    "pub": "npm publish --access=public"
+    "build:code": "tsup src/index.ts --format esm,cjs --dts --sourcemap --target esnext",
+    "build:types": "tsup src/types.ts --dts-only --target esnext",
+    "build": "npm run build:code && npm run build:types",
+    "pub": "npm publish --access=public",
+    "generate-types": "bun run scripts/create-types.ts"
   },
   "keywords": ["pterodactyl", "pterodactyl.ts", "pterodactyl.js", "pelican", "pelican.ts", "pelican.js"],
   "author": "M41den",
@@ -19,6 +27,7 @@
     "@types/node": "^22.18.12",
     "@types/strip-color": "^0.1.2",
     "tsc-alias": "^1.8.16",
+    "tsup": "^8.5.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {

package/scripts/create-types.ts

@@ -0,0 +1,24 @@
+
+import fs from "fs"
+import path from "path"
+
+const typesPaths = [
+    "./api/common/types",
+    "./api/application/types",
+    "./api/client/types"
+]
+
+typesPaths.forEach(p => {
+    const prefix = path.join(__dirname, "../src" , p)
+    const files = fs.readdirSync(prefix)
+        .filter(f => f!=="index.ts")
+        .map(f => f.replace(/\.ts$/, ""))
+    const strings: Array<string> = []
+    files.forEach(f => {
+        strings.push(`export * from "./${f}"`)
+    })
+    fs.writeFileSync(path.join(prefix, "index.ts"), strings.join("\n"))
+})
+
+const strings = typesPaths.map(p => `export * from "${p}"`)
+fs.writeFileSync(path.join(__dirname, "../src/types.ts"), strings.join("\n"))

package/src/api/application/client.ts

@@ -1,13 +1,53 @@
 import {AxiosInstance} from "axios";
 import {Users} from "@/api/application/users";
+import {Nodes} from "@/api/application/nodes";
+import {GenericListResponse, GenericResponse} from "@/api/base/types";
+import {ApplicationServer} from "@/api/application/types/server";
+import {CreateServerSchema, Servers} from "@/api/application/servers";
+import z from "zod";
+import {DatabaseHosts} from "@/api/application/database_hosts";
+import {Roles} from "@/api/application/roles";
 
 export class Client {
     private readonly r: AxiosInstance
     users: Users
+    nodes: Nodes
+    databaseHosts: DatabaseHosts
+    roles: Roles
 
     constructor(requester: AxiosInstance) {
         this.r = requester
 
         this.users = new Users(requester)
+        this.nodes = new Nodes(requester)
+        this.databaseHosts = new DatabaseHosts(requester)
+        this.roles = new Roles(requester)
     }
+
+    listServers = async (
+        search?: string,
+        page: number = 1
+    ): Promise<ApplicationServer[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<ApplicationServer, "server">>
+        >("/servers", {
+            params: {search, page}
+        })
+        return data.data.map(s => s.attributes)
+    }
+
+    createServer = async (opts: z.infer<typeof CreateServerSchema>): Promise<ApplicationServer> => {
+        opts = CreateServerSchema.parse(opts)
+        const {data} = await this.r.post<GenericResponse<ApplicationServer, "server">>("/servers", opts)
+        return data.attributes
+    }
+
+    getServerByExternalId = async (external_id: string, include?: ("egg" | "subusers")[]): Promise<ApplicationServer> => {
+        const {data} = await this.r.get<GenericResponse<ApplicationServer, "server">>(`/servers/external/${external_id}`, {
+            params: {include: include?.join(",")}
+        })
+        return data.attributes
+    }
+
+    servers = (server_id: number) => new Servers(this.r, server_id)
 }

package/src/api/application/database_hosts.ts

@@ -0,0 +1,70 @@
+import {AxiosInstance} from "axios";
+import {GenericListResponse, GenericResponse} from "@/api/base/types";
+import {DatabaseHost} from "@/api/application/types/database_host";
+import z from "zod";
+
+export class DatabaseHosts {
+    private readonly r: AxiosInstance
+
+    constructor(r: AxiosInstance) {
+        this.r = r
+    }
+
+    list = async (
+        page: number = 1
+    ): Promise<DatabaseHost[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<DatabaseHost, "database_host">>
+        >("/database-hosts", {
+            params: {page}
+        })
+        return data.data.map(d => d.attributes)
+    }
+
+    info = async (
+        id: string
+    ): Promise<DatabaseHost> => {
+        const {data} = await this.r.get<
+            GenericResponse<DatabaseHost, "database_host">
+        >(`/database-hosts/${id}`)
+        return data.attributes
+    }
+
+    // TODO: find out why API returns 500
+    create = async (
+        opts: z.infer<typeof CreateDBHostSchema>
+    ): Promise<void> => {
+        opts = CreateDBHostSchema.parse(opts)
+        await this.r.post<
+            GenericResponse<DatabaseHost, "database_host">
+        >("/database-hosts", opts).catch(e=>{})
+    }
+
+    update = async (
+        id: string,
+        opts: z.infer<typeof CreateDBHostSchema>
+    ): Promise<DatabaseHost> => {
+        opts = CreateDBHostSchema.parse(opts)
+        const {data} = await this.r.patch<
+            GenericResponse<DatabaseHost, "database_host">
+        >(`/database-hosts/${id}`, opts)
+
+        return data.attributes
+    }
+
+    delete = async (
+        id: string
+    ): Promise<void> => {
+        await this.r.delete(`/database-hosts/${id}`)
+    }
+}
+
+const CreateDBHostSchema = z.object({
+    name: z.string().min(1).max(255),
+    host: z.string(),
+    port: z.number().min(1).max(65535),
+    username: z.string().min(1).max(255),
+    password: z.string().optional(),
+    node_ids: z.array(z.string()).optional(),
+    max_databases: z.number().optional()
+})

package/src/api/application/nodes.ts

@@ -1,9 +1,9 @@
 import {AxiosInstance} from "axios";
 import {NodesAllocations} from "@/api/application/nodes_allocations";
-import {Server} from "@/api/application/types/server";
+import {ApplicationServer} from "@/api/application/types/server";
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
 import z from "zod";
-import {Node} from "@/api/application/types/node";
+import {Node, NodeConfiguration} from "@/api/application/types/node";
 
 
 export class Nodes {
@@ -26,42 +26,67 @@ export class Nodes {
         return data.data.map(s => s.attributes)
     }
 
+    listDeployable = async (
+        filters: {
+            disk: number,
+            memory: number,
+            cpu?: number,
+            location_ids?: string[],
+            tags?: string[]
+        },
+        include?: ("allocations" | "location" | "servers")[],
+        page: number = 1
+    ): Promise<Node[]> => {
+        z.number().positive().parse(page)
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<Node, "node">>
+        >("/nodes/deployable", {
+            params: {
+                include: include?.join(","),
+                disk: filters.disk,
+                memory: filters.memory,
+                cpu: filters.cpu,
+                location_ids: filters.location_ids,
+                tags: filters.tags,
+                page: page
+            }
+        })
+        return data.data.map(s => s.attributes)
+    }
+
     info = async (
         id: number,
         include?: ("allocations" | "location" | "servers")[],
-        ): Promise<Node> => {
+    ): Promise<Node> => {
         z.number().positive().parse(id)
-        const {data} = await this.r.get<GenericResponse<Node, "node">>(
-            `/nodes/${id}`,
-            {params: {include: include?.join(",")}}
-        )
+        const {data} = await this.r.get<
+            GenericResponse<Node, "node">
+        >(`/nodes/${id}`, {
+            params: {include: include?.join(",")}
+        })
         return data.attributes
     }
 
-    show_configuration = async (id: number): Promise<any> => {
-        z.number().positive().parse(id)
-        const {data} = await this.r.get(`/nodes/${id}/configuration`)
-        return data
-    }
-
-    create = async (node: NodeCreate): Promise<NodeUpdated> => {
+    create = async (node: z.infer<typeof NodeCreateSchema>): Promise<Node> => {
+        node = NodeCreateSchema.parse(node)
         const {data} = await this.r.post<
-            GenericResponse<NodeUpdated, "node">
-        >(
-            "/nodes",
-            node
-        )
+            GenericResponse<Node, "node">
+        >("/nodes", node)
         return data.attributes
     }
 
-    update = async (id: number, node: Node): Promise<NodeUpdated> => {
+    get_configuration = async (id: number): Promise<NodeConfiguration> => {
+        z.number().positive().parse(id)
+        const {data} = await this.r.get<NodeConfiguration>(`/nodes/${id}/configuration`)
+        return data
+    }
+
+    update = async (id: number, node: z.infer<typeof NodeCreateSchema>): Promise<Node> => {
         z.number().positive().parse(id)
-        const {data} = await this.r.put<
-            GenericResponse<NodeUpdated, "node">
-        >(
-            `/nodes/${id}`,
-            node
-        )
+        node = NodeCreateSchema.parse(node)
+        const {data} = await this.r.patch<
+            GenericResponse<Node, "node">
+        >(`/nodes/${id}`, node)
         return data.attributes
     }
 
@@ -75,23 +100,25 @@ export class Nodes {
     )
 }
 
-type NodeCreate = {
-    name: string,
-    location_id: number,
-    fqdn: string,
-    scheme: "https" | "http",
-    memory: number,
-    memory_overallocate: number,
-    disk: number,
-    disk_overallocate: number,
-    upload_size: number,
-    daemon_listen: number,
-    daemon_sftp: number
-}
-
-type NodeAllocatedResources = {
-    memory: number,
-    disk: number
-}
-
-type NodeUpdated = Node & {allocated_resources: NodeAllocatedResources}
+const NodeCreateSchema = z.object({
+    name: z.string().min(1).max(100),
+    description: z.string().optional(),
+    public: z.boolean().optional(),
+    fqdn: z.string().nonempty(),
+    scheme: z.enum(["http", "https"]),
+    behind_proxy: z.boolean().optional(),
+    memory: z.number().min(0),
+    memory_overallocate: z.number().min(-1),
+    disk: z.number().min(0),
+    disk_overallocate: z.number().min(-1),
+    cpu: z.number().min(0),
+    cpu_overallocate: z.number().min(-1),
+    daemon_base: z.string().nonempty().optional(),
+    daemon_sftp: z.number().min(1).max(65535),
+    daemon_sftp_alias: z.string().optional(),
+    daemon_listen: z.number().min(1).max(65535),
+    daemon_connect: z.number().min(1).max(65535),
+    maintenance_mode: z.boolean().optional(),
+    upload_size: z.number().min(1).max(1024),
+    tags: z.array(z.string()).optional(),
+})

package/src/api/application/nodes_allocations.ts

@@ -1,5 +1,5 @@
 import {AxiosInstance} from "axios";
-import {Allocation, AllocationRel} from "@/api/common/types/server_allocations";
+import {Allocation, AllocationRel} from "@/api/application/types/server_allocation";
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
 import z from "zod";
 
@@ -25,17 +25,15 @@ export class NodesAllocations {
 
     create = async (
         ip: string,
-        ports: number[] | string,
+        ports: string[],
         alias?: string
     ): Promise<void> => {
         z.ipv4().parse(ip)
-        z.ipv4().or(z.url()).optional().parse(alias)
+        z.ipv4().or(z.url().max(255)).optional().parse(alias)
         z.array(z.number()).or(z.string().regex(/\d+-\d+/)).parse(ports)
 
         await this.r.post(`/nodes/${this.id}/allocations`, {
-            ip,
-            ports,
-            alias
+            ip, ports, alias
         })
     }
 

package/src/api/application/roles.ts

@@ -0,0 +1,53 @@
+import {AxiosInstance} from "axios";
+import {GenericListResponse, GenericResponse} from "@/api/base/types";
+import {Role} from "@/api/application/types/role";
+
+
+// TODO: API is incomplete
+
+export class Roles {
+    private readonly r: AxiosInstance
+
+    constructor(r: AxiosInstance) {
+        this.r = r
+    }
+
+    list = async (
+        page: number = 1
+    ): Promise<Role[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<Role, "role">>
+        >(`/roles`, {
+            params: {page}
+        })
+        return data.data.map(r => r.attributes)
+    }
+
+    info = async (
+        id: number
+    ): Promise<Role> => {
+        const {data} = await this.r.get<
+            GenericResponse<Role, "role">
+        >(`/roles/${id}`)
+        return data.attributes
+    }
+
+    create = async (
+        opts: {name: string}
+    ): Promise<void> => {
+        await this.r.post(`/roles`, opts)
+    }
+
+    update = async (
+        id: number,
+        opts: {name: string}
+    ): Promise<void> => {
+        await this.r.patch(`/roles/${id}`, opts)
+    }
+
+    delete = async (
+        id: number
+    ): Promise<void> => {
+        await this.r.delete(`/roles/${id}`)
+    }
+}

package/src/api/application/servers.ts

@@ -0,0 +1,135 @@
+import {AxiosInstance} from "axios";
+import z from "zod";
+import {GenericResponse} from "@/api/base/types";
+import {ApplicationServer} from "@/api/application/types/server";
+import {ServersDatabases} from "@/api/application/servers_databases";
+
+export class Servers {
+    private readonly r: AxiosInstance
+    private readonly id: number
+    databases: ServersDatabases
+
+    constructor(r: AxiosInstance, server_id: number) {
+        this.r = r
+        this.id = server_id
+
+        this.databases = new ServersDatabases(this.r, this.id)
+    }
+
+    info = async (include?: ("egg" | "subusers")[]): Promise<ApplicationServer> => {
+        const {data} = await this.r.get<GenericResponse<ApplicationServer, "server">>(`/servers/${this.id}`, {
+            params: {include: include?.join(",")}
+        })
+        return data.attributes
+    }
+
+    delete = async (force: boolean = false) => {
+        await this.r.delete(`/servers/${this.id}${force ? "/force" : ""}`)
+    }
+
+    updateDetails = async (opts: z.infer<typeof UpdateDetailsSchema>): Promise<void> => {
+        opts = UpdateDetailsSchema.parse(opts)
+        await this.r.patch(`/servers/${this.id}/details`, opts)
+    }
+
+    updateBuild = async (opts: z.infer<typeof UpdateBuildSchema>): Promise<void> => {
+        opts = UpdateBuildSchema.parse(opts)
+        await this.r.patch(`/servers/${this.id}/build`, opts)
+    }
+
+    updateStartup = async (opts: z.infer<typeof UpdateStartupSchema>): Promise<void> => {
+        opts = UpdateStartupSchema.parse(opts)
+        await this.r.patch(`/servers/${this.id}/startup`, opts)
+    }
+
+    suspend = async (): Promise<void> => {
+        await this.r.post(`/servers/${this.id}/suspend`)
+    }
+
+    unsuspend = async (): Promise<void> => {
+        await this.r.post(`/servers/${this.id}/unsuspend`)
+    }
+
+    reinstall = async (): Promise<void> => {
+        await this.r.post(`/servers/${this.id}/reinstall`)
+    }
+
+    transferStart = async (
+        node_id: number,
+        allocation_id: number,
+        allocation_additional?: string[]
+    ): Promise<void> => {
+        await this.r.post(`/servers/${this.id}/transfer`, {
+            node_id,
+            allocation_id,
+            allocation_additional
+        })
+    }
+
+    transferCancel = async (): Promise<void> => {
+        await this.r.post(`/servers/${this.id}/transfer/cancel`)
+    }
+}
+
+
+export const CreateServerSchema = z.object({
+    external_id: z.string().min(1).max(255).optional(),
+    name: z.string().min(1).max(255),
+    description: z.string().optional(),
+    user: z.number(),
+    egg: z.number(),
+    docker_image: z.string().optional(),
+    startup: z.string().optional(),
+    environment: z.array(z.string()),
+    skip_scripts: z.boolean().optional(),
+    oom_killer: z.boolean().optional(),
+    start_on_completion: z.boolean().optional(),
+    limits: z.object({
+        memory: z.number().min(0),
+        swap: z.number().min(-1),
+        disk: z.number().min(0),
+        io: z.number().min(0),
+        threads: z.string().optional(),
+        cpu: z.number().min(0)
+    }),
+    feature_limits: z.object({
+        databases: z.number().min(0),
+        allocations: z.number().min(0),
+        backups: z.number().min(0)
+    }),
+    allocation: z.object({
+        default: z.string(),
+        additional: z.array(z.string()).optional()
+    }).optional(),
+    deploy: z.object({
+        tags: z.array(z.string()).optional(),
+        dedicated_ip: z.boolean().optional(),
+        port_range: z.array(z.string()).optional()
+    }).optional()
+})
+
+const UpdateDetailsSchema = CreateServerSchema.pick({
+    external_id: true,
+    name: true,
+    user: true,
+    description: true
+})
+
+const UpdateBuildSchema = CreateServerSchema.pick({
+    oom_killer: true,
+    limits: true,
+    feature_limits: true,
+}).extend({
+    allocation: z.number().optional(),
+    add_allocations: z.array(z.string()).optional(),
+    remove_allocations: z.array(z.string()).optional(),
+})
+
+const UpdateStartupSchema = CreateServerSchema.pick({
+    startup: true,
+    environment: true,
+    egg: true,
+    skip_scripts: true
+}).extend({
+    image: z.string().optional()
+})

package/src/api/application/servers_databases.ts

@@ -0,0 +1,49 @@
+import {AxiosInstance} from "axios";
+import {ServerDatabase} from "@/api/common/types/server_database";
+import {GenericListResponse, GenericResponse} from "@/api/base/types";
+import z from "zod";
+
+// TODO: Check if database type is valid
+export class ServersDatabases {
+    private readonly r: AxiosInstance
+    private readonly id: number
+
+    constructor(r: AxiosInstance, server_id: number) {
+        this.r = r
+        this.id = server_id
+    }
+
+    list = async (): Promise<ServerDatabase[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<ServerDatabase, "server_database">>
+        >(`/servers/${this.id}/databases`)
+        return data.data.map(d => d.attributes)
+    }
+
+    create = async (
+        database: string,
+        remote: string,
+        host: string
+    ): Promise<ServerDatabase> => {
+        database = z.string().min(1).max(48).parse(database)
+        const {data} = await this.r.post<
+            GenericResponse<ServerDatabase, "server_database">
+        >(`/servers/${this.id}/databases`, {database, remote, host})
+        return data.attributes
+    }
+
+    info = async (database_id: number): Promise<ServerDatabase> => {
+        const {data} = await this.r.get<
+            GenericResponse<ServerDatabase, "server_database">
+        >(`/servers/${this.id}/databases/${database_id}`)
+        return data.attributes
+    }
+
+    delete = async (database_id: number): Promise<void> => {
+        await this.r.delete(`/servers/${this.id}/databases/${database_id}`)
+    }
+
+    resetPassword = async (database_id: number): Promise<void> => {
+        await this.r.post(`/servers/${this.id}/databases/${database_id}/reset-password`)
+    }
+}

package/src/api/application/types/container.ts

@@ -3,9 +3,7 @@ export type Container = {
     startup_command: string,
     image: string,
     installed: number,
-    environment: {
-        [key: string]: string | number
-    },
+    environment: Record<string, string>,
     ports: number[],
     volumes: string[],
     network_mode: string

package/src/api/application/types/database_host.ts

@@ -0,0 +1,11 @@
+import {Nullable} from "@/utils/types";
+
+export type DatabaseHost = {
+    id: number,
+    name: string,
+    host: string,
+    port: number,
+    username: string,
+    created_at: string,
+    updated_at: Nullable<string>
+}

package/src/api/application/types/index.ts

@@ -0,0 +1,8 @@
+export * from "./node"
+export * from "./location"
+export * from "./database_host"
+export * from "./container"
+export * from "./role"
+export * from "./server_allocation"
+export * from "./server"
+export * from "./user"