@pelican.ts/sdk 0.3.4-next.4 → 0.4.1

package/src/humane/Client.ts

@@ -0,0 +1,44 @@
+import type { Client as ClientT } from "@/api/client/client"
+import { Account } from "@/humane/Account"
+import { Server } from "@/humane/Server"
+
+export class Client {
+    private readonly client: ClientT
+
+    constructor(client: ClientT) {
+        this.client = client
+    }
+
+    get $client(): ClientT {
+        return this.client
+    }
+
+    getAccount = async () => {
+        const user = await this.client.account.info()
+        return new Account(this.client, user)
+    }
+
+    listPermissions = async () => this.client.listPermissions()
+
+    listServers = async (
+        opts: {
+            type?: "accessible" | "mine" | "admin" | "admin-all"
+            page?: number
+            per_page?: number
+            include?: ("egg" | "subusers")[]
+        } = { type: "accessible", page: 1, per_page: 50 },
+    ) => {
+        const data = await this.client.listServers(
+            opts.type,
+            opts.page,
+            opts.per_page,
+            opts.include,
+        )
+        return data.map((d) => new Server(this.client.server(d.uuid), d))
+    }
+
+    getServer = async (uuid: string, include?: ("egg" | "subusers")[]) => {
+        const server = await this.client.server(uuid).info(include)
+        return new Server(this.client.server(uuid), server)
+    }
+}

package/src/humane/Server.ts

@@ -0,0 +1,206 @@
+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 sftp: {
+        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
+    readonly allocations: ServerAllocation[]
+    readonly variables: EggVariable[]
+    readonly egg?: {
+        uuid: string
+        name: string
+    }
+    readonly subusers?: ServerUser[]
+
+    constructor(client: ServerClient, server: ServerT) {
+        this.client = client
+        this.ownsServer = server.server_owner
+        this.identifier = server.identifier
+        this.internalId = server.internal_id
+        this.uuid = server.uuid
+        this.$name = server.name
+        this.node = server.node
+        this.isNodeUnderMaintenance = server.is_node_under_maintenance
+        this.sftp = server.sftp_details
+        this.$description = server.description
+        this.limits = server.limits
+        this.invocation = server.invocation
+        this.$dockerImage = server.docker_image
+        this.eggFeatures = server.egg_features
+        this.featureLimits = server.feature_limits
+        this.status = server.status
+        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.egg = server.relationships.egg?.attributes
+        this.subusers = server.relationships.subusers?.data.map(
+            (d) => new ServerUser(this.client, d.attributes),
+        )
+    }
+
+    rename = async (name: string) => {
+        await this.client.settings.rename(name)
+        this.$name = name
+    }
+
+    updateDescription = async (description: string) => {
+        await this.client.settings.updateDescription(description)
+        this.$description = description
+    }
+
+    reinstall = async () => this.client.settings.reinstall()
+
+    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 },
+    ) => this.client.activity.list(opts.page, opts.per_page)
+
+    websocket = (stripColors: boolean = false) =>
+        this.client.websocket(stripColors)
+
+    getServerStats = async () => this.client.resources()
+
+    runCommand = async (command: string) => this.client.command(command)
+
+    sendPowerSignal = async (signal: "start" | "stop" | "restart" | "kill") =>
+        this.client.power(signal)
+
+    getDatabases = async (
+        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))
+    }
+
+    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))
+    }
+
+    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) => {
+        const data = await this.client.backups.list(page)
+        return data.map((d) => new ServerBackup(this.client, d))
+    }
+
+    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))
+    }
+
+    createAllocation = async () => {
+        const data = await this.client.allocations.autoAssign()
+        return new ServerAllocation(this.client, data)
+    }
+
+    getFiles = async (path?: string) => {
+        const data = await this.client.files.list(path)
+        return data.map((d) => new ServerFile(this.client, d))
+    }
+
+    createFolder = async (...opts: Parameters<ServerFiles["createFolder"]>) =>
+        this.client.files.createFolder(...opts)
+
+    uploadFile = async (...opts: Parameters<ServerFiles["upload"]>) =>
+        this.client.files.upload(...opts)
+
+    uploadFileGetUrl = async (
+        ...opts: Parameters<ServerFiles["uploadGetUrl"]>
+    ) => this.client.files.uploadGetUrl(...opts)
+
+    pullFileFromRemote = async (
+        ...opts: Parameters<ServerFiles["pullFromRemote"]>
+    ) => this.client.files.pullFromRemote(...opts)
+
+    getUsers = async () => {
+        const data = await this.client.users.list()
+        return data.map((d) => new ServerUser(this.client, d))
+    }
+
+    createUser = async (
+        email: string,
+        permissions: SubuserPermission[] | string[],
+    ) => {
+        const data = await this.client.users.create(email, permissions)
+        return new ServerUser(this.client, data)
+    }
+
+    getStartupInfo = async () => this.client.startup.list()
+
+    setStartupVariable = async (key: string, value: string) =>
+        this.client.startup.set(key, value)
+}

