@pelican.ts/sdk 0.4.12 → 0.4.14

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

@@ -1,65 +0,0 @@
-import {Nullable} from "@/utils/types"
-import {EggVariable} from "@/api/common/types"
-
-export type Egg = {
-    id: number
-    uuid: string
-    name: string
-    author: string
-    description: string
-    features: string[]
-    tags: string[]
-    docker_image: Nullable<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>}
-
-export type ApplicationEggVariable = Omit<
-    EggVariable,
-    "server_value" | "is_editable" | "rules"
-> & {
-    rules: string[]
-    sort: number
-    user_viewable: boolean
-    user_editable: boolean
-}
-
-export type ExportedEgg = {
-    meta: {version: "PLCN_v3"; update_url: Nullable<string>}
-    exported_at: string
-    name: string
-    author: string
-    description: string
-    uuid: string
-    image: Nullable<string>
-    docker_images: Record<string, string>
-    features: string[]
-    tags: string[]
-    file_denylist: string[]
-    startup_commands: Record<string, string>
-    config: Omit<Egg["config"], "extends" | "file_denylist">
-    scripts: {
-        installation: {script: string; container: string; entrypoint: string}
-    }
-    variables: ApplicationEggVariable[]
-}

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

@@ -1,10 +0,0 @@
-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/location.ts

@@ -1,7 +0,0 @@
-export type Location = {
-    id: number
-    short: string
-    long: string
-    created_at: string
-    updated_at: string | null
-}

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

@@ -1,12 +0,0 @@
-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,58 +0,0 @@
-import {GenericListResponse, GenericResponse} from "@/api/base/types"
-import {Allocation} from "@/api/application/types/server_allocation"
-import {Location} from "@/api/application/types/location"
-import {ApplicationServer} from "@/api/application/types/server"
-import {Nullable} from "@/utils/types"
-
-export type Node = {
-    id: number
-    uuid: string
-    public: boolean
-    name: string
-    description: Nullable<string>
-    fqdn: string
-    scheme: "https" | "http"
-    behind_proxy: boolean
-    maintenance_mode: boolean
-    memory: number
-    memory_overallocate: number
-    disk: number
-    disk_overallocate: number
-    cpu: number
-    cpu_overallocate: number
-    upload_size: number
-    daemon_listen: number
-    daemon_sftp: number
-    daemon_sftp_alias: Nullable<string>
-    daemon_base: string
-    daemon_connect: number
-    created_at: string
-    updated_at: Nullable<string>
-    tags: string[]
-    allocated_resources: {memory: number; disk: number; cpu: number}
-    relationships?: {
-        allocations?: GenericListResponse<
-            GenericResponse<Allocation, "allocation">
-        >
-        location?: GenericResponse<Location, "location">
-        servers?: GenericListResponse<
-            GenericResponse<ApplicationServer, "server">
-        >
-    }
-}
-
-export type NodeConfiguration = {
-    debug: boolean
-    uuid: string
-    token_id: string
-    token: string
-    api: {
-        host: string
-        port: number
-        upload_limit: number
-        ssl: {enabled: boolean; cert: string; key: string}
-    }
-    system: {data: string; sftp: {bind_port: number}}
-    allowed_mounts: string[]
-    remote: string
-}

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

@@ -1,6 +0,0 @@
-export type Role = {
-    id: number
-    name: string
-    created_at: string
-    updated_at: string
-}

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

@@ -1,24 +0,0 @@
-import {FeatureLimits, ServerLimits} from "@/api/common/types/server_limits"
-import {Container} from "@/api/application/types/container"
-import {Nullable} from "@/utils/types"
-
-export type ApplicationServer = {
-    id: number
-    external_id: Nullable<string>
-    uuid: string
-    identifier: string
-    name: string
-    description: string
-    status: Nullable<unknown>
-    docker_labels: Record<string, string>
-    suspended: boolean
-    limits: ServerLimits
-    feature_limits: FeatureLimits
-    user: number
-    node: number
-    allocation: number
-    egg: number
-    container: Container
-    created_at: string
-    updated_at: Nullable<string>
-}

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

