alsabase 1.0.0

package/dist/stores/AsyncAuthStore.d.ts

@@ -0,0 +1,13 @@
+import { BaseAuthStore, AuthModelType } from "./BaseAuthStore";
+export interface AsyncAuthStoreOptions {
+    save?: (serialized: string) => Promise<void>;
+    clear?: () => Promise<void>;
+    initial?: string;
+}
+export declare class AsyncAuthStore extends BaseAuthStore {
+    private _saveHandler?;
+    private _clearHandler?;
+    constructor(options?: AsyncAuthStoreOptions);
+    save(token: string, model: AuthModelType): void;
+    clear(): void;
+}

package/dist/stores/AsyncAuthStore.js

@@ -0,0 +1,32 @@
+import { BaseAuthStore } from "./BaseAuthStore";
+export class AsyncAuthStore extends BaseAuthStore {
+    _saveHandler;
+    _clearHandler;
+    constructor(options = {}) {
+        super();
+        this._saveHandler = options.save;
+        this._clearHandler = options.clear;
+        if (options.initial) {
+            try {
+                const parsed = JSON.parse(options.initial);
+                if (parsed && typeof parsed === "object") {
+                    this._token = parsed.token || "";
+                    this._model = parsed.model || null;
+                }
+            }
+            catch { }
+        }
+    }
+    save(token, model) {
+        super.save(token, model);
+        if (this._saveHandler) {
+            this._saveHandler(JSON.stringify({ token: this._token, model: this._model })).catch((err) => console.error("AsyncAuthStore save failed:", err));
+        }
+    }
+    clear() {
+        super.clear();
+        if (this._clearHandler) {
+            this._clearHandler().catch((err) => console.error("AsyncAuthStore clear failed:", err));
+        }
+    }
+}

package/dist/stores/BaseAuthStore.d.ts

@@ -0,0 +1,18 @@
+import { RecordModel, SuperuserModel } from "../types";
+export type AuthModelType = RecordModel | SuperuserModel | null;
+export type OnStoreChangeFunc = (token: string, model: AuthModelType) => void;
+export declare class BaseAuthStore {
+    protected _token: string;
+    protected _model: AuthModelType;
+    private _listeners;
+    get token(): string;
+    get model(): AuthModelType;
+    get isValid(): boolean;
+    get isSuperuser(): boolean;
+    get isAdmin(): boolean;
+    save(token: string, model: AuthModelType): void;
+    clear(): void;
+    onChange(callback: OnStoreChangeFunc): () => void;
+    protected triggerChange(): void;
+    parseJwt(token: string): any;
+}

package/dist/stores/BaseAuthStore.js