package/src/humane/ServerAllocation.ts

@@ -0,0 +1,41 @@
+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
+    readonly alias: Nullable<string>
+    readonly id: number
+    readonly ip: string
+    private $isDefault: boolean
+    get isDefault() {
+        return this.$isDefault
+    }
+    private $notes: Nullable<string>
+    get notes() {
+        return this.$notes
+    }
+    readonly port: number
+
+    constructor(client: ServerClient, alloc: ServerAllocationT) {
+        this.client = client
+        this.alias = alloc.alias
+        this.id = alloc.id
+        this.ip = alloc.ip
+        this.$isDefault = alloc.is_default
+        this.$notes = alloc.notes
+        this.port = alloc.port
+    }
+
+    setNotes = async (notes: string) => {
+        const data = await this.client.allocations.setNotes(this.id, notes)
+        this.$notes = data.notes
+    }
+
+    makeDefault = async () => {
+        const data = await this.client.allocations.setPrimary(this.id)
+        this.$isDefault = data.is_default
+    }
+
+    unassign = async () => this.client.allocations.unassign(this.id)
+}

package/src/humane/ServerBackup.ts

@@ -0,0 +1,37 @@
+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
+    readonly bytes: number
+    readonly checksum: Nullable<string>
+    readonly completedAt: Nullable<Date>
+    readonly createdAt: Date
+    readonly ignoredFiles: string[]
+    readonly isLocked: boolean
+    readonly isSuccessful: boolean
+    readonly name: string
+    readonly uuid: string
+
+    constructor(client: ServerClient, backup: ServerBackupT) {
+        this.client = client
+        this.bytes = backup.bytes
+        this.checksum = backup.checksum
+        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
+        this.isSuccessful = backup.is_successful
+        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

@@ -0,0 +1,37 @@
+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 {
+    private readonly client: ServerClient
+    readonly allowConnectionsFrom: string
+    readonly host: string
+    readonly port: number
+    readonly id: string
+    readonly maxConnections: number
+    readonly name: string
+    private $password?: string
+    get password() {
+        return this.$password
+    }
+    readonly username: string
+
+    constructor(client: ServerClient, database: ServerDatabaseT) {
+        this.client = client
+        this.allowConnectionsFrom = database.connections_from
+        this.host = database.host.address
+        this.port = database.host.port
+        this.id = database.id
+        this.maxConnections = database.max_connections
+        this.name = database.name
+        this.$password = database.relationships?.password.attributes.password
+        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

@@ -0,0 +1,88 @@
+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
+    private readonly dir: string
+    private readonly path: string
+    readonly createdAt: Date
+    readonly isFile: boolean
+    readonly isSymlink: boolean
+    readonly mimetype: string
+    readonly mode: string
+    readonly modeBits: string
+    readonly modifiedAt: Date
+    readonly name: string
+    readonly size: number
+
+    constructor(client: ServerClient, file: FileObject, dir: string = "/") {
+        this.client = client
+        this.dir = dir
+        this.createdAt = new Date(file.created_at)
+        this.isFile = file.is_file
+        this.isSymlink = file.is_symlink
+        this.mimetype = file.mimetype
+        this.mode = file.mode
+        this.modeBits = file.mode_bits
+        this.modifiedAt = new Date(file.modified_at)
+        this.name = file.name
+        this.size = file.size
+        this.path = path.join(dir, this.name)
+    }
+
+    get isArchive() {
+        // Maybe mimetype is better
+        return [
+            "zip",
+            "tgz",
+            "tar.gz",
+            "txz",
+            "tar.xz",
+            "tbz2",
+            "tar.bz2",
+        ].some((ext) => this.name.endsWith(`.${ext}`))
+    }
+
+    /**
+     * Return the contents of a file. To read binary file (non-editable) use {@link download} instead
+     */
+    contents = async () => this.client.files.contents(this.path)
+
+    downloadGetUrl = async () => this.client.files.downloadGetUrl(this.path)
+
+    download = async () => this.client.files.download(this.path)
+
+    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)
+
+    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,
+        )
+
+    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 }])
+}

package/src/humane/ServerSchedule.ts