@@ -1,20 +0,0 @@
-import {GenericResponse} from "@/api/base/types"
-import {ApplicationServer} from "@/api/application/types/server"
-import {Node} from "@/api/application/types/node"
-import {Nullable} from "@/utils/types"
-
-export type Allocation = {
-    id: number
-    ip: string
-    alias: Nullable<string>
-    port: number
-    notes: Nullable<string>
-    assigned: boolean
-}
-
-export type AllocationRel = Allocation & {
-    relationships?: {
-        node?: GenericResponse<Node, "node">
-        server?: GenericResponse<ApplicationServer, "server">
-    }
-}

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

@@ -1,34 +0,0 @@
-import {GenericListResponse, GenericResponse} from "@/api/base/types"
-import {ApplicationServer} from "@/api/application/types/server"
-import {Nullable} from "@/utils/types"
-
-export type ApplicationUser = {
-    id: number
-    external_id: Nullable<string>
-    uuid: string
-    username: string
-    email: string
-    language: string
-    root_admin: string
-    "2fa_enabled": boolean
-    "2fa": boolean
-    created_at: string
-    updated_at: Nullable<string>
-    relationships?: {
-        servers: GenericListResponse<GenericResponse<ApplicationServer>>
-    }
-}
-
-export type ApplicationUserApiKey = {
-    id: number
-    user_id: number
-    key_type: 1
-    identifier: string
-    memo: string
-    allowed_ips: Array<string>
-    permissions: []
-    last_used_at: Nullable<string>
-    expires_at: Nullable<string>
-    created_at: string
-    updated_at: string
-}

package/src/api/application/users.ts

