alsabase 1.0.0

package/dist/services/RealtimeService.js

@@ -0,0 +1,186 @@
+import { io } from "socket.io-client";
+import { BaseService } from "./BaseService";
+export class RealtimeService extends BaseService {
+    subscriptions = new Map();
+    socket = null;
+    isConnecting = false;
+    /**
+     * Checks if realtime is currently connected
+     */
+    get isConnected() {
+        return !!(this.socket && this.socket.connected);
+    }
+    /**
+     * Subscribes a listener callback to a specific topic or collection
+     */
+    async subscribe(topic, listener) {
+        const trimmedTopic = (topic || "*").trim();
+        if (!this.subscriptions.has(trimmedTopic)) {
+            this.subscriptions.set(trimmedTopic, new Set());
+        }
+        this.subscriptions.get(trimmedTopic).add(listener);
+        this.ensureConnection();
+        // If socket is already connected, emit subscribe immediately
+        if (this.socket && this.socket.connected) {
+            this.socket.emit("subscribe", trimmedTopic);
+        }
+        return () => {
+            this.unsubscribeFromTopic(trimmedTopic, listener);
+        };
+    }
+    /**
+     * Unsubscribes all listeners or a specific listener from a topic
+     */
+    async unsubscribe(topic) {
+        if (!topic) {
+            if (this.socket && this.socket.connected && this.subscriptions.size > 0) {
+                this.socket.emit("unsubscribe", Array.from(this.subscriptions.keys()));
+            }
+            this.subscriptions.clear();
+            this.disconnect();
+            return;
+        }
+        const trimmedTopic = topic.trim();
+        this.subscriptions.delete(trimmedTopic);
+        if (this.socket && this.socket.connected) {
+            this.socket.emit("unsubscribe", trimmedTopic);
+        }
+        if (this.subscriptions.size === 0) {
+            this.disconnect();
+        }
+    }
+    /**
+     * Publishes a custom event to a realtime topic
+     */
+    async publish(topic, data, event) {
+        if (this.socket && this.socket.connected) {
+            this.socket.emit("publish", { topic, data, event });
+            return;
+        }
+        await this.send("/api/realtime/publish", {
+            method: "POST",
+            body: {
+                topic,
+                data,
+                event,
+            },
+        });
+    }
+    unsubscribeFromTopic(topic, listener) {
+        const set = this.subscriptions.get(topic);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0) {
+                this.subscriptions.delete(topic);
+                if (this.socket && this.socket.connected) {
+                    this.socket.emit("unsubscribe", topic);
+                }
+            }
+        }
+        if (this.subscriptions.size === 0) {
+            this.disconnect();
+        }
+    }
+    ensureConnection() {
+        if (this.isConnecting || this.isConnected)
+            return;
+        this.connect();
+    }
+    connect() {
+        if (this.socket)
+            return;
+        this.isConnecting = true;
+        const socketUrl = this.client.baseUrl;
+        this.socket = io(socketUrl, {
+            path: "/api/socket.io",
+            auth: {
+                token: this.client.authStore.token,
+            },
+            transports: ["websocket", "polling"],
+            reconnection: true,
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 5000,
+        });
+        this.socket.on("connect", () => {
+            this.isConnecting = false;
+            const topics = Array.from(this.subscriptions.keys());
+            if (topics.length > 0) {
+                this.socket.emit("subscribe", topics);
+            }
+        });
+        this.socket.on("disconnect", () => {
+            this.isConnecting = false;
+        });
+        this.socket.on("connect_error", () => {
+            this.isConnecting = false;
+        });
+        // Handle incoming logs
+        this.socket.on("logs", (data) => {
+            const logData = data?.log || data;
+            this.dispatchMessage(logData, "logs");
+        });
+        this.socket.on("log", (data) => {
+            const logData = data?.log || data;
+            this.dispatchMessage(logData, "logs");
+        });
+        // Handle generic record events
+        this.socket.on("record", (data) => {
+            const collection = data?.collection;
+            this.dispatchMessage(data, collection);
+        });
+        // Catch-all listener for collection or custom topics
+        this.socket.onAny((eventName, ...args) => {
+            if ([
+                "connect",
+                "disconnect",
+                "connect_error",
+                "connected",
+                "subscriptions",
+                "pong",
+            ].includes(eventName)) {
+                return;
+            }
+            const data = args[0];
+            this.dispatchMessage(data, eventName);
+        });
+    }
+    dispatchMessage(data, explicitTopic) {
+        if (!data)
+            return;
+        const collection = explicitTopic || data.collection || data.topic;
+        const recordId = data.record?.id;
+        for (const [topic, listeners] of this.subscriptions.entries()) {
+            let isMatch = false;
+            if (topic === "*" || topic === collection) {
+                isMatch = true;
+            }
+            else if (recordId && topic === `${collection}/${recordId}`) {
+                isMatch = true;
+            }
+            else if (topic === `${collection}/*`) {
+                isMatch = true;
+            }
+            if (isMatch) {
+                for (const listener of listeners) {
+                    try {
+                        listener(data);
+                    }
+                    catch (err) {
+                        console.error("[AlsaBase Realtime] Listener error:", err);
+                    }
+                }
+            }
+        }
+    }
+    disconnect() {
+        this.isConnecting = false;
+        if (this.socket) {
+            try {
+                this.socket.disconnect();
+            }
+            catch { }
+            this.socket = null;
+        }
+    }
+}