@@ -0,0 +1,160 @@
+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
+        minute: string
+    }
+    get cron() {
+        return { ...this.$cron }
+    }
+    readonly id: number
+    private $isActive: boolean
+    get isActive() {
+        return this.$isActive
+    }
+    private $isProcessing: boolean
+    get isProcessing() {
+        return this.$isProcessing
+    }
+    readonly lastRunAt: Nullable<Date>
+    private $name: string
+    get name() {
+        return this.$name
+    }
+    readonly nextRunAt: Date
+    private $onlyWhenOnline: boolean
+    get onlyWhenOnline() {
+        return this.$onlyWhenOnline
+    }
+    readonly tasks: ServerScheduleTask[]
+    private $updatedAt: Date
+    get updatedAt() {
+        return this.$updatedAt
+    }
+
+    constructor(client: ServerClient, schedule: Schedule) {
+        this.client = client
+        this.createdAt = new Date(schedule.created_at)
+        this.$cron = schedule.cron
+        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.$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),
+        )
+        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
+    }) => {
+        const data = await this.client.schedules.control(this.id).update(opts)
+        this.$name = data.name
+        this.$isActive = data.is_active
+        this.$isProcessing = data.is_processing
+        this.$onlyWhenOnline = data.only_when_online
+        this.$cron = data.cron
+        this.$updatedAt = new Date(data.updated_at)
+    }
+
+    delete = async () => this.client.schedules.control(this.id).delete()
+
+    execute = async () => this.client.schedules.control(this.id).execute()
+}
+
+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
+    }
+
+    constructor(client: ServerClient, scheduleId: number, task: ScheduleTask) {
+        this.client = client
+        this.scheduleId = scheduleId
+        this.$action = task.action
+        this.$continueOnFailure = task.continue_on_failure
+        this.createdAt = new Date(task.created_at)
+        this.id = task.id
+        this.$isQueued = task.is_queued
+        this.$payload = task.payload
+        this.$sequenceId = task.sequence_id
+        this.$timeOffset = task.time_offset
+        this.$updatedAt = task.updated_at ? new Date(task.updated_at) : null
+    }
+
+    delete = async () =>
+        this.client.schedules.control(this.scheduleId).tasks.delete(this.id)
+
+    update = async (
+        opts: PartialBy<
+            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)
+        this.$action = data.action
+        this.$continueOnFailure = data.continue_on_failure
+        this.$isQueued = data.is_queued
+        this.$payload = data.payload
+        this.$sequenceId = data.sequence_id
+        this.$timeOffset = data.time_offset
+        this.$updatedAt = data.updated_at ? new Date(data.updated_at) : null
+    }
+}

package/src/humane/ServerUser.ts

@@ -0,0 +1,44 @@
+import type { ServerClient } from "@/api/client/server"
+import type {
+    ServerSubuser,
+    SubuserPermission,
+} from "@/api/client/types/server_subuser"
+
+export class ServerUser {
+    private readonly client: ServerClient
+
+    readonly uuid: string
+    readonly username: string
+    readonly email: string
+    readonly language: string
+    readonly image: string
+    readonly admin: boolean
+    readonly root_admin: boolean
+    readonly has2faEnabled: boolean
+    readonly createdAt: Date
+    private $permissions: SubuserPermission[] | string[]
+    get permissions() {
+        return this.$permissions
+    }
+
+    constructor(client: ServerClient, user: ServerSubuser) {
+        this.client = client
+        this.uuid = user.uuid
+        this.username = user.username
+        this.email = user.email
+        this.language = user.language
+        this.image = user.image
+        this.admin = user.admin
+        this.root_admin = user.root_admin
+        this.has2faEnabled = user["2fa_enabled"]
+        this.createdAt = new Date(user.created_at)
+        this.$permissions = user.permissions
+    }
+
+    update = async (permissions: SubuserPermission[] | string[]) => {
+        const data = await this.client.users.update(this.uuid, permissions)
+        this.$permissions = data.permissions
+    }
+
+    delete = async () => this.client.users.delete(this.uuid)
+}

package/src/index.ts

@@ -1,17 +1,21 @@
-import {Client as UserClient} from "@/api/client/client";
-import {Client as AppClient} from "@/api/application/client";
-import {Agent} from "@/api/base/request";
+import { PelicanAPIClient } from "@/api"
+import { Client as UserClient } from "@/humane/Client"
 
-export class PelicanClient extends UserClient{
-    constructor(url: string, token: string, suffix: string = "/api") {
-        const ax = new Agent(url, token, "client", suffix)
-        super(ax.requester)
-    }
+export const createPelicanClient = (
+    url: string,
+    token: string,
+    suffix: string = "/api",
+) => {
+    const client = new PelicanAPIClient(url, token, suffix)
+    return new UserClient(client)
 }
 
-export class PelicanApplication extends AppClient{
-    constructor(url: string, token: string, suffix: string = "/api") {
-        const ax = new Agent(url, token, "application", suffix)
-        super(ax.requester)
-    }
-}
+export {Client} from "@/humane/Client"
+export {Account} from "@/humane/Account"
+export {Server} from "@/humane/Server"
+export {ServerAllocation} from "@/humane/ServerAllocation"
+export {ServerBackup} from "@/humane/ServerBackup"
+export {ServerDatabase} from "@/humane/ServerDatabase"
+export {ServerFile} from "@/humane/ServerFile"
+export {ServerSchedule} from "@/humane/ServerSchedule"
+export {ServerUser} from "@/humane/ServerUser"