@@ -1,146 +0,0 @@
-import {AxiosInstance} from "axios"
-import z from "zod"
-import {GenericListResponse, GenericResponse} from "@/api/base/types"
-import {
-    ApplicationUser,
-    ApplicationUserApiKey
-} from "@/api/application/types/user"
-import {ArrayQueryParams, SortParam} from "@/utils/transform"
-import {ExactlyOneKey} from "@/utils/types"
-import {languagesSchema, timezonesSchema} from "@/api/common/types/enums"
-import {APIKey} from "@/api/client/types"
-
-export class Users {
-    private readonly r: AxiosInstance
-
-    constructor(requester: AxiosInstance) {
-        this.r = requester
-    }
-
-    list = async (
-        opts: ListType,
-        page: number = 1
-    ): Promise<ApplicationUser[]> => {
-        z.number().positive().parse(page)
-        const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<ApplicationUser, "user">>
-        >("/users", {
-            params: {
-                include: opts.include?.join(","),
-                page,
-                ...ArrayQueryParams({filters: opts.filters || {}}),
-                sort: opts.sort?.id
-                    ? SortParam("id", opts.sort?.id)
-                    : SortParam("uuid", opts.sort?.uuid!)
-            }
-        })
-
-        return data.data.map(d => d.attributes)
-    }
-
-    info = async (
-        id: number,
-        {include}: {include?: "servers"[]}
-    ): Promise<ApplicationUser> => {
-        z.number().positive().parse(id)
-        const {data} = await this.r.get<
-            GenericResponse<ApplicationUser, "user">
-        >(`/users/${id}`, {params: {include: include?.join(",")}})
-        return data.attributes
-    }
-
-    infoByExternal = async (
-        external_id: string,
-        {include}: {include?: "servers"[]}
-    ): Promise<ApplicationUser> => {
-        const {data} = await this.r.get<
-            GenericResponse<ApplicationUser, "user">
-        >(`/users/external/${external_id}`, {
-            params: {include: include?.join(",")}
-        })
-        return data.attributes
-    }
-
-    create = async (
-        user: z.infer<typeof CreateSchema>
-    ): Promise<ApplicationUser> => {
-        user = CreateSchema.parse(user)
-        const {data} = await this.r.post<
-            GenericResponse<ApplicationUser, "user">
-        >("/users", user)
-        return data.attributes
-    }
-
-    update = async (
-        id: number,
-        user: z.infer<typeof CreateSchema>
-    ): Promise<ApplicationUser> => {
-        user = CreateSchema.parse(user)
-        const {data} = await this.r.patch<
-            GenericResponse<ApplicationUser, "user">
-        >(`/users/${id}`, user)
-        return data.attributes
-    }
-
-    delete = async (id: number): Promise<void> => {
-        z.number().positive().parse(id)
-        await this.r.delete(`/users/${id}`)
-    }
-
-    addRoles = async (id: number, roles: number[]): Promise<void> => {
-        z.number().positive().parse(id)
-        await this.r.patch(`/users/${id}/roles/assign`, {roles})
-    }
-
-    removeRoles = async (id: number, roles: number[]): Promise<void> => {
-        z.number().positive().parse(id)
-        await this.r.patch(`/users/${id}/roles/remove`, {roles})
-    }
-
-    apiKeys = {
-        list: async (id: number): Promise<ApplicationUserApiKey[]> => {
-            const {data} = await this.r.get<
-                GenericListResponse<
-                    GenericResponse<ApplicationUserApiKey, "api_key">
-                >
-            >(`/users/${id}/api-keys`)
-            return data.data.map(k => k.attributes)
-        },
-
-        create: async (
-            id: number,
-            description: string,
-            allowed_ips?: string[]
-        ): Promise<ApplicationUserApiKey & {secret_token: string}> => {
-            allowed_ips = z.array(z.ipv4()).optional().parse(allowed_ips)
-            const {data} = await this.r.post<
-                GenericResponse<
-                    ApplicationUserApiKey,
-                    "api_key",
-                    {secret_token: string}
-                >
-            >(`/users/${id}/api-keys`, {description, allowed_ips})
-            return {...data.attributes, secret_token: data.meta!.secret_token}
-        },
-
-        delete: async (id: number, identifier: string): Promise<void> => {
-            await this.r.delete(`/users/${id}/api-keys/${identifier}`)
-        }
-    }
-}
-
-type ListType = {include?: "servers"[]; filters?: ListFilters; sort?: ListSort}
-type ListFilters = {
-    [key in "email" | "uuid" | "username" | "external_id"]: string
-}
-
-type ListSort = ExactlyOneKey<"id" | "uuid", "asc" | "desc">
-
-const CreateSchema = z.object({
-    email: z.email(),
-    external_id: z.string().max(255).optional(),
-    username: z.string().min(1).max(255),
-    password: z.string().optional(),
-    language: languagesSchema,
-    timezone: timezonesSchema
-})

package/src/api/base/request.ts

@@ -1,44 +0,0 @@
-import z from "zod"
-import axios, {AxiosInstance, AxiosResponse} from "axios"
-import {PterodactylError, PterodactylException} from "@/api/base/types"
-
-export class Agent {
-    private readonly base_url: string
-    private readonly token: string
-    readonly requester: AxiosInstance
-
-    constructor(
-        url: string,
-        token: string,
-        type: "client" | "application",
-        suffix: string = "/api"
-    ) {
-        this.base_url = z
-            .url("Invalid URL Schema")
-            .transform(url => new URL(url).href)
-            .parse(url)
-        this.token = z
-            .string()
-            .regex(/^(ptl[ac]|pacc|papp)_.+$/, "Invalid token type")
-            .parse(token)
-
-        this.requester = axios.create({
-            baseURL: this.base_url.replace(/\/+$/, "") + `${suffix}/${type}`,
-            timeout: 3000,
-            headers: {Authorization: `Bearer ${this.token}`}
-        })
-
-        this.requester.interceptors.response.use(undefined, (error: any) => {
-            if (error.response && error.response.status === 400) {
-                return Promise.reject(
-                    new PterodactylException(
-                        "Invalid request data",
-                        error.response.data as PterodactylError[],
-                        error.response.status
-                    )
-                )
-            }
-            return Promise.reject(error)
-        })
-    }
-}

package/src/api/base/types.ts

