@pelican.ts/sdk 0.3.4-next.3 → 0.4.0

package/src/humane/ServerFile.ts

@@ -0,0 +1,73 @@
+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,126 @@
+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,42 @@
+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,8 @@
-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 class PelicanApplication extends AppClient{
-    constructor(url: string, token: string, suffix: string = "/api") {
-        const ax = new Agent(url, token, "application", 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)
 }

package/src/utils/sized.ts

@@ -1,5 +1,3 @@
-
-
 export const SIZES = {
     B: 1,
     KB: 1024,
@@ -9,7 +7,7 @@ export const SIZES = {
 }
 
 const sized = (bytes: number, unit: keyof typeof SIZES): number => {
-    return parseInt((bytes / SIZES[unit]).toFixed(3))
+    return parseInt((bytes / SIZES[unit]).toFixed(3), 10)
 }