package/dist/services/RecordService.d.ts

@@ -0,0 +1,105 @@
+import { BaseService } from "./BaseService";
+import type { AlsaBase } from "../Client";
+import type { ListResult, RecordListOptions, FullListOptions, RecordOptions, CommonOptions, AuthResponse, RealtimeListener, UnsubscribeFunc, CollectionModel } from "../types";
+export declare class RecordService<T = any> extends BaseService {
+    readonly collectionIdOrName: string;
+    constructor(client: AlsaBase, collectionIdOrName: string);
+    /**
+     * Base API endpoint path for the collection records
+     */
+    get baseCrudPath(): string;
+    /**
+     * Returns the current schema and column definitions of this table/collection (Requires Superuser authentication)
+     */
+    getSchema(options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Returns the schema of this table/collection (Requires Superuser authentication)
+     * Alias for getSchema()
+     */
+    schema(options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Returns the schema of this table/collection (Requires Superuser authentication)
+     * Alias for getSchema()
+     */
+    getTableSchema(options?: CommonOptions): Promise<CollectionModel>;
+    /**
+     * Returns a paginated list of records
+     */
+    getList(page?: number, perPage?: number, options?: RecordListOptions): Promise<ListResult<T>>;
+    /**
+     * Returns a list of all records in batches
+     */
+    getFullList(options?: FullListOptions): Promise<T[]>;
+    /**
+     * Returns the first record matching the specified filter expression
+     */
+    getFirstListItem(filter: string, options?: RecordOptions): Promise<T>;
+    /**
+     * Returns a single record by its ID
+     */
+    getOne(id: string, options?: RecordOptions): Promise<T>;
+    /**
+     * Creates a new record in the collection
+     */
+    create(body: any, options?: RecordOptions): Promise<T>;
+    /**
+     * Updates an existing record by its ID
+     */
+    update(id: string, body: any, options?: RecordOptions): Promise<T>;
+    /**
+     * Deletes a record by its ID
+     */
+    delete(id: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Truncates (deletes all records) in the collection (Requires superuser access)
+     */
+    truncate(options?: CommonOptions): Promise<boolean>;
+    /**
+     * Authenticates a user with username/email and password
+     */
+    authWithPassword(identity: string, password: string, options?: CommonOptions): Promise<AuthResponse<T>>;
+    /**
+     * Authenticates a user with a one-time password (OTP)
+     */
+    authWithOTP(otp: string, email: string, options?: CommonOptions): Promise<AuthResponse<T>>;
+    /**
+     * Sends an OTP verification email to the user
+     */
+    requestOTP(email: string, options?: CommonOptions): Promise<any>;
+    /**
+     * Refreshes the currently authenticated record token and profile
+     */
+    authRefresh(options?: CommonOptions): Promise<AuthResponse<T>>;
+    /**
+     * Sends a password reset email
+     */
+    requestPasswordReset(email: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Confirms a password reset request with a token and new password
+     */
+    confirmPasswordReset(token: string, password: string, _passwordConfirm?: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Sends an email verification request
+     */
+    requestVerification(email: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Confirms an email verification request
+     */
+    confirmVerification(token: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Sends an email change verification request
+     */
+    requestEmailChange(newEmail: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Confirms an email change request
+     */
+    confirmEmailChange(token: string, password?: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Subscribes to realtime events for this collection or a specific record ID
+     */
+    subscribe(topicOrListener: string | RealtimeListener<T>, listener?: RealtimeListener<T>): Promise<UnsubscribeFunc>;
+    /**
+     * Unsubscribes from realtime events for this collection or a specific record ID
+     */
+    unsubscribe(topic?: string): Promise<void>;
+}

package/dist/services/RecordService.js

@@ -0,0 +1,287 @@
+import { BaseService } from "./BaseService";
+export class RecordService extends BaseService {
+    collectionIdOrName;
+    constructor(client, collectionIdOrName) {
+        super(client);
+        this.collectionIdOrName = collectionIdOrName;
+    }
+    /**
+     * Base API endpoint path for the collection records
+     */
+    get baseCrudPath() {
+        return `/api/collections/${encodeURIComponent(this.collectionIdOrName)}/records`;
+    }
+    /**
+     * Returns the current schema and column definitions of this table/collection (Requires Superuser authentication)
+     */
+    async getSchema(options) {
+        return this.client.collections.getOne(this.collectionIdOrName, options);
+    }
+    /**
+     * Returns the schema of this table/collection (Requires Superuser authentication)
+     * Alias for getSchema()
+     */
+    async schema(options) {
+        return this.getSchema(options);
+    }
+    /**
+     * Returns the schema of this table/collection (Requires Superuser authentication)
+     * Alias for getSchema()
+     */
+    async getTableSchema(options) {
+        return this.getSchema(options);
+    }
+    /**
+     * Returns a paginated list of records
+     */
+    async getList(page = 1, perPage = 30, options) {
+        const query = {
+            page,
+            limit: perPage,
+            ...options,
+        };
+        return this.send(this.baseCrudPath, {
+            method: "GET",
+            query,
+            ...options,
+        });
+    }
+    /**
+     * Returns a list of all records in batches
+     */
+    async getFullList(options) {
+        const batchSize = options?.batch || 200;
+        let page = 1;
+        let result = [];
+        let hasMore = true;
+        while (hasMore) {
+            const list = await this.getList(page, batchSize, {
+                ...options,
+                skipTotal: true,
+            });
+            result = result.concat(list.items);
+            if (list.items.length < batchSize || (list.totalPages && page >= list.totalPages)) {
+                hasMore = false;
+            }
+            else {
+                page++;
+            }
+        }
+        return result;
+    }
+    /**
+     * Returns the first record matching the specified filter expression
+     */
+    async getFirstListItem(filter, options) {
+        const list = await this.getList(1, 1, {
+            ...options,
+            filter,
+        });
+        if (!list.items || list.items.length === 0) {
+            throw new Error(`Record not found for filter: ${filter}`);
+        }
+        return list.items[0];
+    }
+    /**
+     * Returns a single record by its ID
+     */
+    async getOne(id, options) {
+        return this.send(`${this.baseCrudPath}/${encodeURIComponent(id)}`, {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Creates a new record in the collection
+     */
+    async create(body, options) {
+        return this.send(this.baseCrudPath, {
+            method: "POST",
+            body,
+            ...options,
+        });
+    }
+    /**
+     * Updates an existing record by its ID
+     */
+    async update(id, body, options) {
+        return this.send(`${this.baseCrudPath}/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            body,
+            ...options,
+        });
+    }
+    /**
+     * Deletes a record by its ID
+     */
+    async delete(id, options) {
+        await this.send(`${this.baseCrudPath}/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Truncates (deletes all records) in the collection (Requires superuser access)
+     */
+    async truncate(options) {
+        await this.send(`/api/collections/${encodeURIComponent(this.collectionIdOrName)}/truncate`, {
+            method: "DELETE",
+            ...options,
+        });
+        return true;
+    }
+    // --- Auth Methods ---
+    /**
+     * Authenticates a user with username/email and password
+     */
+    async authWithPassword(identity, password, options) {
+        const res = await this.send("/api/auth/users/login", {
+            method: "POST",
+            body: { identity, password },
+            ...options,
+        });
+        const authResponse = {
+            token: res.token,
+            record: (res.user || res.record),
+            meta: res.meta,
+        };
+        this.client.authStore.save(authResponse.token, authResponse.record);
+        return authResponse;
+    }
+    /**
+     * Authenticates a user with a one-time password (OTP)
+     */
+    async authWithOTP(otp, email, options) {
+        const res = await this.send("/api/auth/verify-otp", {
+            method: "POST",
+            body: { otp, email },
+            ...options,
+        });
+        const authResponse = {
+            token: res.token,
+            record: (res.user || res.record),
+            meta: res.meta,
+        };
+        this.client.authStore.save(authResponse.token, authResponse.record);
+        return authResponse;
+    }
+    /**
+     * Sends an OTP verification email to the user
+     */
+    async requestOTP(email, options) {
+        return this.send("/api/auth/request-otp", {
+            method: "POST",
+            body: { email },
+            ...options,
+        });
+    }
+    /**
+     * Refreshes the currently authenticated record token and profile
+     */
+    async authRefresh(options) {
+        const user = await this.send("/api/auth/users/me", {
+            method: "GET",
+            ...options,
+        });
+        const token = this.client.authStore.token;
+        const authResponse = {
+            token,
+            record: user,
+        };
+        this.client.authStore.save(token, user);
+        return authResponse;
+    }
+    /**
+     * Sends a password reset email
+     */
+    async requestPasswordReset(email, options) {
+        await this.send("/api/auth/request-password-reset", {
+            method: "POST",
+            body: { email },
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Confirms a password reset request with a token and new password
+     */
+    async confirmPasswordReset(token, password, _passwordConfirm, options) {
+        await this.send("/api/auth/confirm-password-reset", {
+            method: "POST",
+            body: { token, password },
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Sends an email verification request
+     */
+    async requestVerification(email, options) {
+        await this.send("/api/auth/request-verification", {
+            method: "POST",
+            body: { email },
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Confirms an email verification request
+     */
+    async confirmVerification(token, options) {
+        await this.send("/api/auth/confirm-verification", {
+            method: "POST",
+            body: { token },
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Sends an email change verification request
+     */
+    async requestEmailChange(newEmail, options) {
+        await this.send("/api/auth/request-email-change", {
+            method: "POST",
+            body: { newEmail },
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Confirms an email change request
+     */
+    async confirmEmailChange(token, password, options) {
+        await this.send("/api/auth/confirm-email-change", {
+            method: "POST",
+            body: { token, password },
+            ...options,
+        });
+        return true;
+    }
+    // --- Realtime Subscriptions ---
+    /**
+     * Subscribes to realtime events for this collection or a specific record ID
+     */
+    async subscribe(topicOrListener, listener) {
+        let topic;
+        let cb;
+        if (typeof topicOrListener === "function") {
+            topic = this.collectionIdOrName;
+            cb = topicOrListener;
+        }
+        else {
+            topic = `${this.collectionIdOrName}/${topicOrListener}`;
+            cb = listener;
+        }
+        return this.client.realtime.subscribe(topic, cb);
+    }
+    /**
+     * Unsubscribes from realtime events for this collection or a specific record ID
+     */
+    async unsubscribe(topic) {
+        const fullTopic = topic
+            ? `${this.collectionIdOrName}/${topic}`
+            : this.collectionIdOrName;
+        return this.client.realtime.unsubscribe(fullTopic);
+    }
+}

package/dist/services/SuperuserService.d.ts

@@ -0,0 +1,35 @@
+import { BaseService } from "./BaseService";
+import type { SuperuserAuthResponse, SuperuserModel, CommonOptions } from "../types";
+export declare class SuperuserService extends BaseService {
+    /**
+     * Authenticates a superuser with email and password
+     */
+    authWithPassword(email: string, password: string, options?: CommonOptions): Promise<SuperuserAuthResponse>;
+    /**
+     * Checks if an initial superuser exists in the system
+     */
+    hasInitialSuperuser(options?: CommonOptions): Promise<{
+        hasSuperuser: boolean;
+    }>;
+    /**
+     * Sets up the first superuser account (Only available when no superusers exist)
+     */
+    setupInitialSuperuser(email: string, password: string, options?: CommonOptions): Promise<SuperuserAuthResponse>;
+    /**
+     * Returns current authenticated superuser profile
+     */
+    getMe(options?: CommonOptions): Promise<SuperuserModel>;
+    /**
+     * Refreshes superuser auth state
+     */
+    authRefresh(options?: CommonOptions): Promise<SuperuserAuthResponse>;
+    /**
+     * Requests a password reset email for superuser
+     */
+    requestPasswordReset(email: string, options?: CommonOptions): Promise<boolean>;
+    /**
+     * Confirms a password reset with token
+     */
+    confirmPasswordReset(token: string, password: string, _passwordConfirm?: string, options?: CommonOptions): Promise<boolean>;
+}
+export type AdminService = SuperuserService;

package/dist/services/SuperuserService.js

@@ -0,0 +1,80 @@
+import { BaseService } from "./BaseService";
+export class SuperuserService extends BaseService {
+    /**
+     * Authenticates a superuser with email and password
+     */
+    async authWithPassword(email, password, options) {
+        const res = await this.send("/api/auth/superusers/login", {
+            method: "POST",
+            body: { email, password },
+            ...options,
+        });
+        this.client.authStore.save(res.token, res.user);
+        return res;
+    }
+    /**
+     * Checks if an initial superuser exists in the system
+     */
+    async hasInitialSuperuser(options) {
+        return this.send("/api/auth/superusers/has-initial", {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Sets up the first superuser account (Only available when no superusers exist)
+     */
+    async setupInitialSuperuser(email, password, options) {
+        const res = await this.send("/api/auth/superusers/setup", {
+            method: "POST",
+            body: { email, password },
+            ...options,
+        });
+        this.client.authStore.save(res.token, res.user);
+        return res;
+    }
+    /**
+     * Returns current authenticated superuser profile
+     */
+    async getMe(options) {
+        return this.send("/api/auth/superusers/me", {
+            method: "GET",
+            ...options,
+        });
+    }
+    /**
+     * Refreshes superuser auth state
+     */
+    async authRefresh(options) {
+        const user = await this.getMe(options);
+        const token = this.client.authStore.token;
+        const res = {
+            token,
+            user,
+        };
+        this.client.authStore.save(token, user);
+        return res;
+    }
+    /**
+     * Requests a password reset email for superuser
+     */
+    async requestPasswordReset(email, options) {
+        await this.send("/api/auth/request-password-reset", {
+            method: "POST",
+            body: { email },
+            ...options,
+        });
+        return true;
+    }
+    /**
+     * Confirms a password reset with token
+     */
+    async confirmPasswordReset(token, password, _passwordConfirm, options) {
+        await this.send("/api/auth/confirm-password-reset", {
+            method: "POST",
+            body: { token, password },
+            ...options,
+        });
+        return true;
+    }
+}