alsabase 1.0.0

package/dist/services/BaseService.d.ts

@@ -0,0 +1,7 @@
+import type { AlsaBase } from "../Client";
+import type { SendOptions } from "../types";
+export declare abstract class BaseService {
+    readonly client: AlsaBase;
+    constructor(client: AlsaBase);
+    protected send<T = any>(path: string, options?: SendOptions): Promise<T>;
+}

package/dist/services/BaseService.js

@@ -0,0 +1,9 @@
+export class BaseService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async send(path, options) {
+        return this.client.send(path, options);
+    }
+}

package/dist/services/CollectionService.d.ts

@@ -0,0 +1,42 @@
+import { BaseService } from "./BaseService";
+import type { CollectionModel, ListResult, ListOptions, CommonOptions } from "../types";
+export declare class CollectionService extends BaseService {
+    /**
+     * Returns a list of all collections (Superuser required)
+     */
+    getFullList(options?: CommonOptions): Promise<CollectionModel[]>;
+    /**
+     * Returns a paginated list of collections
+     */
+    getList(page?: number, perPage?: number, options?: ListOptions): Promise<ListResult<CollectionModel>>;
+    /**
+     * Returns a single collection schema by its name or ID (Superuser required)
+     */
+    getOne(idOrName: string, options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Returns the schema and column definitions of a table/collection (Superuser required)
+     * Alias for getOne()
+     */
+    getSchema(idOrName: string, options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Returns the schema of a table/collection (Superuser required)
+     * Alias for getOne()
+     */
+    getTableSchema(idOrName: string, options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Creates a new collection schema
+     */
+    create(data: Partial<CollectionModel>, options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Updates an existing collection schema
+     */
+    update(idOrName: string, data: Partial<CollectionModel>, options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Deletes a collection schema
+     */
+    delete(idOrName: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Truncates all records in a collection
+     */
+    truncate(idOrName: string, options?: CommonOptions): Promise<boolean>;
+}

package/dist/services/CollectionService.js

@@ -0,0 +1,94 @@
+import { BaseService } from "./BaseService";
+export class CollectionService extends BaseService {
+    /**
+     * Returns a list of all collections (Superuser required)
+     */
+    async getFullList(options) {
+        const res = await this.send("/api/collections", {
+            method: "GET",
+            ...options,
+        });
+        return res.items || [];
+    }
+    /**
+     * Returns a paginated list of collections
+     */
+    async getList(page = 1, perPage = 30, options) {
+        const all = await this.getFullList(options);
+        const start = (page - 1) * perPage;
+        const end = start + perPage;
+        const items = all.slice(start, end);
+        const total = all.length;
+        const totalPages = Math.ceil(total / perPage) || 1;
+        return {
+            page,
+            perPage,
+            totalItems: total,
+            totalPages,
+            items,
+        };
+    }
+    /**
+     * Returns a single collection schema by its name or ID (Superuser required)
+     */
+    async getOne(idOrName, options) {
+        return this.send(`/api/collections/${encodeURIComponent(idOrName)}/schema`, {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Returns the schema and column definitions of a table/collection (Superuser required)
+     * Alias for getOne()
+     */
+    async getSchema(idOrName, options) {
+        return this.getOne(idOrName, options);
+    }
+    /**
+     * Returns the schema of a table/collection (Superuser required)
+     * Alias for getOne()
+     */
+    async getTableSchema(idOrName, options) {
+        return this.getOne(idOrName, options);
+    }
+    /**
+     * Creates a new collection schema
+     */
+    async create(data, options) {
+        return this.send("/api/collections", {
+            method: "POST",
+            body: data,
+            ...options,
+        });
+    }
+    /**
+     * Updates an existing collection schema
+     */
+    async update(idOrName, data, options) {
+        return this.send(`/api/collections/${encodeURIComponent(idOrName)}`, {
+            method: "PATCH",
+            body: data,
+            ...options,
+        });
+    }
+    /**
+     * Deletes a collection schema
+     */
+    async delete(idOrName, options) {
+        await this.send(`/api/collections/${encodeURIComponent(idOrName)}`, {
+            method: "DELETE",
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Truncates all records in a collection
+     */
+    async truncate(idOrName, options) {
+        await this.send(`/api/collections/${encodeURIComponent(idOrName)}/truncate`, {
+            method: "DELETE",
+            ...options,
+        });
+        return true;
+    }
+}

package/dist/services/FileService.d.ts

@@ -0,0 +1,71 @@
+import { BaseService } from "./BaseService";
+import type { FileDetailResponse, TreeResponse, BatchUploadFileItem, BatchUploadResponse, CommonOptions } from "../types";
+export declare class FileService extends BaseService {
+    /**
+     * Generates a URL for accessing an uploaded record file asset
+     *
+     * @param record Record object or record ID string
+     * @param filename Filename of the uploaded asset
+     * @param queryParams Optional query parameters (e.g. thumb, download)
+     */
+    getUrl(record: {
+        id?: string;
+        collectionName?: string;
+        collectionId?: string;
+    } | string, filename: string, queryParams?: Record<string, any>): string;
+    /**
+     * Generates a URL for a public website static asset hosted in _public
+     *
+     * @param relPath Relative path inside _public (e.g. 'images/banner.png' or 'maps/mafia/lost-heaven/')
+     */
+    getPublicUrl(relPath: string): string;
+    /**
+     * Lists all files in the _public directory
+     */
+    listPublicFiles(options?: CommonOptions): Promise<{
+        items: any[];
+        total: number;
+        publicDir: string;
+    }>;
+    /**
+     * Gets a folder tree for the _public directory
+     */
+    getPublicTree(dir?: string, options?: CommonOptions): Promise<TreeResponse>;
+    /**
+     * Reads a file's content from the _public directory
+     */
+    readPublicFile(path: string, options?: CommonOptions): Promise<FileDetailResponse>;
+    /**
+     * Saves or updates a file in the _public directory (Superuser required)
+     */
+    savePublicFile(name: string, content: string, isBase64?: boolean, options?: CommonOptions): Promise<{
+        name: string;
+        saved: boolean;
+        path: string;
+    }>;
+    /**
+     * Uploads a batch of files to the _public directory (Superuser required)
+     */
+    uploadPublicBatch(files: BatchUploadFileItem[], options?: CommonOptions): Promise<BatchUploadResponse>;
+    /**
+     * Deletes a file in the _public directory (Superuser required)
+     */
+    deletePublicFile(path: string, options?: CommonOptions): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Creates a folder inside the _public directory (Superuser required)
+     */
+    createPublicFolder(path: string, options?: CommonOptions): Promise<{
+        success: boolean;
+        path: string;
+    }>;
+    /**
+     * Deletes a folder and all its contents inside the _public directory (Superuser required)
+     */
+    deletePublicFolder(path: string, options?: CommonOptions): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/services/FileService.js

@@ -0,0 +1,119 @@
+import { BaseService } from "./BaseService";
+export class FileService extends BaseService {
+    /**
+     * Generates a URL for accessing an uploaded record file asset
+     *
+     * @param record Record object or record ID string
+     * @param filename Filename of the uploaded asset
+     * @param queryParams Optional query parameters (e.g. thumb, download)
+     */
+    getUrl(record, filename, queryParams) {
+        if (!filename)
+            return "";
+        let fileUrlPath;
+        if (typeof record === "object" && record !== null) {
+            const col = record.collectionName || record.collectionId || "";
+            const id = record.id || "";
+            if (col && id) {
+                fileUrlPath = `/api/static-files/file/${encodeURIComponent(col)}/${encodeURIComponent(id)}/${encodeURIComponent(filename)}`;
+            }
+            else if (id) {
+                fileUrlPath = `/api/static-files/file/${encodeURIComponent(id)}/${encodeURIComponent(filename)}`;
+            }
+            else {
+                fileUrlPath = `/api/static-files/file/${encodeURIComponent(filename)}`;
+            }
+        }
+        else if (typeof record === "string" && record) {
+            fileUrlPath = `/api/static-files/file/${encodeURIComponent(record)}/${encodeURIComponent(filename)}`;
+        }
+        else {
+            fileUrlPath = `/api/static-files/file/${encodeURIComponent(filename)}`;
+        }
+        return this.client.buildUrl(fileUrlPath, queryParams);
+    }
+    /**
+     * Generates a URL for a public website static asset hosted in _public
+     *
+     * @param relPath Relative path inside _public (e.g. 'images/banner.png' or 'maps/mafia/lost-heaven/')
+     */
+    getPublicUrl(relPath) {
+        const clean = relPath.replace(/^[\/\\]+/, "");
+        return `${this.client.baseUrl.replace(/\/+$/, "")}/${clean}`;
+    }
+    /**
+     * Lists all files in the _public directory
+     */
+    async listPublicFiles(options) {
+        return this.send("/api/static-files", {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Gets a folder tree for the _public directory
+     */
+    async getPublicTree(dir = "", options) {
+        return this.send(`/api/static-files/tree?dir=${encodeURIComponent(dir)}`, {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Reads a file's content from the _public directory
+     */
+    async readPublicFile(path, options) {
+        return this.send(`/api/static-files/file?path=${encodeURIComponent(path)}`, {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Saves or updates a file in the _public directory (Superuser required)
+     */
+    async savePublicFile(name, content, isBase64 = false, options) {
+        return this.send("/api/static-files/file", {
+            method: "POST",
+            body: { name, content, isBase64 },
+            ...options,
+        });
+    }
+    /**
+     * Uploads a batch of files to the _public directory (Superuser required)
+     */
+    async uploadPublicBatch(files, options) {
+        return this.send("/api/static-files/upload-batch", {
+            method: "POST",
+            body: { files },
+            ...options,
+        });
+    }
+    /**
+     * Deletes a file in the _public directory (Superuser required)
+     */
+    async deletePublicFile(path, options) {
+        return this.send(`/api/static-files/file?path=${encodeURIComponent(path)}`, {
+            method: "DELETE",
+            ...options,
+        });
+    }
+    /**
+     * Creates a folder inside the _public directory (Superuser required)
+     */
+    async createPublicFolder(path, options) {
+        return this.send("/api/static-files/folder", {
+            method: "POST",
+            body: { path },
+            ...options,
+        });
+    }
+    /**
+     * Deletes a folder and all its contents inside the _public directory (Superuser required)
+     */
+    async deletePublicFolder(path, options) {
+        return this.send(`/api/static-files/folder?path=${encodeURIComponent(path)}`, {
+            method: "DELETE",
+            ...options,
+        });
+    }
+}

package/dist/services/HooksService.d.ts

@@ -0,0 +1,76 @@
+import { BaseService } from "./BaseService";
+import type { HooksOverview, FileDetailResponse, TreeResponse, BatchUploadFileItem, BatchUploadResponse, CommonOptions } from "../types";
+export declare class HooksService extends BaseService {
+    /**
+     * Returns an overview of all active hooks, routes, crons, and commands (Superuser required)
+     */
+    getOverview(options?: CommonOptions): Promise<HooksOverview>;
+    /**
+     * Lists all files in the _hooks directory (Superuser required)
+     */
+    listFiles(options?: CommonOptions): Promise<{
+        items: any[];
+        total: number;
+    }>;
+    /**
+     * Gets a folder tree for the _hooks directory (Superuser required)
+     */
+    getTree(dir?: string, options?: CommonOptions): Promise<TreeResponse>;
+    /**
+     * Reads a file's content from the _hooks directory (Superuser required)
+     */
+    readFile(path: string, options?: CommonOptions): Promise<FileDetailResponse>;
+    /**
+     * Saves or updates a file in the _hooks directory (Superuser required)
+     */
+    saveFile(name: string, content: string, isBase64?: boolean, options?: CommonOptions): Promise<{
+        name: string;
+        saved: boolean;
+        path: string;
+    }>;
+    /**
+     * Uploads a batch of files to the _hooks directory (Superuser required)
+     */
+    uploadBatch(files: BatchUploadFileItem[], options?: CommonOptions): Promise<BatchUploadResponse>;
+    /**
+     * Deletes a file in the _hooks directory (Superuser required)
+     */
+    deleteFile(path: string, options?: CommonOptions): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Creates a folder inside the _hooks directory (Superuser required)
+     */
+    createFolder(path: string, options?: CommonOptions): Promise<{
+        success: boolean;
+        path: string;
+    }>;
+    /**
+     * Deletes a folder and all its contents inside the _hooks directory (Superuser required)
+     */
+    deleteFolder(path: string, options?: CommonOptions): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Manually triggers execution of a scheduled cron job (Superuser required)
+     */
+    triggerCron(name: string, options?: CommonOptions): Promise<any>;
+    /**
+     * Cancels a running cron job (Superuser required)
+     */
+    cancelCron(executionId?: string, name?: string, options?: CommonOptions): Promise<any>;
+    /**
+     * Runs a custom hook CLI command (Superuser required)
+     */
+    runCommand(name: string, args?: any, options?: CommonOptions): Promise<any>;
+    /**
+     * Cancels a running CLI command (Superuser required)
+     */
+    cancelCommand(executionId?: string, name?: string, options?: CommonOptions): Promise<any>;
+    /**
+     * Reloads all hook files and re-registers custom routes (Superuser required)
+     */
+    reload(options?: CommonOptions): Promise<any>;
+}

package/dist/services/HooksService.js

@@ -0,0 +1,135 @@
+import { BaseService } from "./BaseService";
+export class HooksService extends BaseService {
+    /**
+     * Returns an overview of all active hooks, routes, crons, and commands (Superuser required)
+     */
+    async getOverview(options) {
+        return this.send("/api/hooks", {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Lists all files in the _hooks directory (Superuser required)
+     */
+    async listFiles(options) {
+        return this.send("/api/hooks/files", {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Gets a folder tree for the _hooks directory (Superuser required)
+     */
+    async getTree(dir = "", options) {
+        return this.send(`/api/hooks/tree?dir=${encodeURIComponent(dir)}`, {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Reads a file's content from the _hooks directory (Superuser required)
+     */
+    async readFile(path, options) {
+        return this.send(`/api/hooks/files/file?path=${encodeURIComponent(path)}`, {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Saves or updates a file in the _hooks directory (Superuser required)
+     */
+    async saveFile(name, content, isBase64 = false, options) {
+        return this.send("/api/hooks/files", {
+            method: "POST",
+            body: { name, content, isBase64 },
+            ...options,
+        });
+    }
+    /**
+     * Uploads a batch of files to the _hooks directory (Superuser required)
+     */
+    async uploadBatch(files, options) {
+        return this.send("/api/hooks/files/upload-batch", {
+            method: "POST",
+            body: { files },
+            ...options,
+        });
+    }
+    /**
+     * Deletes a file in the _hooks directory (Superuser required)
+     */
+    async deleteFile(path, options) {
+        return this.send(`/api/hooks/files/file?path=${encodeURIComponent(path)}`, {
+            method: "DELETE",
+            ...options,
+        });
+    }
+    /**
+     * Creates a folder inside the _hooks directory (Superuser required)
+     */
+    async createFolder(path, options) {
+        return this.send("/api/hooks/files/folder", {
+            method: "POST",
+            body: { path },
+            ...options,
+        });
+    }
+    /**
+     * Deletes a folder and all its contents inside the _hooks directory (Superuser required)
+     */
+    async deleteFolder(path, options) {
+        return this.send(`/api/hooks/files/folder?path=${encodeURIComponent(path)}`, {
+            method: "DELETE",
+            ...options,
+        });
+    }
+    /**
+     * Manually triggers execution of a scheduled cron job (Superuser required)
+     */
+    async triggerCron(name, options) {
+        return this.send(`/api/hooks/cron/${encodeURIComponent(name)}/trigger`, {
+            method: "POST",
+            ...options,
+        });
+    }
+    /**
+     * Cancels a running cron job (Superuser required)
+     */
+    async cancelCron(executionId, name, options) {
+        return this.send("/api/hooks/cron/cancel", {
+            method: "POST",
+            body: { executionId, name },
+            ...options,
+        });
+    }
+    /**
+     * Runs a custom hook CLI command (Superuser required)
+     */
+    async runCommand(name, args, options) {
+        return this.send(`/api/hooks/commands/${encodeURIComponent(name)}/run`, {
+            method: "POST",
+            body: { args },
+            ...options,
+        });
+    }
+    /**
+     * Cancels a running CLI command (Superuser required)
+     */
+    async cancelCommand(executionId, name, options) {
+        return this.send("/api/hooks/commands/cancel", {
+            method: "POST",
+            body: { executionId, name },
+            ...options,
+        });
+    }
+    /**
+     * Reloads all hook files and re-registers custom routes (Superuser required)
+     */
+    async reload(options) {
+        return this.send("/api/hooks/reload", {
+            method: "POST",
+            ...options,
+        });
+    }
+}

package/dist/services/LogService.d.ts

@@ -0,0 +1,32 @@
+import { BaseService } from "./BaseService";
+import type { LogModel, LogListOptions, LogStats, LogTimelineItem, ListResult, CommonOptions } from "../types";
+export declare class LogService extends BaseService {
+    /**
+     * Returns a paginated list of system access and error logs (Superuser required)
+     */
+    getList(page?: number, perPage?: number, options?: LogListOptions): Promise<ListResult<LogModel>>;
+    /**
+     * Returns timeline distribution of system requests and errors
+     */
+    getTimeline(options?: CommonOptions): Promise<{
+        timeline: LogTimelineItem[];
+    }>;
+    /**
+     * Returns summary stats for server logs
+     */
+    getStats(options?: CommonOptions): Promise<LogStats>;
+    /**
+     * Deletes a batch of logs by IDs or all matching filter criteria
+     */
+    deleteBatch(params: {
+        ids?: string[];
+        all?: boolean;
+        level?: string;
+        search?: string;
+        includeSuperusers?: boolean;
+    }, options?: CommonOptions): Promise<any>;
+    /**
+     * Clears all system logs
+     */
+    clear(options?: CommonOptions): Promise<boolean>;
+}

package/dist/services/LogService.js

@@ -0,0 +1,63 @@
+import { BaseService } from "./BaseService";
+export class LogService extends BaseService {
+    /**
+     * Returns a paginated list of system access and error logs (Superuser required)
+     */
+    async getList(page = 1, perPage = 50, options) {
+        const query = {
+            page,
+            limit: perPage,
+            ...options,
+        };
+        const res = await this.send("/api/logs", {
+            method: "GET",
+            query,
+            ...options,
+        });
+        return {
+            page: res.page,
+            perPage: res.limit,
+            totalItems: res.total,
+            totalPages: res.totalPages,
+            items: res.items,
+        };
+    }
+    /**
+     * Returns timeline distribution of system requests and errors
+     */
+    async getTimeline(options) {
+        return this.send("/api/logs/timeline", {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Returns summary stats for server logs
+     */
+    async getStats(options) {
+        return this.send("/api/logs/stats", {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Deletes a batch of logs by IDs or all matching filter criteria
+     */
+    async deleteBatch(params, options) {
+        return this.send("/api/logs/delete-batch", {
+            method: "POST",
+            body: params,
+            ...options,
+        });
+    }
+    /**
+     * Clears all system logs
+     */
+    async clear(options) {
+        await this.send("/api/logs", {
+            method: "DELETE",
+            ...options,
+        });
+        return true;
+    }
+}

package/dist/services/RealtimeService.d.ts

@@ -0,0 +1,28 @@
+import { BaseService } from "./BaseService";
+import type { RealtimeListener, UnsubscribeFunc } from "../types";
+export declare class RealtimeService extends BaseService {
+    private subscriptions;
+    private socket;
+    private isConnecting;
+    /**
+     * Checks if realtime is currently connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Subscribes a listener callback to a specific topic or collection
+     */
+    subscribe<T = any>(topic: string, listener: RealtimeListener<T>): Promise<UnsubscribeFunc>;
+    /**
+     * Unsubscribes all listeners or a specific listener from a topic
+     */
+    unsubscribe(topic?: string): Promise<void>;
+    /**
+     * Publishes a custom event to a realtime topic
+     */
+    publish(topic: string, data: any, event?: string): Promise<void>;
+    private unsubscribeFromTopic;
+    private ensureConnection;
+    private connect;
+    private dispatchMessage;
+    private disconnect;
+}