@pelican.ts/sdk 0.2.2 → 0.2.4

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 {Server} 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<Server> => {
+        const {data} = await this.r.get<GenericResponse<Server, "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/node.ts

@@ -1,7 +1,8 @@
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {Allocation} from "@/api/common/types/server_allocations";
+import {Allocation} from "@/api/application/types/server_allocation";
 import {Location} from "@/api/application/types/location";
 import {Server} from "@/api/application/types/server";
+import {Nullable} from "@/utils/types";
 
 
 export type Node = {
@@ -9,8 +10,7 @@ export type Node = {
     uuid: string,
     public: boolean,
     name: string,
-    description: string,
-    location_id: number,
+    description: Nullable<string>,
     fqdn: string,
     scheme: "https" | "http",
     behind_proxy: boolean,
@@ -19,15 +19,50 @@ export type Node = {
     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: string | null
+    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<Server, "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

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

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

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

package/src/api/{common/types/server_allocations.ts → application/types/server_allocation.ts}

@@ -1,15 +1,16 @@
 import {GenericResponse} from "@/api/base/types";
 import {Server} from "@/api/application/types/server";
+import {Node} from "@/api/application/types/node";
 import {Nullable} from "@/utils/types";
 
 
 export type Allocation = {
     id: number,
     ip: string,
-    ip_alias: Nullable<string>,
+    alias: Nullable<string>,
     port: number,
     notes: Nullable<string>,
-    is_default: boolean
+    assigned: boolean
 }
 
 export type AllocationRel = Allocation & {

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

@@ -1,19 +1,19 @@
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
 import {Server} from "@/api/application/types/server";
+import {Nullable} from "@/utils/types";
 
 export type User = {
     id: number,
-    external_id: string | null,
+    external_id: Nullable<string>,
     uuid: string,
     username: string,
     email: string,
-    first_name: string,
-    last_name: string,
     language: string,
     root_admin: string,
+    "2fa_enabled": boolean,
     "2fa": boolean,
     created_at: string,
-    updated_at: string,
+    updated_at: Nullable<string>,
     relationships?: {
         servers: GenericListResponse<GenericResponse<Server>>
     }

package/src/api/application/users.ts

@@ -4,6 +4,7 @@ import {GenericListResponse, GenericResponse} from "@/api/base/types";
 import {User} from "@/api/application/types/user";
 import {ArrayQueryParams, SortParam} from "@/utils/transform";
 import {ExactlyOneKey} from "@/utils/types";
+import {languagesSchema, timezonesSchema} from "@/api/common/types/enums";
 
 
 export class Users {
@@ -14,7 +15,7 @@ export class Users {
     }
 
     list = async (
-        {...opts}: ListType,
+        opts: ListType,
         page: number = 1
     ): Promise<User[]> => {
         z.number().positive().parse(page)
@@ -50,23 +51,26 @@ export class Users {
     infoByExternal = async (
         external_id: string,
         {include}: { include?: ("servers")[] }
-        ): Promise<User> => {
+    ): Promise<User> => {
         const {data} = await this.r.get<
             GenericResponse<User, "user">
-        >(`/users/external/${external_id}`)
+        >(`/users/external/${external_id}`, {
+            params: {include: include?.join(",")}
+        })
         return data.attributes
     }
 
-    create = async (user: CreateType): Promise<User> => {
+    create = async (user: z.infer<typeof CreateSchema>): Promise<User> => {
+        user = CreateSchema.parse(user)
         const {data} = await this.r.post<
             GenericResponse<User, "user">
         >("/users", user)
         return data.attributes
     }
 
-    update = async (id: number, user: UpdateType): Promise<User> => {
-        z.number().positive().parse(id)
-        const {data} = await this.r.put<
+    update = async (id: number, user: z.infer<typeof CreateSchema>): Promise<User> => {
+        user = CreateSchema.parse(user)
+        const {data} = await this.r.patch<
             GenericResponse<User, "user">
         >(`/users/${id}`, user)
         return data.attributes
@@ -77,6 +81,15 @@ export class Users {
         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})
+    }
 }
 
 type ListType = {
@@ -90,14 +103,11 @@ type ListFilters = {
 
 type ListSort = ExactlyOneKey<"id" | "uuid", "asc" | "desc">
 
-type CreateType = {
-    email: string,
-    username: string,
-    first_name: string,
-    last_name: string
-}
-
-type UpdateType = CreateType & {
-    language: string
-    password: string
-}
+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

@@ -7,12 +7,12 @@ export class Agent {
     private readonly token: string
     readonly requester: AxiosInstance
 
-    constructor(url: string, token: string, type: "client" | "application") {
-        this.base_url = z.url("Invalid URL Schema").parse(url)
+    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(/\/+$/, "")+`/api/${type}`,
+            baseURL: this.base_url.replace(/\/+$/, "")+`${suffix}/${type}`,
             timeout: 3000,
             headers: {
                 Authorization: `Bearer ${this.token}`

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/common/types/server_allocations";
+import {Allocation} from "@/api/client/types/server_allocation";
 
 export class ServerAllocations {
     private readonly r: AxiosInstance

package/src/api/client/server_databases.ts

@@ -1,7 +1,7 @@
 import {AxiosInstance} from "axios";
 import z from "zod";
 import {GenericListResponse, GenericResponse} from "@/api/base/types";
-import {Database} from "@/api/common/types/server_database";
+import {ServerDatabase} from "@/api/common/types/server_database";
 // TODO: Check for validity
 
 export class ServerDatabases {
@@ -15,26 +15,26 @@ export class ServerDatabases {
 
     list = async (
         include?: ("password")[], page: number = 1
-    ): Promise<Database[]> => {
+    ): Promise<ServerDatabase[]> => {
         z.number().positive().parse(page)
         const {data} = await this.r.get<
-            GenericListResponse<GenericResponse<Database, "server_database">>
+            GenericListResponse<GenericResponse<ServerDatabase, "server_database">>
         >(`/servers/${this.id}/databases`, {
             params: {include: include?.join(","), page}
         })
         return data.data.map(d => d.attributes)
     }
 
-    create = async (database: string, remote: string): Promise<Database> => {
+    create = async (database: string, remote: string): Promise<ServerDatabase> => {
         const {data} = await this.r.post<
-            GenericResponse<Database, "server_database">
+            GenericResponse<ServerDatabase, "server_database">
         >(`/servers/${this.id}/databases`, {database, remote})
         return data.attributes
     }
 
-    rotatePassword = async (database_id: string): Promise<Database> => {
+    rotatePassword = async (database_id: string): Promise<ServerDatabase> => {
         const {data} = await this.r.post<
-            GenericResponse<Database, "server_database">
+            GenericResponse<ServerDatabase, "server_database">
         >(`/servers/${this.id}/databases/${database_id}/rotate-password`)
         return data.attributes
     }

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/common/types/server_allocations";
+import {Allocation} from "@/api/client/types/server_allocation";
 import {Nullable} from "@/utils/types";
 
 export type Server = {

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

@@ -0,0 +1,11 @@
+import {Nullable} from "@/utils/types";
+
+
+export type Allocation = {
+    id: number,
+    ip: string,
+    alias: Nullable<string>,
+    port: number,
+    notes: Nullable<string>,
+    is_default: boolean
+}