@pelican.ts/sdk 0.4.0 → 0.4.1

package/src/humane/Server.ts

@@ -1,50 +1,60 @@
-import type {ServerClient} from "@/api/client/server";
-import type {ServerBackups} from "@/api/client/server_backups";
-import type {ServerFiles} from "@/api/client/server_files";
-import type {ServerSchedules} from "@/api/client/server_schedules";
-import type {Server as ServerT} from "@/api/client/types/server";
-import { ServerAllocation } from "@/humane/ServerAllocation";
-import {ServerBackup} from "@/humane/ServerBackup";
-import {ServerDatabase} from "@/humane/ServerDatabase";
-import {ServerFile} from "@/humane/ServerFile";
-import {ServerSchedule} from "@/humane/ServerSchedule";
-import {ServerUser} from "@/humane/ServerUser";
-import type {EggVariable, FeatureLimits, ServerLimits, SubuserPermission} from "@/types";
-import type {Nullable} from "@/utils/types";
-
+import type { ServerClient } from "@/api/client/server"
+import type { ServerBackups } from "@/api/client/server_backups"
+import type { ServerFiles } from "@/api/client/server_files"
+import type { ServerSchedules } from "@/api/client/server_schedules"
+import type { Server as ServerT } from "@/api/client/types/server"
+import { ServerAllocation } from "@/humane/ServerAllocation"
+import { ServerBackup } from "@/humane/ServerBackup"
+import { ServerDatabase } from "@/humane/ServerDatabase"
+import { ServerFile } from "@/humane/ServerFile"
+import { ServerSchedule } from "@/humane/ServerSchedule"
+import { ServerUser } from "@/humane/ServerUser"
+import type {
+    EggVariable,
+    FeatureLimits,
+    ServerLimits,
+    SubuserPermission,
+} from "@/types"
+import type { Nullable } from "@/utils/types"
 
 export class Server {
     private readonly client: ServerClient
 
-    readonly ownsServer: boolean;
-    readonly identifier: string;
-    readonly internalId?: number;
-    readonly uuid: string;
-    private $name: string;
-    get name() {return this.$name}
-    readonly node: string;
-    readonly isNodeUnderMaintenance: boolean;
+    readonly ownsServer: boolean
+    readonly identifier: string
+    readonly internalId?: number
+    readonly uuid: string
+    private $name: string
+    get name() {
+        return this.$name
+    }
+    readonly node: string
+    readonly isNodeUnderMaintenance: boolean
     readonly sftp: {
-        ip: string,
-        alias: Nullable<string>,
+        ip: string
+        alias: Nullable<string>
         port: number
-    };
-    private $description: string;
-    get description() {return this.$description}
-    readonly limits: ServerLimits;
-    readonly invocation: string;
-    private $dockerImage: string;
-    get dockerImage() {return this.$dockerImage}
-    readonly eggFeatures: Nullable<string[]>;
-    readonly featureLimits: FeatureLimits;
-    readonly status: unknown;
-    readonly isSuspended: boolean;
-    readonly isInstalling: boolean;
-    readonly isTransferring: boolean;
+    }
+    private $description: string
+    get description() {
+        return this.$description
+    }
+    readonly limits: ServerLimits
+    readonly invocation: string
+    private $dockerImage: string
+    get dockerImage() {
+        return this.$dockerImage
+    }
+    readonly eggFeatures: Nullable<string[]>
+    readonly featureLimits: FeatureLimits
+    readonly status: unknown
+    readonly isSuspended: boolean
+    readonly isInstalling: boolean
+    readonly isTransferring: boolean
     readonly allocations: ServerAllocation[]
     readonly variables: EggVariable[]
     readonly egg?: {
-        uuid: string,
+        uuid: string
         name: string
     }
     readonly subusers?: ServerUser[]
@@ -69,40 +79,37 @@ export class Server {
         this.isSuspended = server.is_suspended
         this.isInstalling = server.is_installing
         this.isTransferring = server.is_transferring
-        this.allocations = server.relationships.allocations.data.map(d => new ServerAllocation(this.client, d.attributes))
-        this.variables = server.relationships.variables.data.map(d => d.attributes)
+        this.allocations = server.relationships.allocations.data.map(
+            (d) => new ServerAllocation(this.client, d.attributes),
+        )
+        this.variables = server.relationships.variables.data.map(
+            (d) => d.attributes,
+        )
         this.egg = server.relationships.egg?.attributes
-        this.subusers = server.relationships.subusers?.data.map(d => new ServerUser(this.client, d.attributes))
+        this.subusers = server.relationships.subusers?.data.map(
+            (d) => new ServerUser(this.client, d.attributes),
+        )
     }
 
