@pelican.ts/sdk 0.2.4 → 0.3.0

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@pelican.ts/sdk",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "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",

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

@@ -2,11 +2,13 @@ import {AxiosInstance} from "axios";
 import {Users} from "@/api/application/users";
 import {Nodes} from "@/api/application/nodes";
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {Server} from "@/api/application/types/server";
+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";
+import {Eggs} from "@/api/application/eggs";
+import {Mounts} from "@/api/application/mounts";
 
 export class Client {
     private readonly r: AxiosInstance
@@ -14,6 +16,8 @@ export class Client {
     nodes: Nodes
     databaseHosts: DatabaseHosts
     roles: Roles
+    eggs: Eggs
+    mounts: Mounts
 
     constructor(requester: AxiosInstance) {
         this.r = requester
@@ -22,28 +26,30 @@ export class Client {
         this.nodes = new Nodes(requester)
         this.databaseHosts = new DatabaseHosts(requester)
         this.roles = new Roles(requester)
+        this.eggs = new Eggs(requester)
+        this.mounts = new Mounts(requester)
     }
 
     listServers = async (
         search?: string,
         page: number = 1
-    ): Promise<Server[]> => {
+    ): Promise<ApplicationServer[]> => {
         const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<Server, "server">>
+            GenericListResponse<GenericResponse<ApplicationServer, "server">>
         >("/servers", {
             params: {search, page}
         })
         return data.data.map(s => s.attributes)
     }
 
-    createServer = async (opts: z.infer<typeof CreateServerSchema>): Promise<Server> => {
+    createServer = async (opts: z.infer<typeof CreateServerSchema>): Promise<ApplicationServer> => {
         opts = CreateServerSchema.parse(opts)
-        const {data} = await this.r.post<GenericResponse<Server, "server">>("/servers", opts)
+        const {data} = await this.r.post<GenericResponse<ApplicationServer, "server">>("/servers", opts)
         return data.attributes
     }
 
-    getServerByExternalId = async (external_id: string, include?: ("egg" | "subusers")[]): Promise<Server> => {
-        const {data} = await this.r.get<GenericResponse<Server, "server">>(`/servers/external/${external_id}`, {
+    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

package/src/api/application/eggs.ts

@@ -0,0 +1,31 @@
+import {AxiosInstance} from "axios";
+import {GenericListResponse, GenericResponse} from "@/api/base/types";
+import {Egg} from "@/api/application/types/egg";
+
+// TODO: API is incomplete
+
+export class Eggs {
+    private readonly r: AxiosInstance
+
+    constructor(r: AxiosInstance) {
+        this.r = r
+    }
+
+    list = async (): Promise<Egg[]> => {
+        const {data} = await this.r.get<GenericListResponse<GenericResponse<Egg, "egg">>>("/eggs")
+        return data.data.map(d => d.attributes)
+    }
+
+    info = async (id: number): Promise<Egg> => {
+        const {data} = await this.r.get<GenericResponse<Egg, "egg">>(`/eggs/${id}`)
+        return data.attributes
+    }
+
+    export = async (id: number, format: "json" | "yaml"): Promise<string> => {
+        const {data} = await this.r.get<string>(`/eggs/${id}/export`, {
+            params: {format},
+            transformResponse: r => r
+        })
+        return data
+    }
+}

package/src/api/application/mounts.ts

@@ -0,0 +1,96 @@
+import {AxiosInstance} from "axios";
+import {Mount} from "@/api/application/types/mount";
+import {GenericListResponse, GenericResponse} from "@/api/base/types";
+import z from "zod";
+import {Egg} from "@/api/application/types/egg";
+import {ApplicationServer} from "@/api/application/types";
+
+export class Mounts {
+    private readonly r: AxiosInstance
+
+    constructor(r: AxiosInstance) {
+        this.r = r
+    }
+
+    list = async (): Promise<Mount[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<Mount, "mount">>
+        >("/mounts")
+        return data.data.map(d => d.attributes)
+    }
+
+    info = async (id: number): Promise<Mount> => {
+        const {data} = await this.r.get<GenericResponse<Mount, "mount">>(`/mounts/${id}`)
+        return data.attributes
+    }
+
+    create = async (opts: z.infer<typeof CreateMountSchema>): Promise<Mount> => {
+        opts = CreateMountSchema.parse(opts)
+        const {data} = await this.r.post<GenericResponse<Mount, "mount">>("/mounts", opts)
+        return data.attributes
+    }
+
+    update = async (id: number, opts: z.infer<typeof CreateMountSchema>): Promise<Mount> => {
+        opts = CreateMountSchema.parse(opts)
+        const {data} = await this.r.patch<GenericResponse<Mount, "mount">>(`/mounts/${id}`, opts)
+        return data.attributes
+    }
+
+    delete = async (id: number): Promise<void> => {
+        await this.r.delete(`/mounts/${id}`)
+    }
+
+    listAssignedEggs = async (id: number): Promise<Egg[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<Egg, "egg">>
+        >(`/mounts/${id}/eggs`)
+        return data.data.map(d => d.attributes)
+    }
+
+    assignEggs = async (id: number, eggs: number[]): Promise<void> => {
+        await this.r.post(`/mounts/${id}/eggs`, {eggs})
+    }
+
+    unassignEgg = async (id: number, egg_id: number): Promise<void> => {
+        await this.r.delete(`/mounts/${id}/eggs/${egg_id}`)
+    }
+
+    listAssignedNodes = async (id: number): Promise<Node[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<Node, "node">>
+        >(`/mounts/${id}/nodes`)
+        return data.data.map(d => d.attributes)
+    }
+
+    assignNodes = async (id: number, nodes: number[]): Promise<void> => {
+        await this.r.post(`/mounts/${id}/nodes`, {nodes})
+    }
+
+    unassignNode = async (id: number, node_id: number): Promise<void> => {
+        await this.r.delete(`/mounts/${id}/nodes/${node_id}`)
+    }
+
+    listAssignedServers = async (id: number): Promise<ApplicationServer[]> => {
+        const {data} = await this.r.get<
+            GenericListResponse<GenericResponse<ApplicationServer, "server">>
+        >(`/mounts/${id}/servers`)
+        return data.data.map(d => d.attributes)
+    }
+
+    assignServers = async (id: number, servers: number[]): Promise<void> => {
+        await this.r.post(`/mounts/${id}/servers`, {servers})
+    }
+
+    unassignServer = async (id: number, server_id: number): Promise<void> => {
+        await this.r.delete(`/mounts/${id}/servers/${server_id}`)
+    }
+}
+
+
+const CreateMountSchema = z.object({
+    name: z.string().min(1).max(255),
+    description: z.string().optional(),
+    source: z.string(),
+    target: z.string(),
+    read_only: z.boolean().optional()
+})

package/src/api/application/nodes.ts

@@ -1,6 +1,6 @@
 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, NodeConfiguration} from "@/api/application/types/node";

package/src/api/application/servers.ts

@@ -1,7 +1,7 @@
 import {AxiosInstance} from "axios";
 import z from "zod";
 import {GenericResponse} from "@/api/base/types";
-import {Server} from "@/api/application/types/server";
+import {ApplicationServer} from "@/api/application/types/server";
 import {ServersDatabases} from "@/api/application/servers_databases";
 
 export class Servers {
@@ -16,8 +16,8 @@ export class Servers {
         this.databases = new ServersDatabases(this.r, this.id)
     }
 
-    info = async (include?: ("egg" | "subusers")[]): Promise<Server> => {
-        const {data} = await this.r.get<GenericResponse<Server, "server">>(`/servers/${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

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

@@ -0,0 +1,37 @@
+import {Nullable} from "@/utils/types";
+
+export type Egg = {
+    id: number,
+    uuid: string,
+    name: number,
+    author: string,
+    description: string,
+    features: string[],
+    tags: string[],
+    docker_image: string,
+    docker_images: Record<string, string>,
+    config: {
+        files: Record<string, FileConfig>
+        startup: Record<string, string>,
+        stop: string,
+        logs: object | [],
+        file_denylist: string[],
+        extends: Nullable<number>
+    },
+    startup: string,
+    startup_commands: Record<string, string>,
+    script: {
+        privileged: boolean,
+        install: string,
+        entry: string,
+        container: string,
+        extends: Nullable<number>
+    },
+    created_at: string,
+    updated_at: Nullable<string>
+}
+
+type FileConfig = {
+    parser: string,
+    find: Record<string, string>
+}

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

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

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

@@ -0,0 +1,12 @@
+import {Nullable} from "@/utils/types";
+
+export type Mount = {
+    id: number,
+    uuid: string,
+    name: string,
+    description: Nullable<string>,
+    source: string,
+    target: string,
+    read_only: boolean,
+    user_mountable: boolean
+}

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

@@ -1,7 +1,7 @@
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
 import {Allocation} from "@/api/application/types/server_allocation";
 import {Location} from "@/api/application/types/location";
-import {Server} from "@/api/application/types/server";
+import {ApplicationServer} from "@/api/application/types/server";
 import {Nullable} from "@/utils/types";
 
 
@@ -38,7 +38,7 @@ export type Node = {
     relationships?: {
         allocations?: GenericListResponse<GenericResponse<Allocation, "allocation">>,
         location?: GenericResponse<Location, "location">,
-        servers?: GenericListResponse<GenericResponse<Server, "server">>
+        servers?: GenericListResponse<GenericResponse<ApplicationServer, "server">>
     }
 }
 

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

@@ -3,7 +3,7 @@ import {Container} from "@/api/application/types/container";
 import {Nullable} from "@/utils/types";
 
 
-export type Server = {
+export type ApplicationServer = {
     id: number,
     external_id: Nullable<string>,
     uuid: string,

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

@@ -1,5 +1,5 @@
 import {GenericResponse} from "@/api/base/types";
-import {Server} from "@/api/application/types/server";
+import {ApplicationServer} from "@/api/application/types/server";
 import {Node} from "@/api/application/types/node";
 import {Nullable} from "@/utils/types";
 
@@ -16,6 +16,6 @@ export type Allocation = {
 export type AllocationRel = Allocation & {
     relationships?: {
         node?: GenericResponse<Node, "node">,
-        server?: GenericResponse<Server, "server">
+        server?: GenericResponse<ApplicationServer, "server">
     }
 }

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

@@ -1,8 +1,8 @@
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {Server} from "@/api/application/types/server";
+import {ApplicationServer} from "@/api/application/types/server";
 import {Nullable} from "@/utils/types";
 
-export type User = {
+export type ApplicationUser = {
     id: number,
     external_id: Nullable<string>,
     uuid: string,
@@ -15,6 +15,6 @@ export type User = {
     created_at: string,
     updated_at: Nullable<string>,
     relationships?: {
-        servers: GenericListResponse<GenericResponse<Server>>
+        servers: GenericListResponse<GenericResponse<ApplicationServer>>
     }
 }

package/src/api/application/users.ts

@@ -1,7 +1,7 @@
 import {AxiosInstance} from "axios";
 import z from "zod";
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {User} from "@/api/application/types/user";
+import {ApplicationUser} from "@/api/application/types/user";
 import {ArrayQueryParams, SortParam} from "@/utils/transform";
 import {ExactlyOneKey} from "@/utils/types";
 import {languagesSchema, timezonesSchema} from "@/api/common/types/enums";
@@ -17,10 +17,10 @@ export class Users {
     list = async (
         opts: ListType,
         page: number = 1
-    ): Promise<User[]> => {
+    ): Promise<ApplicationUser[]> => {
         z.number().positive().parse(page)
         const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<User, "user">>
+            GenericListResponse<GenericResponse<ApplicationUser, "user">>
         >("/users", {
             params: {
                 include: opts.include?.join(","),
@@ -38,10 +38,10 @@ export class Users {
     info = async (
         id: number,
         {include}: { include?: ("servers")[] }
-    ): Promise<User> => {
+    ): Promise<ApplicationUser> => {
         z.number().positive().parse(id)
         const {data} = await this.r.get<
-            GenericResponse<User, "user">
+            GenericResponse<ApplicationUser, "user">
         >(`/users/${id}`, {
             params: {include: include?.join(",")}
         })
@@ -51,27 +51,27 @@ export class Users {
     infoByExternal = async (
         external_id: string,
         {include}: { include?: ("servers")[] }
-    ): Promise<User> => {
+    ): Promise<ApplicationUser> => {
         const {data} = await this.r.get<
-            GenericResponse<User, "user">
+            GenericResponse<ApplicationUser, "user">
         >(`/users/external/${external_id}`, {
             params: {include: include?.join(",")}
         })
         return data.attributes
     }
 
-    create = async (user: z.infer<typeof CreateSchema>): Promise<User> => {
+    create = async (user: z.infer<typeof CreateSchema>): Promise<ApplicationUser> => {
         user = CreateSchema.parse(user)
         const {data} = await this.r.post<
-            GenericResponse<User, "user">
+            GenericResponse<ApplicationUser, "user">
         >("/users", user)
         return data.attributes
     }
 
-    update = async (id: number, user: z.infer<typeof CreateSchema>): Promise<User> => {
+    update = async (id: number, user: z.infer<typeof CreateSchema>): Promise<ApplicationUser> => {
         user = CreateSchema.parse(user)
         const {data} = await this.r.patch<
-            GenericResponse<User, "user">
+            GenericResponse<ApplicationUser, "user">
         >(`/users/${id}`, user)
         return data.attributes
     }

package/src/api/client/server_allocations.ts

@@ -1,6 +1,6 @@
 import {AxiosInstance} from "axios";
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {Allocation} from "@/api/client/types/server_allocation";
+import {ServerAllocation} from "@/api/client/types/server_allocation";
 
 export class ServerAllocations {
     private readonly r: AxiosInstance
@@ -11,30 +11,30 @@ export class ServerAllocations {
         this.id = id
     }
 
-    list = async (): Promise<Allocation[]> => {
+    list = async (): Promise<ServerAllocation[]> => {
         const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<Allocation, "allocation">>
+            GenericListResponse<GenericResponse<ServerAllocation, "allocation">>
         >(`/servers/${this.id}/network/allocations`)
         return data.data.map(r => r.attributes)
     }
 
-    autoAssign = async (): Promise<Allocation> => {
+    autoAssign = async (): Promise<ServerAllocation> => {
         const {data} = await this.r.post<
-            GenericResponse<Allocation, "allocation">
+            GenericResponse<ServerAllocation, "allocation">
         >(`/servers/${this.id}/network/allocations`)
         return data.attributes
     }
 
-    setNotes = async (alloc_id: number, notes: string): Promise<Allocation> => {
+    setNotes = async (alloc_id: number, notes: string): Promise<ServerAllocation> => {
         const {data} = await this.r.post<
-            GenericResponse<Allocation, "allocation">
+            GenericResponse<ServerAllocation, "allocation">
         >(`/servers/${this.id}/network/allocations/${alloc_id}`, {notes})
         return data.attributes
     }
 
-    setPrimary = async (alloc_id: number): Promise<Allocation> => {
+    setPrimary = async (alloc_id: number): Promise<ServerAllocation> => {
         const {data} = await this.r.post<
-            GenericResponse<Allocation, "allocation">
+            GenericResponse<ServerAllocation, "allocation">
         >(`/servers/${this.id}/network/allocations/${alloc_id}/primary`)
         return data.attributes
     }

package/src/api/client/server_backups.ts

@@ -1,5 +1,5 @@
 import axios, {AxiosInstance} from "axios";
-import {Backup} from "@/api/common/types/server_backup";
+import {ServerBackup} from "@/api/common/types/server_backup";
 import z, {string} from "zod";
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
 
@@ -13,10 +13,10 @@ export class ServerBackups {
         this.id = id
     }
 
-    list = async (page: number = 1): Promise<Backup[]> => {
+    list = async (page: number = 1): Promise<ServerBackup[]> => {
         z.number().positive().parse(page)
         const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<Backup, "backup">>
+            GenericListResponse<GenericResponse<ServerBackup, "backup">>
         >(`/servers/${this.id}/backups`, {
             params: {page}
         })
@@ -28,10 +28,10 @@ export class ServerBackups {
         name?: string,
         is_locked: boolean,
         ignored_files: string[],
-    }): Promise<Backup> => {
+    }): Promise<ServerBackup> => {
         args.name = z.string().max(255).optional().parse(args.name)
         const {data} = await this.r.post<
-            GenericResponse<Backup, "backup">
+            GenericResponse<ServerBackup, "backup">
         >(`/servers/${this.id}/backups`, {
             name: args.name,
             is_locked: args.is_locked,
@@ -40,9 +40,9 @@ export class ServerBackups {
         return data.attributes
     }
 
-    info = async (backup_uuid: string): Promise<Backup> => {
+    info = async (backup_uuid: string): Promise<ServerBackup> => {
         const {data} = await this.r.get<
-            GenericResponse<Backup, "backup">
+            GenericResponse<ServerBackup, "backup">
         >(`/servers/${this.id}/backups/${backup_uuid}`)
         return data.attributes
     }

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

@@ -0,0 +1,5 @@
+export * from "./websocket"
+export * from "./server_allocation"
+export * from "./server_subuser"
+export * from "./server"
+export * from "./user"

package/src/api/client/types/server.ts

@@ -2,7 +2,7 @@ import {GenericListResponse, GenericResponse} from "@/api/base/types";
 import {EggVariable} from "@/api/common/types/egg";
 import {ServerSubuser} from "@/api/client/types/server_subuser";
 import {FeatureLimits, ServerLimits} from "@/api/common/types/server_limits";
-import {Allocation} from "@/api/client/types/server_allocation";
+import {ServerAllocation} from "@/api/client/types/server_allocation";
 import {Nullable} from "@/utils/types";
 
 export type Server = {
@@ -29,7 +29,7 @@ export type Server = {
     is_installing: boolean,
     is_transferring: boolean,
     relationships: {
-        allocations: GenericListResponse<GenericResponse<Allocation, "allocation">>,
+        allocations: GenericListResponse<GenericResponse<ServerAllocation, "allocation">>,
         variables: GenericListResponse<GenericResponse<EggVariable, "egg_variable">>,
         egg?: GenericResponse<{
             uuid: string,

package/src/api/client/types/server_allocation.ts

@@ -1,7 +1,7 @@
 import {Nullable} from "@/utils/types";
 
 
-export type Allocation = {
+export type ServerAllocation = {
     id: number,
     ip: string,
     alias: Nullable<string>,

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

@@ -0,0 +1,9 @@
+export * from "./server_power"
+export * from "./server_database"
+export * from "./server_limits"
+export * from "./server_startup"
+export * from "./server_backup"
+export * from "./egg"
+export * from "./server_files"
+export * from "./enums"
+export * from "./server_schedule"

package/src/api/common/types/server_backup.ts

@@ -1,7 +1,7 @@
 import {Nullable} from "@/utils/types";
 
 
-export type Backup = {
+export type ServerBackup = {
     uuid: string
     is_successful: boolean,
     is_locked: boolean,

package/src/types.ts

@@ -0,0 +1,3 @@
+export * from "./api/common/types"
+export * from "./api/application/types"
+export * from "./api/client/types"