@pelican.ts/sdk 0.4.8 → 0.4.10

package/src/api/application/database_hosts.ts

@@ -1,7 +1,7 @@
-import {AxiosInstance} from "axios";
-import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {DatabaseHost} from "@/api/application/types/database_host";
-import z from "zod";
+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
@@ -10,20 +10,14 @@ export class DatabaseHosts {
         this.r = r
     }
 
-    list = async (
-        page: number = 1
-    ): Promise<DatabaseHost[]> => {
+    list = async (page: number = 1): Promise<DatabaseHost[]> => {
         const {data} = await this.r.get<
             GenericListResponse<GenericResponse<DatabaseHost, "database_host">>
-        >("/database-hosts", {
-            params: {page}
-        })
+        >("/database-hosts", {params: {page}})
         return data.data.map(d => d.attributes)
     }
 
-    info = async (
-        id: string
-    ): Promise<DatabaseHost> => {
+    info = async (id: string): Promise<DatabaseHost> => {
         const {data} = await this.r.get<
             GenericResponse<DatabaseHost, "database_host">
         >(`/database-hosts/${id}`)
@@ -35,9 +29,12 @@ export class DatabaseHosts {
         opts: z.infer<typeof CreateDBHostSchema>
     ): Promise<void> => {
         opts = CreateDBHostSchema.parse(opts)
-        await this.r.post<
-            GenericResponse<DatabaseHost, "database_host">
-        >("/database-hosts", opts).catch(e=>{})
+        await this.r
+            .post<GenericResponse<DatabaseHost, "database_host">>(
+                "/database-hosts",
+                opts
+            )
+            .catch(e => {})
     }
 
     update = async (
@@ -52,9 +49,7 @@ export class DatabaseHosts {
         return data.attributes
     }
 
-    delete = async (
-        id: string
-    ): Promise<void> => {
+    delete = async (id: string): Promise<void> => {
         await this.r.delete(`/database-hosts/${id}`)
     }
 }
@@ -67,4 +62,4 @@ const CreateDBHostSchema = z.object({
     password: z.string().optional(),
     node_ids: z.array(z.string()).optional(),
     max_databases: z.number().optional()
-})
+})

package/src/api/application/eggs.ts

@@ -1,6 +1,6 @@
-import {AxiosInstance} from "axios";
-import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {Egg, ExportedEgg} from "@/api/application/types/egg";
+import {AxiosInstance} from "axios"
+import {GenericListResponse, GenericResponse} from "@/api/base/types"
+import {Egg, ExportedEgg} from "@/api/application/types/egg"
 
 // TODO: API is incomplete
 
@@ -12,12 +12,17 @@ export class Eggs {
     }
 
     list = async (): Promise<Egg[]> => {
-        const {data} = await this.r.get<GenericListResponse<GenericResponse<Egg, "egg">>>("/eggs")
+        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}`)
+        const {data} = await this.r.get<GenericResponse<Egg, "egg">>(
+            `/eggs/${id}`
+        )
         return data.attributes
     }
 
@@ -30,7 +35,9 @@ export class Eggs {
     }
 
     infoExportable = async (id: number): Promise<ExportedEgg> => {
-        const {data} = await this.r.get<ExportedEgg>(`/eggs/${id}/export`, {params: {format: "json"}})
+        const {data} = await this.r.get<ExportedEgg>(`/eggs/${id}/export`, {
+            params: {format: "json"}
+        })
         return data
     }
-}
+}

package/src/api/application/mounts.ts

@@ -1,9 +1,9 @@
-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";
+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
@@ -13,26 +13,40 @@ export class Mounts {
     }
 
     list = async (): Promise<Mount[]> => {
-        const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<Mount, "mount">>
-        >("/mounts")
+        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}`)
+        const {data} = await this.r.get<GenericResponse<Mount, "mount">>(
+            `/mounts/${id}`
+        )
         return data.attributes
     }
 
