@pelican.ts/sdk 0.4.13 → 0.4.15

package/src/humane/Server.ts

@@ -1,206 +0,0 @@
-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, path))
-    }
-
-    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)
-
-    compressMultipleFiles = async (
-        ...opts: Parameters<ServerFiles["compress"]>
-    ) => this.client.files.compress(...opts)
-
-    renameMultipleFiles = async (...opts: Parameters<ServerFiles["rename"]>) =>
-        this.client.files.rename(...opts)
-
-    deleteMultipleFiles = async (...opts: Parameters<ServerFiles["delete"]>) =>
-        this.client.files.delete(...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

@@ -1,41 +0,0 @@
-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.ip_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

@@ -1,44 +0,0 @@
-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)
-
-    rename = async (name: string) => this.client.backups.rename(this.uuid, name)
-
-    toggleLock = async () => this.client.backups.toggleLock(this.uuid)
-
-    restore = async (truncate: boolean) =>
-        this.client.backups.restore(this.uuid, truncate)
-}

package/src/humane/ServerDatabase.ts

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

@@ -1,91 +0,0 @@
-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"
-    ) =>
-        new ServerFile(
-            this.client,
-            await 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

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

@@ -1,44 +0,0 @@
-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,21 +0,0 @@
-import {PelicanAPIClient} from "@/api"
-import {Client as UserClient} from "@/humane/Client"
-
-export const createPelicanClient = (
-    url: string,
-    token: string,
-    suffix: string = "/api"
-) => {
-    const client = new PelicanAPIClient(url, token, suffix)
-    return new UserClient(client)
-}
-
-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"

package/src/types.ts

@@ -1,3 +0,0 @@
-export * from "./api/common/types"
-export * from "./api/application/types"
-export * from "./api/client/types"

package/src/utils/sized.ts

@@ -1,13 +0,0 @@
-export const SIZES = {
-    B: 1,
-    KB: 1024,
-    MB: 1024 * 1024,
-    GB: 1024 * 1024 * 1024,
-    TB: 1024 * 1024 * 1024 * 1024
-}
-
-const sized = (bytes: number, unit: keyof typeof SIZES): number => {
-    return parseInt((bytes / SIZES[unit]).toFixed(3), 10)
-}
-
-export default sized

package/src/utils/transform.ts

@@ -1,21 +0,0 @@
-import {string} from "zod"
-
-export const ArrayQueryParams = (p: {
-    [key: string]: {[key: string]: string}
-}): {[key: string]: string} => {
-    const params = new URLSearchParams()
-
-    const o: ReturnType<typeof ArrayQueryParams> = {}
-
-    for (const [param, value] of Object.entries(p)) {
-        for (const [key, val] of Object.entries(value)) {
-            o[`${param}[${key}]`] = val
-        }
-    }
-
-    return o
-}
-
-export const SortParam = (key: string, p: "asc" | "desc"): string => {
-    return `${p === "desc" ? "-" : ""}${key}`
-}