-    rename = async (
-        name: string
-    ) => {
+    rename = async (name: string) => {
         await this.client.settings.rename(name)
         this.$name = name
     }
 
-    updateDescription = async (
-        description: string
-    ) => {
+    updateDescription = async (description: string) => {
         await this.client.settings.updateDescription(description)
         this.$description = description
     }
 
     reinstall = async () => this.client.settings.reinstall()
 
-    changeDockerImage = async (
-        image: string
-    ) => {
+    changeDockerImage = async (image: string) => {
         await this.client.settings.changeDockerImage(image)
         this.$dockerImage = image
     }
 
     getActivityLogs = async (
-        opts: {
-            page?: number,
-            per_page?: number
-        } = {page: 1, per_page: 50}
+        opts: { page?: number; per_page?: number } = { page: 1, per_page: 50 },
     ) => this.client.activity.list(opts.page, opts.per_page)
 
     websocket = (stripColors: boolean = false) =>
@@ -112,59 +119,47 @@ export class Server {
 
     runCommand = async (command: string) => this.client.command(command)
 
-    sendPowerSignal = async (
-        signal: "start" | "stop" | "restart" | "kill"
-    ) => this.client.power(signal)
-
-
+    sendPowerSignal = async (signal: "start" | "stop" | "restart" | "kill") =>
+        this.client.power(signal)
 
     getDatabases = async (
-        opts: {
-            include?: ("password")[],
-            page?: number
-        } = {include: [], page: 1}
+        opts: { include?: "password"[]; page?: number } = {
+            include: [],
+            page: 1,
+        },
     ) => {
         const data = await this.client.databases.list(opts.include, opts.page)
-        return data.map(d => new ServerDatabase(this.client, d))
+        return data.map((d) => new ServerDatabase(this.client, d))
     }
 
-    createDatabase = async (
-        database: string,
-        remote: string
-    ) => {
+    createDatabase = async (database: string, remote: string) => {
         const data = await this.client.databases.create(database, remote)
         return new ServerDatabase(this.client, data)
     }
 
     getSchedules = async () => {
         const data = await this.client.schedules.list()
-        return data.map(d => new ServerSchedule(this.client, d))
+        return data.map((d) => new ServerSchedule(this.client, d))
     }
 
-    createSchedule = async (
-        ...opts: Parameters<ServerSchedules["create"]>
-    ) => {
+    createSchedule = async (...opts: Parameters<ServerSchedules["create"]>) => {
         const data = await this.client.schedules.create(...opts)
         return new ServerSchedule(this.client, data)
     }
 
-    getBackups = async (
-        page: number = 1
-    ) => {
+    getBackups = async (page: number = 1) => {
         const data = await this.client.backups.list(page)
-        return data.map(d => new ServerBackup(this.client, d))
+        return data.map((d) => new ServerBackup(this.client, d))
     }
 
-    createBackup = async (
-        ...args: Parameters<ServerBackups["create"]>
-    ) => {
+    createBackup = async (...args: Parameters<ServerBackups["create"]>) => {
         const data = await this.client.backups.create(...args)
         return new ServerBackup(this.client, data)
     }
 
     getAllocations = async () => {
         const data = await this.client.allocations.list()
-        return data.map(d => new ServerAllocation(this.client, d))
+        return data.map((d) => new ServerAllocation(this.client, d))
     }
 
     createAllocation = async () => {
@@ -172,20 +167,16 @@ export class Server {
         return new ServerAllocation(this.client, data)
     }
 
-    getFiles = async (
-        path?: string
-    ) => {
+    getFiles = async (path?: string) => {
         const data = await this.client.files.list(path)
-        return data.map(d => new ServerFile(this.client, d))
+        return data.map((d) => new ServerFile(this.client, d))
     }
 
-    createFolder = async (
-        ...opts: Parameters<ServerFiles["createFolder"]>
-    ) => this.client.files.createFolder(...opts)
+    createFolder = async (...opts: Parameters<ServerFiles["createFolder"]>) =>
+        this.client.files.createFolder(...opts)
 
-    uploadFile = async (
-        ...opts: Parameters<ServerFiles["upload"]>
-    ) => this.client.files.upload(...opts)
+    uploadFile = async (...opts: Parameters<ServerFiles["upload"]>) =>
+        this.client.files.upload(...opts)
 
     uploadFileGetUrl = async (
         ...opts: Parameters<ServerFiles["uploadGetUrl"]>
@@ -197,12 +188,12 @@ export class Server {
 
     getUsers = async () => {
         const data = await this.client.users.list()
-        return data.map(d => new ServerUser(this.client, d))
+        return data.map((d) => new ServerUser(this.client, d))
     }
 
     createUser = async (
         email: string,
-        permissions: SubuserPermission[] | string[]
+        permissions: SubuserPermission[] | string[],
     ) => {
         const data = await this.client.users.create(email, permissions)
         return new ServerUser(this.client, data)
@@ -210,8 +201,6 @@ export class Server {
 
     getStartupInfo = async () => this.client.startup.list()
 
-    setStartupVariable = async (
-        key: string,
-        value: string
-    ) => this.client.startup.set(key, value)
-}
+    setStartupVariable = async (key: string, value: string) =>
+        this.client.startup.set(key, value)
+}

package/src/humane/ServerAllocation.ts

@@ -1,6 +1,6 @@
-import type {ServerClient} from "@/api/client/server";
-import type {ServerAllocation as ServerAllocationT} from "@/api/client/types/server_allocation";
-import type {Nullable} from "@/utils/types";
+import type { ServerClient } from "@/api/client/server"
+import type { ServerAllocation as ServerAllocationT } from "@/api/client/types/server_allocation"
+import type { Nullable } from "@/utils/types"
 
 export class ServerAllocation {
     private readonly client: ServerClient
@@ -8,9 +8,13 @@ export class ServerAllocation {
     readonly id: number
     readonly ip: string
     private $isDefault: boolean
-    get isDefault() {return this.$isDefault}
+    get isDefault() {
+        return this.$isDefault
+    }
     private $notes: Nullable<string>
-    get notes() {return this.$notes}
+    get notes() {
+        return this.$notes
+    }
     readonly port: number
 
     constructor(client: ServerClient, alloc: ServerAllocationT) {
@@ -23,9 +27,7 @@ export class ServerAllocation {
         this.port = alloc.port
     }
 
-    setNotes = async (
-        notes: string
-    ) => {
+    setNotes = async (notes: string) => {
         const data = await this.client.allocations.setNotes(this.id, notes)
         this.$notes = data.notes
     }
@@ -36,4 +38,4 @@ export class ServerAllocation {
     }
 
     unassign = async () => this.client.allocations.unassign(this.id)
-}
+}

package/src/humane/ServerBackup.ts

@@ -1,7 +1,6 @@
-import type {ServerClient} from "@/api/client/server";
-import type {ServerBackup as ServerBackupT} from "@/api/common/types/server_backup";
-import type {Nullable} from "@/utils/types";
-
+import type { ServerClient } from "@/api/client/server"
+import type { ServerBackup as ServerBackupT } from "@/api/common/types/server_backup"
+import type { Nullable } from "@/utils/types"
 
 export class ServerBackup {
     private readonly client: ServerClient
@@ -19,7 +18,9 @@ export class ServerBackup {
         this.client = client
         this.bytes = backup.bytes
         this.checksum = backup.checksum
-        this.completedAt = backup.completed_at ? new Date(backup.completed_at) : null
+        this.completedAt = backup.completed_at
+            ? new Date(backup.completed_at)
+            : null
         this.createdAt = new Date(backup.created_at)
         this.ignoredFiles = backup.ignored_files
         this.isLocked = backup.is_locked
@@ -27,11 +28,10 @@ export class ServerBackup {
         this.name = backup.name
         this.uuid = backup.uuid
     }
-    
 
     downloadGetUrl = async () => this.client.backups.downloadGetUrl(this.uuid)
 
     download = async () => this.client.backups.download(this.uuid)
 
     delete = async () => this.client.backups.delete(this.uuid)
-}
+}

package/src/humane/ServerDatabase.ts

@@ -1,5 +1,5 @@
-import type {ServerClient} from "@/api/client/server";
-import type {ServerDatabase as ServerDatabaseT} from "@/api/common/types/server_database";
+import type { ServerClient } from "@/api/client/server"
+import type { ServerDatabase as ServerDatabaseT } from "@/api/common/types/server_database"
 // TODO: Check for validity
 
 export class ServerDatabase {
@@ -11,7 +11,9 @@ export class ServerDatabase {
     readonly maxConnections: number
     readonly name: string
     private $password?: string
-    get password() {return this.$password}
+    get password() {
+        return this.$password
+    }
     readonly username: string
 
     constructor(client: ServerClient, database: ServerDatabaseT) {
@@ -26,11 +28,10 @@ export class ServerDatabase {
         this.username = database.username
     }
 
-
     rotatePassword = async () => {
         const data = await this.client.databases.rotatePassword(this.id)
         this.$password = data.relationships?.password.attributes.password
     }
 
     delete = async () => this.client.databases.delete(this.id)
-}
+}

package/src/humane/ServerFile.ts

@@ -1,7 +1,6 @@
-import path from "node:path";
-import type {ServerClient} from "@/api/client/server";
-import type {FileObject} from "@/api/common/types/server_files";
-
+import path from "node:path"
+import type { ServerClient } from "@/api/client/server"
+import type { FileObject } from "@/api/common/types/server_files"
 
 export class ServerFile {
     private readonly client: ServerClient
@@ -35,8 +34,14 @@ export class ServerFile {
     get isArchive() {
         // Maybe mimetype is better
         return [
-            "zip", "tgz", "tar.gz", "txz", "tar.xz", "tbz2", "tar.bz2"
-        ].some(ext => this.name.endsWith(`.${ext}`))
+            "zip",
+            "tgz",
+            "tar.gz",
+            "txz",
+            "tar.xz",
+            "tbz2",
+            "tar.bz2",
+        ].some((ext) => this.name.endsWith(`.${ext}`))
     }
 
     /**
@@ -48,26 +53,36 @@ export class ServerFile {
 
     download = async () => this.client.files.download(this.path)
 
-    rename = async (
-        newName: string
-    ) => this.client.files.rename(this.dir, [{from: this.name, to: newName}])
+    rename = async (newName: string) =>
+        this.client.files.rename(this.dir, [{ from: this.name, to: newName }])
 
     copy = async () => this.client.files.copy(this.path)
 
-    write = async (
-        content: string
-    ) => this.client.files.write(this.path, content)
+    write = async (content: string) =>
+        this.client.files.write(this.path, content)
 
     compress = async (
         archive_name?: string,
-        extension?: "zip" | "tgz" | "tar.gz" | "txz" | "tar.xz" | "tbz2" | "tar.bz2"
-    ) => this.client.files.compress(this.dir, [this.name], archive_name, extension)
+        extension?:
+            | "zip"
+            | "tgz"
+            | "tar.gz"
+            | "txz"
+            | "tar.xz"
+            | "tbz2"
+            | "tar.bz2",
+    ) =>
+        this.client.files.compress(
+            this.dir,
+            [this.name],
+            archive_name,
+            extension,
+        )
 
     decompress = async () => this.client.files.decompress(this.dir, this.name)
 
     delete = async () => this.client.files.delete(this.dir, [this.name])
 
-    chmod = async (
-        mode: number
-    ) => this.client.files.chmod(this.dir, [{file: this.name, mode}])
-}
+    chmod = async (mode: number) =>
+        this.client.files.chmod(this.dir, [{ file: this.name, mode }])
+}

package/src/humane/ServerSchedule.ts

@@ -1,32 +1,43 @@
-import type {ServerClient} from "@/api/client/server";
-import type {Schedule, ScheduleTask} from "@/api/common/types/server_schedule";
-import type {Nullable, PartialBy} from "@/utils/types";
-
+import type { ServerClient } from "@/api/client/server"
+import type { Schedule, ScheduleTask } from "@/api/common/types/server_schedule"
+import type { Nullable, PartialBy } from "@/utils/types"
 
 export class ServerSchedule {
     private readonly client: ServerClient
     readonly createdAt: Date
     private $cron: {
-        day_of_week: string,
-        day_of_month: string,
-        hour: string,
+        day_of_week: string
+        day_of_month: string
+        hour: string
         minute: string
     }
-    get cron() {return {...this.$cron}}
+    get cron() {
+        return { ...this.$cron }
+    }
     readonly id: number
     private $isActive: boolean
-    get isActive() {return this.$isActive}
+    get isActive() {
+        return this.$isActive
+    }
     private $isProcessing: boolean
-    get isProcessing() {return this.$isProcessing}
+    get isProcessing() {
+        return this.$isProcessing
+    }
     readonly lastRunAt: Nullable<Date>
     private $name: string
-    get name() {return this.$name}
+    get name() {
+        return this.$name
+    }
     readonly nextRunAt: Date
     private $onlyWhenOnline: boolean
-    get onlyWhenOnline() {return this.$onlyWhenOnline}
+    get onlyWhenOnline() {
+        return this.$onlyWhenOnline
+    }
     readonly tasks: ServerScheduleTask[]
     private $updatedAt: Date
-    get updatedAt() {return this.$updatedAt}
+    get updatedAt() {
+        return this.$updatedAt
+    }
 
     constructor(client: ServerClient, schedule: Schedule) {
         this.client = client
@@ -35,28 +46,28 @@ export class ServerSchedule {
         this.id = schedule.id
         this.$isActive = schedule.is_active
         this.$isProcessing = schedule.is_processing
-        this.lastRunAt = schedule.last_run_at ? new Date(schedule.last_run_at) : null
+        this.lastRunAt = schedule.last_run_at
+            ? new Date(schedule.last_run_at)
+            : null
         this.$name = schedule.name
         this.nextRunAt = new Date(schedule.next_run_at)
         this.$onlyWhenOnline = schedule.only_when_online
         this.tasks = schedule.relationships.tasks.data.map(
-            d => new ServerScheduleTask(this.client, this.id, d.attributes)
+            (d) => new ServerScheduleTask(this.client, this.id, d.attributes),
         )
         this.$updatedAt = new Date(schedule.updated_at)
     }
 
-    update = async (
-        opts: {
-            name: string,
-            is_active?: boolean,
-            only_when_online?: boolean,
-            minute: string,
-            hour: string,
-            day_of_week: string,
-            month: string,
-            day_of_month: string
-        }
-    ) => {
+    update = async (opts: {
+        name: string
+        is_active?: boolean
+        only_when_online?: boolean
+        minute: string
+        hour: string
+        day_of_week: string
+        month: string
+        day_of_month: string
+    }) => {
         const data = await this.client.schedules.control(this.id).update(opts)
         this.$name = data.name
         this.$isActive = data.is_active
@@ -74,22 +85,36 @@ export class ServerSchedule {
 export class ServerScheduleTask {
     private readonly client: ServerClient
     private readonly scheduleId: number
-    private $action: "command" | "power" | "backup" | "delete_files";
-    get action() {return this.$action}
-    private $continueOnFailure: boolean;
-    get continueOnFailure() {return this.$continueOnFailure}
-    readonly createdAt: Date;
-    readonly id: number;
-    private $isQueued: boolean;
-    get isQueued() {return this.$isQueued}
-    private $payload: string;
-    get payload() {return this.$payload}
-    private $sequenceId: number;
-    get sequenceId() {return this.$sequenceId}
-    private $timeOffset: number;
-    get timeOffset() {return this.$timeOffset}
-    private $updatedAt: Nullable<Date>;
-    get updatedAt() {return this.$updatedAt}
+    private $action: "command" | "power" | "backup" | "delete_files"
+    get action() {
+        return this.$action
+    }
+    private $continueOnFailure: boolean
+    get continueOnFailure() {
+        return this.$continueOnFailure
+    }
+    readonly createdAt: Date
+    readonly id: number
+    private $isQueued: boolean
+    get isQueued() {
+        return this.$isQueued
+    }
+    private $payload: string
+    get payload() {
+        return this.$payload
+    }
+    private $sequenceId: number
+    get sequenceId() {
+        return this.$sequenceId
+    }
+    private $timeOffset: number
+    get timeOffset() {
+        return this.$timeOffset
+    }
+    private $updatedAt: Nullable<Date>
+    get updatedAt() {
+        return this.$updatedAt
+    }
 
     constructor(client: ServerClient, scheduleId: number, task: ScheduleTask) {
         this.client = client
@@ -110,11 +135,20 @@ export class ServerScheduleTask {
 
     update = async (
         opts: PartialBy<
-            Pick<ScheduleTask, "action" | "payload" | "time_offset" | "sequence_id" | "continue_on_failure">,
+            Pick<
+                ScheduleTask,
+                | "action"
+                | "payload"
+                | "time_offset"
+                | "sequence_id"
+                | "continue_on_failure"
+            >,
             "payload" | "sequence_id" | "continue_on_failure"
-        >
+        >,
     ) => {
-        const data = await this.client.schedules.control(this.scheduleId).tasks.update(this.id, opts)
+        const data = await this.client.schedules
+            .control(this.scheduleId)
+            .tasks.update(this.id, opts)
         this.$action = data.action
         this.$continueOnFailure = data.continue_on_failure
         this.$isQueued = data.is_queued
@@ -123,4 +157,4 @@ export class ServerScheduleTask {
         this.$timeOffset = data.time_offset
         this.$updatedAt = data.updated_at ? new Date(data.updated_at) : null
     }
-}
+}