@inflector/aura 0.1.0

package/dist/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAS,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAIjE,cAAM,WAAW,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC9C,OAAO,CAAC,GAAG,CAAQ;IACnB,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,SAAS,CAAQ;gBAEb,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAMxD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wvBAUF;IACD,MAAM;;ovBAUL;IACD,MAAM;;wvBAUL;IACD,GAAG,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,gvBAa5B;IACD,OAAO,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,EAAE,gvBAalC;IACD,MAAM,GAAI,QAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;;wvBAUpC;IACD,KAAK;;4BAUJ;IACD,KAAK;;6BAUJ;IACD,SAAS,GAAI,UAAU,CAAC,CAAC,CAAC,EAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,GAAG,CAAA;KAAC,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,GAAG,CAAA;KAAC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,gBAO5G;CACJ;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,EACzE,KAAK,MAAM,EACX,WAAW,MAAM,EACjB,QAAQ,CAAC,QAEe,CAAC,kCAY5B,CAAA"}

package/dist/database.js

@@ -0,0 +1,100 @@
+import { createFluentBuilder } from "./fluent";
+import axios from "axios";
+class RemoteTable {
+    URL;
+    Name;
+    WorkSpace;
+    constructor(url, name, workspace) {
+        this.URL = url;
+        this.Name = name;
+        this.WorkSpace = workspace;
+    }
+    Get = () => {
+        return createFluentBuilder(async (data) => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'Get',
+                settings: data,
+            })).data;
+        });
+    };
+    GetOne = () => {
+        return createFluentBuilder(async (data) => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'GetOne',
+                settings: data,
+            })).data;
+        });
+    };
+    Delete = () => {
+        return createFluentBuilder(async (data) => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'Delete',
+                settings: { ...data, returning: true },
+            })).data;
+        });
+    };
+    Add = (record) => {
+        return createFluentBuilder(async () => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'Add',
+                settings: {
+                    returning: true
+                },
+                data: record
+            })).data;
+        });
+    };
+    AddMany = (record) => {
+        return createFluentBuilder(async () => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'AddMany',
+                settings: {
+                    returning: true
+                },
+                data: record
+            })).data;
+        });
+    };
+    Update = (record) => {
+        return createFluentBuilder(async (data) => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'Update',
+                settings: { ...data, returning: true },
+            })).data;
+        });
+    };
+    Count = () => {
+        return createFluentBuilder(async (data) => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'Count',
+                settings: data,
+            })).data;
+        });
+    };
+    Exist = () => {
+        return createFluentBuilder(async (data) => {
+            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: 'Exist',
+                settings: data,
+            })).data;
+        });
+    };
+    Subscribe = (callback) => {
+        const eventSource = new EventSource(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`);
+        eventSource.addEventListener(this.Name, (event) => {
+            const { op, ...data } = JSON.parse(event.data);
+            callback({ action: op, data });
+        });
+        return () => eventSource.close();
+    };
+}
+export const AuraDatabase = (url, workspace, tables) => {
+    const Tables = {};
+    for (const key in tables) {
+        if (Object.prototype.hasOwnProperty.call(tables, key)) {
+            // @ts-ignore
+            Tables[key] = new RemoteTable(url, key, workspace);
+        }
+    }
+    return Tables;
+};

package/dist/fluent.d.ts

@@ -0,0 +1,14 @@
+export type SetFlag<State, Key extends keyof State> = {
+    [P in keyof State]: P extends Key ? true : State[P];
+};
+type MapToFalse<T> = {
+    [K in keyof T]: false;
+};
+type FluentStep<Schema, State extends {
+    [K in keyof Schema]: boolean | unknown;
+}, Result> = {
+    [K in keyof Schema as State[K] extends true ? never : K]: Schema[K] extends boolean ? () => FluentStep<Schema, SetFlag<State, K>, Result> : Schema[K] extends any[] ? (...args: Schema[K]) => FluentStep<Schema, SetFlag<State, K>, Result> : (arg: Schema[K]) => FluentStep<Schema, SetFlag<State, K>, Result>;
+} & PromiseLike<Result>;
+export declare function createFluentBuilder<Schema, R = Schema>(onBuild?: (data: Schema) => R | Promise<R>): FluentStep<Schema, MapToFalse<Schema>, R>;
+export {};
+//# sourceMappingURL=fluent.d.ts.map

package/dist/fluent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluent.d.ts","sourceRoot":"","sources":["../src/fluent.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,KAAK,EAAE,GAAG,SAAS,MAAM,KAAK,IAAI;KACjD,CAAC,IAAI,MAAM,KAAK,GAAG,CAAC,SAAS,GAAG,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC;CACpD,CAAC;AACF,KAAK,UAAU,CAAC,CAAC,IAAI;KAClB,CAAC,IAAI,MAAM,CAAC,GAAG,KAAK;CACtB,CAAC;AACF,KAAK,UAAU,CACb,MAAM,EACN,KAAK,SAAS;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,OAAO,GAAG,OAAO;CAAE,EACxD,MAAM,IACJ;KACD,CAAC,IAAI,MAAM,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,GACvC,KAAK,GACL,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,SAAS,OAAO,GAC7B,MAAM,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,GACnD,MAAM,CAAC,CAAC,CAAC,SAAS,GAAG,EAAE,GACvB,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,GACrE,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC;CACtE,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAExB,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,EACpD,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACzC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAgC3C"}

package/dist/fluent.js

@@ -0,0 +1,29 @@
+export function createFluentBuilder(onBuild) {
+    const data = {};
+    const handler = {
+        get(target, prop) {
+            if (prop === "then") {
+                return (resolve, reject) => {
+                    const result = onBuild ? onBuild(target) : target;
+                    Promise.resolve(result).then(resolve, reject);
+                };
+            }
+            return (...args) => {
+                // 1. No Args -> True (Flag)
+                if (args.length === 0) {
+                    target[prop] = true;
+                }
+                // 2. One Arg -> Store value
+                else if (args.length === 1) {
+                    target[prop] = args[0];
+                }
+                // 3. Multiple Args -> Store as Array/Tuple
+                else {
+                    target[prop] = args;
+                }
+                return new Proxy(target, handler);
+            };
+        },
+    };
+    return new Proxy(data, handler);
+}

package/dist/function.d.ts

@@ -0,0 +1,2 @@
+export declare function createFunctionHandler(baseUrl: string, workspace: string, functionsFolder?: string): any;
+//# sourceMappingURL=function.d.ts.map

package/dist/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../src/function.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,GAAG,CAiGvG"}

package/dist/function.js

@@ -0,0 +1,90 @@
+export function createFunctionHandler(baseUrl, workspace, functionsFolder) {
+    const handler = new Proxy({}, {
+        get(_, prop) {
+            return createNestedProxy([prop]);
+        }
+    });
+    function createNestedProxy(path) {
+        // Target function is just a placeholder
+        return new Proxy(() => { }, {
+            get(_, prop) {
+                return createNestedProxy([...path, prop]);
+            },
+            // 1. Remove 'async' here to prevent native Promise wrapping
+            apply(_, __, args) {
+                const url = [baseUrl, "api", "fn", workspace, ...path].join("/");
+                // 2. Start the fetch properly (without await)
+                const requestPromise = fetch(url, {
+                    method: "POST",
+                    body: JSON.stringify(args ?? {}),
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Accept": "text/event-stream,application/json",
+                    },
+                });
+                // 3. Return a custom "Thenable" object immediately
+                return {
+                    then(onFulfilled, onRejected) {
+                        requestPromise.then(async (response) => {
+                            const contentType = response.headers.get("Content-Type") || "";
+                            // ─────────────────────────────────────────────
+                            // SSE PATH
+                            // ─────────────────────────────────────────────
+                            if (contentType.includes("text/event-stream")) {
+                                const reader = response.body.getReader();
+                                const decoder = new TextDecoder("utf-8");
+                                let buffer = "";
+                                try {
+                                    while (true) {
+                                        const { value, done } = await reader.read();
+                                        if (done)
+                                            break;
+                                        buffer += decoder.decode(value, { stream: true });
+                                        // Split by SSE message delimiter
+                                        const parts = buffer.split("\n\n");
+                                        buffer = parts.pop() || ""; // Keep incomplete chunk
+                                        for (const part of parts) {
+                                            // Extract data lines, remove 'data: ' prefix, join with newline
+                                            const message = part
+                                                .split("\n")
+                                                .filter(line => line.trim().startsWith("data: "))
+                                                .map(line => line.replace(/^data: /, ""))
+                                                .join("\n");
+                                            if (message) {
+                                                try {
+                                                    // Emit parsed JSON
+                                                    onFulfilled(JSON.parse(message));
+                                                }
+                                                catch {
+                                                    // Or emit raw string if parsing fails
+                                                    onFulfilled(message);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                catch (err) {
+                                    if (onRejected)
+                                        onRejected(err);
+                                }
+                            }
+                            // ─────────────────────────────────────────────
+                            // NORMAL JSON PATH
+                            // ─────────────────────────────────────────────
+                            else {
+                                const data = await response.json();
+                                onFulfilled(data.data ?? data);
+                            }
+                        }).catch((err) => {
+                            if (onRejected)
+                                onRejected(err);
+                        });
+                        // Return 'this' to allow chaining, though strictly custom behavior
+                        return this;
+                    }
+                };
+            },
+        });
+    }
+    return handler;
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { AuraAuth } from "./auth";
+import { AuraDatabase } from "./database";
+import { AuraStorage } from "./storage";
+export * from "@inflector/optima/types";
+export * from "./lib";
+type CreateAuraConfig<T extends Record<string, any>> = {
+    config: {
+        Url: string;
+        WorkSpace: string;
+        [key: string]: any;
+    };
+    Tables: T;
+};
+type AuraInstance<F, T extends Record<string, any>> = {
+    Database: ReturnType<typeof AuraDatabase<T>>;
+    Function: F;
+    Storage: ReturnType<typeof AuraStorage>;
+    Auth: ReturnType<typeof AuraAuth>;
+};
+export declare const CreateAura: <F, T extends Record<string, any>>(Config: CreateAuraConfig<T>) => AuraInstance<F, T>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,cAAc,yBAAyB,CAAC;AACxC,cAAc,OAAO,CAAC;AAEtB,KAAK,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IACnD,MAAM,EAAE;QACJ,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,EAAE,MAAM,CAAC;QAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;IACF,MAAM,EAAE,CAAC,CAAC;CACb,CAAC;AAEF,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IAClD,QAAQ,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,QAAQ,EAAE,CAAC,CAAC;IACZ,OAAO,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACxC,IAAI,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,UAAU,GACnB,CAAC,EACD,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAE7B,QAAQ,gBAAgB,CAAC,CAAC,CAAC,KAC5B,YAAY,CAAC,CAAC,EAAE,CAAC,CAQnB,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+import { AuraAuth } from "./auth";
+import { AuraDatabase } from "./database";
+import { createFunctionHandler } from "./function";
+import { AuraStorage } from "./storage";
+export * from "@inflector/optima/types";
+export * from "./lib";
+export const CreateAura = (Config) => {
+    const auth = AuraAuth(Config.config.Url, Config.config.WorkSpace);
+    return {
+        Database: AuraDatabase(Config.config.Url, Config.config.WorkSpace, Config.Tables),
+        Function: createFunctionHandler(Config.config.Url, Config.config.WorkSpace),
+        Auth: auth,
+        Storage: AuraStorage(Config.config.Url, Config.config.WorkSpace, auth.Signal),
+    };
+};

package/dist/lib.d.ts

@@ -0,0 +1,12 @@
+export type AuraFunctionHandler<Args = any, Result = any> = (ctx: {
+    args: Args;
+    ctx: any;
+    secrets: Record<string, string>;
+}) => Result | Promise<Result>;
+export interface SSEHandler {
+    __isSSE: true;
+    handler: (send: (event: string, data: any) => void, close: () => void) => Promise<void> | void;
+}
+export declare function AuraFunction<Args = any, Result = any>(handler: AuraFunctionHandler<Args, Result>): AuraFunctionHandler<Args, Result>;
+export declare function sse(handler: (send: (event: string, data: any) => void, close: () => void) => Promise<void> | void): SSEHandler;
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,mBAAmB,CAAC,IAAI,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,GAAG,CAAC;IAAA,OAAO,EAAC,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC,CAAA;CAAE,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAEtJ,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAChG;AAED,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,IAAI,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EAC3D,OAAO,EAAE,mBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC,GACzC,mBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAErC,MAAM,CAAC,OAAO,UAAU,GAAG,CACzB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAC7F,UAAU,CAAC"}

package/dist/lib.js

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

package/dist/storage.d.ts

@@ -0,0 +1,31 @@
+type FileAura = {
+    ID: string;
+    FileName: string;
+    MimeType: string;
+    Size: number;
+    Path: string;
+    UploadedBy?: string;
+    UploadedAt: Date;
+};
+export declare const AuraStorage: (url: string, workspace: string, userAtom: any) => {
+    Upload: (file?: File, config?: {
+        openSelector?: boolean;
+        allowedTypes?: string[];
+    }) => Promise<any>;
+    File: (id: string) => string;
+    Delete: (id: string) => Promise<any>;
+    Get: (id: string) => Promise<FileAura | undefined>;
+    List: () => Promise<FileAura[]>;
+    UploadMultiple: (files?: File[], config?: {
+        openSelector?: boolean;
+        allowedTypes?: string[];
+    }) => Promise<any[]>;
+    Exists: (id: string) => Promise<boolean | undefined>;
+    Download: (id: string, download?: boolean) => Promise<{
+        blob: any;
+        fileName: string;
+        mimeType: any;
+    }>;
+};
+export {};
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,IAAI,CAAC;CACpB,CAAC;AAIF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM,EAAE,UAAU,GAAG;oBAG1D,IAAI,WACH;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;eAgDhD,MAAM;iBAGE,MAAM;cAUT,MAAM;;6BAoBV,IAAI,EAAE,WACN;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;iBAuC5C,MAAM;mBAUJ,MAAM,aAAY,OAAO;;;;;CA6BrD,CAAA"}

package/dist/storage.js

@@ -0,0 +1,164 @@
+import axios from "axios";
+export const AuraStorage = (url, workspace, userAtom) => {
+    const UploadFn = async (file, config = {}) => {
+        if (!userAtom.get().data)
+            return;
+        // If no file is passed, or openSelector is true, open a file input dialog automatically
+        if (!file || config.openSelector) {
+            return new Promise(async (resolve, reject) => {
+                const input = document.createElement("input");
+                input.type = "file";
+                // Set allowedTypes if provided
+                if (config.allowedTypes && config.allowedTypes.length > 0) {
+                    input.accept = config.allowedTypes.join(",");
+                }
+                input.style.display = "none";
+                document.body.appendChild(input);
+                input.onchange = async () => {
+                    try {
+                        const selectedFile = input.files?.[0];
+                        if (!selectedFile) {
+                            reject(new Error("No file selected"));
+                            document.body.removeChild(input);
+                            return;
+                        }
+                        const fd = new FormData();
+                        fd.set("operation", "Upload");
+                        fd.set("owner", userAtom.get().data.user.id);
+                        fd.set("file", selectedFile);
+                        const result = (await axios.post(url + "/api/storage/" + workspace, fd)).data;
+                        resolve(result);
+                        document.body.removeChild(input);
+                    }
+                    catch (e) {
+                        reject(e);
+                        document.body.removeChild(input);
+                    }
+                };
+                input.click();
+            });
+        }
+        else {
+            const fd = new FormData();
+            fd.set("operation", "Upload");
+            fd.set("owner", userAtom.get().data.user.id);
+            fd.set("file", file);
+            return (await axios.post(url + "/api/storage/" + workspace, fd)).data;
+        }
+    };
+    return {
+        Upload: UploadFn,
+        File: (id) => {
+            return `${url}/api/storage/${workspace}/${id}`;
+        },
+        Delete: async (id) => {
+            if (!userAtom.get().data)
+                return;
+            return (await axios.post(url + "/api/storage/" + workspace, {
+                operation: "Delete",
+                settings: {
+                    FileID: id,
+                    Owner: userAtom.get().data.user.id
+                }
+            })).data;
+        },
+        Get: async (id) => {
+            if (!userAtom.get().data)
+                return;
+            return (await axios.post(url + "/api/storage/" + workspace, {
+                operation: "Get",
+                settings: {
+                    FileID: id,
+                    Owner: userAtom.get().data.user.id
+                }
+            })).data;
+        },
+        List: async () => {
+            if (!userAtom.get().data)
+                return [];
+            return (await axios.post(url + "/api/storage/" + workspace, {
+                operation: "List",
+                settings: {
+                    Owner: userAtom.get().data.user.id
+                }
+            })).data;
+        },
+        UploadMultiple: async (files, config = {}) => {
+            // If files not passed or openSelector is true, open selector
+            if (config.openSelector || !files || files.length === 0) {
+                return await new Promise((resolve, reject) => {
+                    const input = document.createElement("input");
+                    input.type = "file";
+                    input.multiple = true;
+                    // Set allowedTypes if provided
+                    if (config.allowedTypes && config.allowedTypes.length > 0) {
+                        input.accept = config.allowedTypes.join(",");
+                    }
+                    input.style.display = "none";
+                    document.body.appendChild(input);
+                    input.onchange = async () => {
+                        const selectedFiles = Array.from(input.files ?? []);
+                        try {
+                            if (selectedFiles.length === 0) {
+                                reject(new Error("No files selected"));
+                                document.body.removeChild(input);
+                                return;
+                            }
+                            const uploadResults = await Promise.all(selectedFiles.map(f => UploadFn(f, config)));
+                            resolve(uploadResults);
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                        finally {
+                            document.body.removeChild(input);
+                        }
+                    };
+                    input.click();
+                });
+            }
+            else {
+                // Use given files directly
+                return await Promise.all(files.map(f => UploadFn(f, config)));
+            }
+        },
+        Exists: async (id) => {
+            if (!userAtom.get().data)
+                return;
+            return (await axios.post(url + "/api/storage/" + workspace, {
+                operation: "Get",
+                settings: {
+                    FileID: id,
+                    Owner: userAtom.get().data.user.id
+                }
+            })).data;
+        },
+        Download: async (id, download = true) => {
+            try {
+                const response = await axios.get(`${url}/api/storage/${workspace}/${id}?download=${download ? '1' : '0'}`, {
+                    responseType: "blob",
+                    withCredentials: true
+                });
+                // Extract filename from content-disposition
+                const contentDisposition = response.headers["content-disposition"];
+                let fileName = id;
+                if (contentDisposition) {
+                    const match = /filename="?([^"]+)"?/i.exec(contentDisposition);
+                    if (match)
+                        fileName = decodeURIComponent(match[1]);
+                }
+                return {
+                    blob: response.data,
+                    fileName,
+                    mimeType: response.headers["content-type"] || "application/octet-stream"
+                };
+            }
+            catch (error) {
+                if (error.response && error.response.data && error.response.data.message) {
+                    throw new Error(error.response.data.message);
+                }
+                throw new Error("File not found");
+            }
+        },
+    };
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@inflector/aura",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc"
+  },
+  "bin": {
+    "aura": "./dist/bin.js"
+  },
+  "browser": false,
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^20.14.10",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.3",
+    "rollup": "^4.0.0",
+    "rollup-plugin-esbuild": "^6.1.0",
+    "rollup-plugin-dts": "^6.1.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@inflector/optima": "1.1.0",
+    "@nanostores/react": "^1.0.0",
+    "axios": "^1.13.2",
+    "better-auth": "^1.4.16",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "eventsource": "^4.1.0",
+    "tsx": "^4.20.4",
+    "zod": "^3.25.67"
+  }
+}