-    create = async (opts: z.infer<typeof CreateMountSchema>): Promise<Mount> => {
+    create = async (
+        opts: z.infer<typeof CreateMountSchema>
+    ): Promise<Mount> => {
         opts = CreateMountSchema.parse(opts)
-        const {data} = await this.r.post<GenericResponse<Mount, "mount">>("/mounts", 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> => {
+    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)
+        const {data} = await this.r.patch<GenericResponse<Mount, "mount">>(
+            `/mounts/${id}`,
+            opts
+        )
         return data.attributes
     }
 
@@ -86,11 +100,10 @@ export class Mounts {
     }
 }
 
-
 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,10 +1,9 @@
-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";
-
+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
@@ -20,18 +19,16 @@ export class Nodes {
         z.number().positive().parse(page)
         const {data} = await this.r.get<
             GenericListResponse<GenericResponse<Node, "node">>
-        >("/nodes", {
-            params: {include: include?.join(","), page}
-        })
+        >("/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[],
+            disk: number
+            memory: number
+            cpu?: number
+            location_ids?: string[]
             tags?: string[]
         },
         include?: ("allocations" | "location" | "servers")[],
@@ -56,37 +53,43 @@ export class Nodes {
 
     info = async (
         id: number,
-        include?: ("allocations" | "location" | "servers")[],
+        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(",")}
-        })
+        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)
+        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`)
+        const {data} = await this.r.get<NodeConfiguration>(
+            `/nodes/${id}/configuration`
+        )
         return data
     }
 
-    update = async (id: number, node: z.infer<typeof NodeCreateSchema>): Promise<Node> => {
+    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)
+        const {data} = await this.r.patch<GenericResponse<Node, "node">>(
+            `/nodes/${id}`,
+            node
+        )
         return data.attributes
     }
 
@@ -95,9 +98,8 @@ export class Nodes {
         await this.r.delete(`/nodes/${id}`)
     }
 
-    allocations = (server_id: number): NodesAllocations => (
+    allocations = (server_id: number): NodesAllocations =>
         new NodesAllocations(this.r, server_id)
-    )
 }
 
 const NodeCreateSchema = z.object({
@@ -120,5 +122,5 @@ const NodeCreateSchema = z.object({
     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(),
-})
+    tags: z.array(z.string()).optional()
+})

package/src/api/application/nodes_allocations.ts

@@ -1,8 +1,10 @@
-import {AxiosInstance} from "axios";
-import {Allocation, AllocationRel} from "@/api/application/types/server_allocation";
-import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import z from "zod";
-
+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
@@ -13,7 +15,9 @@ export class NodesAllocations {
         this.id = id
     }
 
-    list = async (include?: ("node" | "server")[]): Promise<AllocationRel[]> => {
+    list = async (
+        include?: ("node" | "server")[]
+    ): Promise<AllocationRel[]> => {
         const {data} = await this.r.get<
             GenericListResponse<GenericResponse<AllocationRel, "allocation">>
         >(`/nodes/${this.id}/allocations`, {
@@ -30,14 +34,14 @@ export class NodesAllocations {
     ): 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)
+        z.array(z.number())
+            .or(z.string().regex(/\d+-\d+/))
+            .parse(ports)
 
-        await this.r.post(`/nodes/${this.id}/allocations`, {
-            ip, ports, alias
-        })
+        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,7 +1,6 @@
-import {AxiosInstance} from "axios";
-import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {Role} from "@/api/application/types/role";
-
+import {AxiosInstance} from "axios"
+import {GenericListResponse, GenericResponse} from "@/api/base/types"
+import {Role} from "@/api/application/types/role"
 
 // TODO: API is incomplete
 
@@ -12,42 +11,29 @@ export class Roles {
         this.r = r
     }
 
-    list = async (
-        page: number = 1
-    ): Promise<Role[]> => {
+    list = async (page: number = 1): Promise<Role[]> => {
         const {data} = await this.r.get<
             GenericListResponse<GenericResponse<Role, "role">>
-        >(`/roles`, {
-            params: {page}
-        })
+        >(`/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}`)
+    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> => {
+    create = async (opts: {name: string}): Promise<void> => {
         await this.r.post(`/roles`, opts)
     }
 
-    update = async (
-        id: number,
-        opts: {name: string}
-    ): Promise<void> => {
+    update = async (id: number, opts: {name: string}): Promise<void> => {
         await this.r.patch(`/roles/${id}`, opts)
     }
 
-    delete = async (
-        id: number
-    ): Promise<void> => {
+    delete = async (id: number): Promise<void> => {
         await this.r.delete(`/roles/${id}`)
     }
-}
+}

package/src/api/application/servers.ts

@@ -1,8 +1,8 @@
-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";
+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
@@ -16,10 +16,12 @@ export class Servers {
         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(",")}
-        })
+    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
     }
 
@@ -27,17 +29,23 @@ export class Servers {
         await this.r.delete(`/servers/${this.id}${force ? "/force" : ""}`)
     }
 
-    updateDetails = async (opts: z.infer<typeof UpdateDetailsSchema>): Promise<void> => {
+    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> => {
+    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> => {
+    updateStartup = async (
+        opts: z.infer<typeof UpdateStartupSchema>
+    ): Promise<void> => {
         opts = UpdateStartupSchema.parse(opts)
         await this.r.patch(`/servers/${this.id}/startup`, opts)
     }
@@ -71,7 +79,6 @@ export class Servers {
     }
 }
 
-
 export const CreateServerSchema = z.object({
     external_id: z.string().min(1).max(255).optional(),
     name: z.string().min(1).max(255),
@@ -98,15 +105,19 @@ export const CreateServerSchema = z.object({
         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()
+    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({
@@ -120,11 +131,11 @@ const UpdateDetailsSchema = CreateServerSchema.pick({
 const UpdateBuildSchema = CreateServerSchema.pick({
     oom_killer: true,
     limits: true,
-    feature_limits: true,
+    feature_limits: true
 }).extend({
     allocation: z.number().optional(),
     add_allocations: z.array(z.string()).optional(),
-    remove_allocations: z.array(z.string()).optional(),
+    remove_allocations: z.array(z.string()).optional()
 })
 
 const UpdateStartupSchema = CreateServerSchema.pick({
@@ -132,6 +143,4 @@ const UpdateStartupSchema = CreateServerSchema.pick({
     environment: true,
     egg: true,
     skip_scripts: true
-}).extend({
-    image: z.string().optional()
-})
+}).extend({image: z.string().optional()})

package/src/api/application/servers_databases.ts

@@ -1,7 +1,7 @@
-import {AxiosInstance} from "axios";
-import {ServerDatabase} from "@/api/common/types/server_database";
-import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import z from "zod";
+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 {
@@ -15,7 +15,9 @@ export class ServersDatabases {
 
     list = async (): Promise<ServerDatabase[]> => {
         const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<ServerDatabase, "server_database">>
+            GenericListResponse<
+                GenericResponse<ServerDatabase, "server_database">
+            >
         >(`/servers/${this.id}/databases`)
         return data.data.map(d => d.attributes)
     }
@@ -44,6 +46,8 @@ export class ServersDatabases {
     }
 
     resetPassword = async (database_id: number): Promise<void> => {
-        await this.r.post(`/servers/${this.id}/databases/${database_id}/reset-password`)
+        await this.r.post(
+            `/servers/${this.id}/databases/${database_id}/reset-password`
+        )
     }
-}
+}

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

@@ -1,10 +1,9 @@
-
 export type Container = {
-    startup_command: string,
-    image: string,
-    installed: number,
-    environment: Record<string, string>,
-    ports: number[],
-    volumes: string[],
+    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 +1,11 @@
-import {Nullable} from "@/utils/types";
+import {Nullable} from "@/utils/types"
 
 export type DatabaseHost = {
-    id: number,
-    name: string,
-    host: string,
-    port: number,
-    username: string,
-    created_at: string,
+    id: number
+    name: string
+    host: string
+    port: number
+    username: string
+    created_at: string
     updated_at: Nullable<string>
-}
+}