@@ -1,40 +0,0 @@
-export type GenericResponse<T, N extends string = string, M = undefined> = {
-    object: N
-    attributes: T
-    meta?: M
-}
-
-type PaginationMeta = {
-    total: number
-    count: number
-    per_page: number
-    current_page: number
-    total_pages: number
-    links: any
-}
-
-export type GenericListResponse<T> = {
-    object: "list"
-    data: T[]
-    meta?: {pagination: PaginationMeta}
-}
-
-export type CustomListResponse<T, M> = {object: "list"; data: T[]; meta?: M}
-
-export class PterodactylException extends Error {
-    data: PterodactylError[]
-    status: number
-
-    constructor(message: string, data: PterodactylError[], status: number) {
-        super(message)
-        this.data = data
-        this.status = status
-    }
-}
-
-export type PterodactylError = {
-    code: string
-    status?: number
-    detail: string
-    source?: {[key: string]: string}
-}

package/src/api/client/account.ts

@@ -1,77 +0,0 @@
-import {AxiosInstance} from "axios"
-import {APIKey, SSHKey, User} from "@/api/client/types/user"
-import {GenericListResponse, GenericResponse} from "@/api/base/types"
-import z from "zod"
-
-export class Account {
-    private readonly r: AxiosInstance
-
-    constructor(requester: AxiosInstance) {
-        this.r = requester
-    }
-
-    info = async (): Promise<User> => {
-        const {data} =
-            await this.r.get<GenericResponse<User, "user">>("/account")
-        return data.attributes
-    }
-
-    updateEmail = async (newEmail: string, password: string): Promise<void> => {
-        newEmail = z.email().parse(newEmail)
-        await this.r.put("/account/email", {email: newEmail, password})
-    }
-
-    updatePassword = async (newPassword: string): Promise<void> => {
-        newPassword = z.string().min(8).parse(newPassword)
-        await this.r.put("/account/password", {
-            password: newPassword,
-            password_confirmation: newPassword
-        })
-    }
-
-    apiKeys = {
-        list: async (): Promise<APIKey[]> => {
-            const {data} =
-                await this.r.get<
-                    GenericListResponse<GenericResponse<APIKey, "api_key">>
-                >("/account/api-keys")
-            return data.data.map(k => k.attributes)
-        },
-
-        create: async (
-            description: string,
-            allowed_ips?: string[]
-        ): Promise<APIKey & {secret_token: string}> => {
-            allowed_ips = z.array(z.ipv4()).optional().parse(allowed_ips)
-            const {data} = await this.r.post<
-                GenericResponse<APIKey, "api_key", {secret_token: string}>
-            >("/account/api-keys", {description, allowed_ips})
-            return {...data.attributes, secret_token: data.meta!.secret_token}
-        },
-
-        delete: async (identifier: string): Promise<void> => {
-            await this.r.delete(`/account/api-keys/${identifier}`)
-        }
-    }
-
-    sshKeys = {
-        list: async (): Promise<SSHKey[]> => {
-            const {data} =
-                await this.r.get<
-                    GenericListResponse<GenericResponse<SSHKey, "ssh_key">>
-                >("/account/ssh-keys")
-            return data.data.map(k => k.attributes)
-        },
-
-        create: async (name: string, public_key: string): Promise<SSHKey> => {
-            const {data} = await this.r.post<
-                GenericResponse<SSHKey, "ssh_key">
-            >("/account/ssh-keys", {name, public_key})
-            return data.attributes
-        },
-
-        delete: async (fingerprint: string): Promise<void> => {
-            await this.r.post(`/account/ssh-keys/remove`, {fingerprint})
-        }
-    }
-}

package/src/api/client/client.ts

