@pelican.ts/sdk 0.4.12 → 0.4.14

package/src/api/application/database_hosts.ts

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

@@ -1,43 +0,0 @@
-import {AxiosInstance} from "axios"
-import {GenericListResponse, GenericResponse} from "@/api/base/types"
-import {Egg, ExportedEgg} 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
-    }
-
-    infoExportable = async (id: number): Promise<ExportedEgg> => {
-        const {data} = await this.r.get<ExportedEgg>(`/eggs/${id}/export`, {
-            params: {format: "json"}
-        })
-        return data
-    }
-}

package/src/api/application/mounts.ts

@@ -1,109 +0,0 @@
-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,126 +0,0 @@
-import {AxiosInstance} from "axios"
-import {NodesAllocations} from "@/api/application/nodes_allocations"
-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"
-
-export class Nodes {
-    private readonly r: AxiosInstance
-
-    constructor(requester: AxiosInstance) {
-        this.r = requester
-    }
-
-    list = async (
-        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", {params: {include: include?.join(","), page}})
-        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> => {
-        z.number().positive().parse(id)
-        const {data} = await this.r.get<GenericResponse<Node, "node">>(
-            `/nodes/${id}`,
-            {params: {include: include?.join(",")}}
-        )
-        return data.attributes
-    }
-
-    create = async (node: z.infer<typeof NodeCreateSchema>): Promise<Node> => {
-        node = NodeCreateSchema.parse(node)
-        const {data} = await this.r.post<GenericResponse<Node, "node">>(
-            "/nodes",
-            node
-        )
-        return data.attributes
-    }
-
-    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)
-        node = NodeCreateSchema.parse(node)
-        const {data} = await this.r.patch<GenericResponse<Node, "node">>(
-            `/nodes/${id}`,
-            node
-        )
-        return data.attributes
-    }
-
-    delete = async (id: number): Promise<void> => {
-        z.number().positive().parse(id)
-        await this.r.delete(`/nodes/${id}`)
-    }
-
-    allocations = (server_id: number): NodesAllocations =>
-        new NodesAllocations(this.r, server_id)
-}
-
-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,47 +0,0 @@
-import {AxiosInstance} from "axios"
-import {
-    Allocation,
-    AllocationRel
-} from "@/api/application/types/server_allocation"
-import {GenericListResponse, GenericResponse} from "@/api/base/types"
-import z from "zod"
-
-export class NodesAllocations {
-    private readonly r: AxiosInstance
-    private readonly id: number
-
-    constructor(requester: AxiosInstance, id: number) {
-        this.r = requester
-        this.id = id
-    }
-
-    list = async (
-        include?: ("node" | "server")[]
-    ): Promise<AllocationRel[]> => {
-        const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<AllocationRel, "allocation">>
-        >(`/nodes/${this.id}/allocations`, {
-            params: {include: include?.join(",")}
-        })
-
-        return data.data.map(d => d.attributes)
-    }
-
-    create = async (
-        ip: string,
-        ports: string[],
-        alias?: string
-    ): Promise<void> => {
-        z.ipv4().parse(ip)
-        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})
-    }
-
-    delete = async (alloc_id: number): Promise<void> => {
-        await this.r.delete(`/nodes/${this.id}/allocations/${alloc_id}`)
-    }
-}

package/src/api/application/roles.ts

@@ -1,39 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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.record(z.string(), z.string()),
-    skip_scripts: z.boolean().optional(),
-    oom_killer: z.boolean().optional(),
-    start_on_completion: z.boolean().optional(),
-    docker_labels: z.record(z.string(), z.string()).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,
-    docker_labels: 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
-}).extend({image: z.string().optional(), skip_scripts: z.boolean()})

package/src/api/application/servers_databases.ts

@@ -1,53 +0,0 @@
-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

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

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

@@ -1,11 +0,0 @@
-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>
-}