@@ -0,0 +1,81 @@
+export class BaseAuthStore {
+    _token = "";
+    _model = null;
+    _listeners = new Set();
+    get token() {
+        return this._token;
+    }
+    get model() {
+        return this._model;
+    }
+    get isValid() {
+        if (!this.token)
+            return false;
+        const jwt = this.parseJwt(this.token);
+        if (!jwt || !jwt.exp)
+            return true; // without exp header, treat as valid if present
+        const now = Math.floor(Date.now() / 1000);
+        return jwt.exp > now;
+    }
+    get isSuperuser() {
+        if (!this.model)
+            return false;
+        return !!this.model.email && this.model.collectionName === undefined;
+    }
+    get isAdmin() {
+        return this.isSuperuser;
+    }
+    save(token, model) {
+        this._token = token || "";
+        this._model = model || null;
+        this.triggerChange();
+    }
+    clear() {
+        this._token = "";
+        this._model = null;
+        this.triggerChange();
+    }
+    onChange(callback) {
+        this._listeners.add(callback);
+        return () => {
+            this._listeners.delete(callback);
+        };
+    }
+    triggerChange() {
+        for (const listener of this._listeners) {
+            try {
+                listener(this._token, this._model);
+            }
+            catch (err) {
+                console.error("AuthStore change listener error:", err);
+            }
+        }
+    }
+    parseJwt(token) {
+        if (!token)
+            return null;
+        try {
+            const base64Url = token.split(".")[1];
+            if (!base64Url)
+                return null;
+            const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+            let jsonPayload;
+            if (typeof atob === "function") {
+                jsonPayload = decodeURIComponent(atob(base64)
+                    .split("")
+                    .map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2))
+                    .join(""));
+            }
+            else if (typeof globalThis.Buffer !== "undefined") {
+                jsonPayload = globalThis.Buffer.from(base64, "base64").toString("utf8");
+            }
+            else {
+                return null;
+            }
+            return JSON.parse(jsonPayload);
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/stores/LocalAuthStore.d.ts

@@ -0,0 +1,8 @@
+import { BaseAuthStore, AuthModelType } from "./BaseAuthStore";
+export declare class LocalAuthStore extends BaseAuthStore {
+    storageKey: string;
+    constructor(storageKey?: string);
+    private loadInitial;
+    save(token: string, model: AuthModelType): void;
+    clear(): void;
+}

package/dist/stores/LocalAuthStore.js

@@ -0,0 +1,43 @@
+import { BaseAuthStore } from "./BaseAuthStore";
+const DEFAULT_STORAGE_KEY = "alsabase_auth";
+export class LocalAuthStore extends BaseAuthStore {
+    storageKey;
+    constructor(storageKey = DEFAULT_STORAGE_KEY) {
+        super();
+        this.storageKey = storageKey;
+        this.loadInitial();
+    }
+    loadInitial() {
+        if (typeof window === "undefined" || !window.localStorage)
+            return;
+        try {
+            const raw = window.localStorage.getItem(this.storageKey);
+            if (!raw)
+                return;
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object") {
+                this._token = parsed.token || "";
+                this._model = parsed.model || null;
+            }
+        }
+        catch { }
+    }
+    save(token, model) {
+        super.save(token, model);
+        if (typeof window !== "undefined" && window.localStorage) {
+            try {
+                window.localStorage.setItem(this.storageKey, JSON.stringify({ token: this._token, model: this._model }));
+            }
+            catch { }
+        }
+    }
+    clear() {
+        super.clear();
+        if (typeof window !== "undefined" && window.localStorage) {
+            try {
+                window.localStorage.removeItem(this.storageKey);
+            }
+            catch { }
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,241 @@
+export interface BaseModel {
+    id: string;
+    created?: string;
+    updated?: string;
+    [key: string]: any;
+}
+export interface RecordModel extends BaseModel {
+    id: string;
+    collectionId?: string;
+    collectionName?: string;
+    created?: string;
+    updated?: string;
+}
+export interface AuthModel extends RecordModel {
+    email?: string;
+    username?: string;
+    verified?: boolean;
+    emailVisibility?: boolean;
+}
+export interface SuperuserModel extends BaseModel {
+    id: string;
+    email: string;
+    role?: string;
+    created?: string;
+    updated?: string;
+}
+export type AdminModel = SuperuserModel;
+export interface AuthResponse<T = RecordModel> {
+    token: string;
+    record: T;
+    meta?: any;
+}
+export interface SuperuserAuthResponse {
+    token: string;
+    user: SuperuserModel;
+}
+export type AdminAuthResponse = SuperuserAuthResponse;
+export interface ListResult<T> {
+    page: number;
+    perPage: number;
+    totalItems: number;
+    totalPages: number;
+    items: T[];
+}
+export interface SendOptions extends RequestInit {
+    query?: Record<string, any>;
+    params?: Record<string, any>;
+    headers?: Record<string, string>;
+    body?: any;
+    requestKey?: string | null;
+    autoCancel?: boolean;
+}
+export interface CommonOptions {
+    fields?: string;
+    expand?: string;
+    filter?: string;
+    sort?: string;
+    requestKey?: string | null;
+    [key: string]: any;
+}
+export interface ListOptions extends CommonOptions {
+    page?: number;
+    perPage?: number;
+    skipTotal?: boolean;
+}
+export interface RecordOptions extends CommonOptions {
+}
+export interface RecordListOptions extends ListOptions {
+}
+export interface FullListOptions extends CommonOptions {
+    batch?: number;
+}
+export interface FieldDef {
+    name: string;
+    type: "text" | "number" | "bool" | "email" | "url" | "date" | "autodate" | "select" | "json" | "file" | "relation";
+    required?: boolean;
+    unique?: boolean;
+    presentable?: boolean;
+    hidden?: boolean;
+    helpText?: string;
+    defaultValue?: any;
+    min?: number;
+    max?: number;
+    noDecimal?: boolean;
+    pattern?: string;
+    autogeneratePattern?: string;
+    maxSize?: number;
+    maxSelect?: number;
+    mimeTypes?: string[];
+    thumbs?: string[];
+    protected?: boolean;
+    values?: string[];
+    relationCollection?: string;
+    onCreate?: boolean;
+    onUpdate?: boolean;
+    options?: Record<string, any>;
+}
+export interface CollectionRule {
+    list?: string | null;
+    view?: string | null;
+    create?: string | null;
+    update?: string | null;
+    delete?: string | null;
+    listRule?: string | null;
+    viewRule?: string | null;
+    createRule?: string | null;
+    updateRule?: string | null;
+    deleteRule?: string | null;
+    authWithPassword?: string;
+    authRule?: string;
+    manageRule?: string;
+}
+export interface CollectionModel {
+    id: string;
+    name: string;
+    type: "base" | "auth" | "view";
+    fields?: FieldDef[];
+    schema?: FieldDef[];
+    rules?: CollectionRule;
+    indexes?: string[];
+    options?: Record<string, any>;
+    created?: string;
+    updated?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface LogModel {
+    id: string;
+    timestamp: string;
+    level: "INFO" | "WARN" | "ERROR";
+    method?: string;
+    path?: string;
+    status?: number;
+    duration_ms?: number;
+    error_message?: string;
+    stack_trace?: string;
+    metadata_json?: string;
+}
+export interface LogListOptions {
+    page?: number;
+    perPage?: number;
+    level?: string;
+    search?: string;
+    includeSuperusers?: boolean;
+    requestKey?: string | null;
+}
+export interface LogTimelineItem {
+    time_bucket: string;
+    total: number;
+    errors: number;
+}
+export interface LogStats {
+    total: number;
+    error: number;
+    warn: number;
+    info: number;
+    avgDurationMs: number;
+}
+export interface RealtimeRecordEvent<T = any> {
+    action: "create" | "update" | "delete";
+    collection: string;
+    record: T;
+    timestamp: string;
+}
+export interface RealtimeCustomEvent<T = any> {
+    topic: string;
+    data: T;
+    event?: string;
+    timestamp: string;
+}
+export type RealtimeListener<T = any> = (event: RealtimeRecordEvent<T> | RealtimeCustomEvent<T> | any) => void;
+export type UnsubscribeFunc = () => void;
+export interface HookRouteDef {
+    method: string;
+    path: string;
+    authLevel: string;
+    sourceFile: string;
+}
+export interface HookCronDef {
+    name: string;
+    schedule: string;
+    sourceFile: string;
+    active: boolean;
+    last_run_at?: string | null;
+    last_status?: string | null;
+    last_duration_ms?: number | null;
+}
+export interface HookCommandDef {
+    name: string;
+    description?: string;
+    usage?: string;
+    sourceFile?: string;
+    type?: string;
+}
+export interface HookFileItem {
+    name: string;
+    filename?: string;
+    sizeBytes: number;
+    updatedAt: string;
+    error?: string | null;
+    isFolder?: boolean;
+}
+export interface HooksOverview {
+    hooksDir: string;
+    files: HookFileItem[];
+    routes: HookRouteDef[];
+    crons: HookCronDef[];
+    commands: HookCommandDef[];
+    totalFiles: number;
+    totalRoutes: number;
+    totalCrons: number;
+    totalCommands: number;
+}
+export interface FileDetailResponse {
+    name: string;
+    content: string;
+    sizeBytes: number;
+    updatedAt: string;
+}
+export interface TreeNodeItem {
+    name: string;
+    fullPath: string;
+    isFolder: boolean;
+    sizeBytes?: number;
+    updatedAt?: string;
+}
+export interface TreeResponse {
+    items: TreeNodeItem[];
+    dir: string;
+    total: number;
+}
+export interface BatchUploadFileItem {
+    path: string;
+    content: string;
+    isBase64?: boolean;
+}
+export interface BatchUploadResponse {
+    success: boolean;
+    count: number;
+    saved: string[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "alsabase",
+  "version": "1.0.0",
+  "description": "Official JavaScript/TypeScript SDK for AlsaBase - lightweight, realtime, batteries-included backend with SQLite",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node ./build.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx ./test/sdk.test.ts"
+  },
+  "keywords": [
+    "alsabase",
+    "sdk",
+    "client",
+    "database",
+    "sqlite",
+    "realtime",
+    "auth",
+    "typescript"
+  ],
+  "author": "AlsaBase",
+  "license": "MIT",
+  "dependencies": {
+    "socket.io-client": "^4.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  }
+}