@@ -1,56 +0,0 @@
-import {Account} from "@/api/client/account"
-import {AxiosInstance} from "axios"
-import {Permission} from "@/api/client/types/user"
-import {GenericListResponse, GenericResponse} from "@/api/base/types"
-import {Server} from "@/api/client/types/server"
-import z from "zod"
-import {ServerClient} from "@/api/client/server"
-
-export class Client {
-    account: Account
-
-    private readonly r: AxiosInstance
-
-    constructor(requester: AxiosInstance) {
-        this.r = requester
-        this.account = new Account(requester)
-    }
-
-    get $r(): AxiosInstance {
-        return this.r
-    }
-
-    listPermissions = async (): Promise<Record<string, Permission>> => {
-        const {data} =
-            await this.r.get<
-                GenericResponse<
-                    {permissions: Record<string, Permission>},
-                    "system_permissions"
-                >
-            >("/permissions")
-
-        return data.attributes.permissions
-    }
-
-    listServers = async (
-        type: "accessible" | "mine" | "admin" | "admin-all" = "accessible",
-        page: number = 1,
-        per_page: number = 50,
-        include?: ("egg" | "subusers")[]
-    ): Promise<Server[]> => {
-        z.number().positive().parse(page)
-        const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<Server, "server">>
-        >("/", {params: {type, page, include: include?.join(",")}})
-        return data.data.map(s => s.attributes)
-    }
-
-    server = (uuid: string): ServerClient => new ServerClient(this.r, uuid)
-}
-
-/*
-Include:    ?include=param1,param2
-Avail:      ?param1=val1&param2=val2
-Filters:    ?filter[param1]=val1&filter[param2]=val2
-Sort:       ?sort=-param, param=asc, -param=desc
-*/

package/src/api/client/server.ts

@@ -1,74 +0,0 @@
-import {AxiosInstance} from "axios"
-import {GenericResponse} from "@/api/base/types"
-import {Server, ServerStats} from "@/api/client/types/server"
-import {ServerDatabases} from "@/api/client/server_databases"
-import {ServerFiles} from "@/api/client/server_files"
-import {ServerSchedules} from "@/api/client/server_schedules"
-import {ServerAllocations} from "@/api/client/server_allocations"
-import {ServerUsers} from "@/api/client/server_users"
-import {ServerBackups} from "@/api/client/server_backups"
-import {ServerStartup} from "@/api/client/server_startup"
-import {ServerSettings} from "@/api/client/server_settings"
-import {ServerWebsocket} from "@/api/client/server_websocket"
-import {ServerActivity} from "@/api/client/server_activity"
-
-export class ServerClient {
-    private readonly r: AxiosInstance
-    private readonly id: string
-
-    activity: ServerActivity
-    databases: ServerDatabases
-    files: ServerFiles
-    schedules: ServerSchedules
-    allocations: ServerAllocations
-    users: ServerUsers
-    backups: ServerBackups
-    startup: ServerStartup
-    variables: ServerStartup
-    settings: ServerSettings
-
-    constructor(requester: AxiosInstance, id: string) {
-        this.r = requester
-        this.id = id
-
-        this.activity = new ServerActivity(requester, id)
-        this.databases = new ServerDatabases(requester, id)
-        this.files = new ServerFiles(requester, id)
-        this.schedules = new ServerSchedules(requester, id)
-        this.allocations = new ServerAllocations(requester, id)
-        this.users = new ServerUsers(requester, id)
-        this.backups = new ServerBackups(requester, id)
-        this.startup = new ServerStartup(requester, id)
-        this.variables = this.startup // preferable
-        this.settings = new ServerSettings(requester, id)
-    }
-
-    info = async (include?: ("egg" | "subusers")[]): Promise<Server> => {
-        const {data} = await this.r.get<GenericResponse<Server, "server">>(
-            `/servers/${this.id}`,
-            {params: {include: include?.join(",")}}
-        )
-        return data.attributes
-    }
-
-    websocket = (stripColors: boolean = false): ServerWebsocket => {
-        return new ServerWebsocket(this.r, this.id, stripColors)
-    }
-
-    resources = async (): Promise<ServerStats> => {
-        const {data} = await this.r.get<GenericResponse<ServerStats, "stats">>(
-            `/servers/${this.id}/resources`
-        )
-        return data.attributes
-    }
-
-    command = async (command: string): Promise<void> => {
-        await this.r.post(`/servers/${this.id}/command`, {command})
-    }
-
-    power = async (
-        signal: "start" | "stop" | "restart" | "kill"
-    ): Promise<void> => {
-        await this.r.post(`/servers/${this.id}/power`, {signal})
-    }
-}