@inflector/aura 0.1.19 → 0.2.0

package/dist/auth.d.ts

@@ -1,23 +1,13 @@
-export declare const authTokenVersion: import("nanostores").PreinitializedWritableAtom<number> & object;
-declare const getTokenKey: (workspace: string) => string;
-declare const getToken: (workspace: string) => string;
-declare const setToken: (workspace: string, token: string | null) => void;
-export { getToken, setToken, getTokenKey };
-export declare const AuraAuth: (url: string, workspace: string) => {
-    Logout: () => Promise<{
-        data: {
-            success: boolean;
-        };
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
+export declare const AuraAuth: (workspace: string) => {
+    Logout: <FetchOptions extends import("better-auth").ClientFetchOption<never, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0?: import("better-auth").Prettify<{
+        query?: Record<string, any> | undefined;
+        fetchOptions?: FetchOptions | undefined;
+    }> | undefined, data_1?: FetchOptions | undefined) => Promise<import("@better-fetch/fetch").BetterFetchResponse<{
+        success: boolean;
+    }, {
+        code?: string | undefined;
+        message?: string | undefined;
+    }, FetchOptions["throw"] extends true ? true : false>>;
     Email: {
         SignUp: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
             name: string;

package/dist/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB,kEAAW,CAAC;AAKzC,QAAA,MAAM,WAAW,GAAI,WAAW,MAAM,WAAqC,CAAC;AAG5E,QAAA,MAAM,QAAQ,GAAI,WAAW,MAAM,KAAG,MAGrC,CAAC;AAEF,QAAA,MAAM,QAAQ,GAAI,WAAW,MAAM,EAAE,OAAO,MAAM,GAAG,IAAI,SAWxD,CAAC;AAGF,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;AAU3C,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA2E3B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;yBAQxB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA7EvC,CAAC;iBAAe,CAAC;;;;;;;;;;;;;;;;qBAZI,CAAC;;;;;;;;;;;;;;;;CAoKtC,CAAC"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ,GAAI,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAmDd,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;yBAQxB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BARN,CAAC;iBAC/C,CAAC;;;;;;;;;;;;;;;;qBAfoB,CAAC;;;;;;;;;;;;;;;;CA6FzB,CAAC"}

package/dist/auth.js

@@ -1,70 +1,18 @@
 import { createAuthClient } from "better-auth/client";
 import { anonymousClient } from "better-auth/client/plugins";
-import { computed, atom } from "nanostores";
-// Atom to track session/token version for reactivity
-export const authTokenVersion = atom(-1);
-// Token storage key - unique per workspace to avoid conflicts
-const getTokenKey = (workspace) => `aura_bearer_token_${workspace}`;
-// Helper to get/set token from localStorage (with SSR safety)
-const getToken = (workspace) => {
-    if (typeof window === 'undefined')
-        return '';
-    return localStorage.getItem(getTokenKey(workspace)) || '';
-};
-const setToken = (workspace, token) => {
-    if (typeof window === 'undefined')
-        return;
-    const key = getTokenKey(workspace);
-    if (token) {
-        localStorage.setItem(key, token);
-    }
-    else {
-        localStorage.removeItem(key);
-    }
-    // Update version to trigger reactivity in hooks
-    authTokenVersion.set(authTokenVersion.get() + 1);
-};
-// Export for use in other modules
-export { getToken, setToken, getTokenKey };
-// Listen for storage events (cross-tab sync) to update token version
-if (typeof window !== 'undefined') {
-    window.addEventListener('storage', (e) => {
-        if (e.key && e.key.startsWith('aura_bearer_token_')) {
-            authTokenVersion.set(authTokenVersion.get() + 1);
-        }
-    });
-}
-export const AuraAuth = (url, workspace) => {
+import { computed } from "nanostores";
+export const AuraAuth = (workspace) => {
     const _onUserLoadedCallbacks = [];
     const _onUserNotFoundCallbacks = [];
     let _initialized = false;
     let User = null;
     const authClient = createAuthClient({
-        baseURL: url + "/api/auth/" + workspace,
+        baseURL: `${window.location.origin}/api/auth/${workspace}`,
         plugins: [anonymousClient()],
         fetchOptions: {
-            // Use Bearer token authentication instead of cookies
-            auth: {
-                type: "Bearer",
-                token: () => getToken(workspace)
-            },
-            // Store the token from response headers on every successful request
-            onSuccess: (ctx) => {
-                const authToken = ctx.response.headers.get("set-auth-token");
-                if (authToken) {
-                    setToken(workspace, authToken);
-                }
-            }
+            credentials: "include"
         },
     });
-    // Refresh session when token changes (e.g. from another tab)
-    if (typeof window !== 'undefined') {
-        const unsub = authTokenVersion.subscribe((v) => {
-            if (v > 0) {
-                authClient.getSession().catch(() => { });
-            }
-        });
-    }
     const Session = computed(authClient.useSession, (session) => {
         if (!session?.data?.user)
             return session;
@@ -74,7 +22,7 @@ export const AuraAuth = (url, workspace) => {
                 ...session.data,
                 user: {
                     ...session.data.user,
-                    image: session.data.user.image ? url + session.data.user.image : null,
+                    image: session.data.user.image ? session.data.user.image : null,
                 },
             },
         };
@@ -99,9 +47,6 @@ export const AuraAuth = (url, workspace) => {
             await triggerCallbacks(_onUserNotFoundCallbacks);
         }
         finally {
-            if (authTokenVersion.get() < 0) {
-                authTokenVersion.set(0);
-            }
             _initialized = true;
         }
     };
@@ -124,11 +69,7 @@ export const AuraAuth = (url, workspace) => {
     // Initialize auth on creation
     initialize();
     return {
-        Logout: async () => {
-            const result = await authClient.signOut();
-            setToken(workspace, null); // Clear token on logout
-            return result;
-        },
+        Logout: authClient.signOut,
         Email: {
             SignUp: authClient.signUp.email,
             Login: authClient.signIn.email,

package/dist/bin.d.ts

@@ -1,3 +1,4 @@
 #!/usr/bin/env bun
 export declare function build(silent?: boolean): void;
+export declare function dev(): Promise<void>;
 //# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AA2JA,wBAAgB,KAAK,CAAC,MAAM,UAAQ,QAqBnC"}
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AA+KA,wBAAgB,KAAK,CAAC,MAAM,UAAQ,QAyBnC;AAwaD,wBAAsB,GAAG,kBAuDxB"}

package/dist/bin.js

@@ -27,7 +27,7 @@ class Spinner {
             return;
         process.stdout.write("\x1B[?25l");
         this.timer = setInterval(() => {
-            const frame = this.frames[this.i = (this.i + 1) % this.frames.length];
+            const frame = this.frames[(this.i = (this.i + 1) % this.frames.length)];
             process.stdout.write(`\r${chalk.cyan(frame)}  ${this.text}`);
         }, 80);
     }
@@ -54,15 +54,21 @@ function printBanner() {
     console.log("");
 }
 function printBox(title, content) {
-    const lines = content.split('\n');
-    const width = Math.max(title.length, ...lines.map(l => l.length)) + 4;
+    const lines = content.split("\n");
+    const width = Math.max(title.length, ...lines.map((l) => l.length)) + 4;
     const top = BORDER_COLOR("┌" + "─".repeat(width) + "┐");
     const bottom = BORDER_COLOR("└" + "─".repeat(width) + "┘");
     console.log(top);
-    console.log(BORDER_COLOR("│") + "  " + chalk.bold.white(title.padEnd(width - 2)) + BORDER_COLOR("│"));
+    console.log(BORDER_COLOR("│") +
+        "  " +
+        chalk.bold.white(title.padEnd(width - 2)) +
+        BORDER_COLOR("│"));
     console.log(BORDER_COLOR("├" + "─".repeat(width) + "┤"));
-    lines.forEach(line => {
-        console.log(BORDER_COLOR("│") + "  " + ACCENT_COLOR(line.padEnd(width - 2)) + BORDER_COLOR("│"));
+    lines.forEach((line) => {
+        console.log(BORDER_COLOR("│") +
+            "  " +
+            ACCENT_COLOR(line.padEnd(width - 2)) +
+            BORDER_COLOR("│"));
     });
     console.log(bottom);
 }
@@ -106,7 +112,7 @@ function scanFolderWithTypes(folder) {
             if (isAuraFunctionHandlerExport(content)) {
                 result[name] = {
                     type: "AuraFunctionHandler",
-                    returnType: inferAuraFunctionReturnType(content)
+                    returnType: inferAuraFunctionReturnType(content),
                 };
             }
             else {
@@ -118,7 +124,9 @@ function scanFolderWithTypes(folder) {
 }
 function objectToTypeWithReturn(name, obj, auraType = "AuraFunctionHandler") {
     const lines = [];
-    function toFnType(returnType) { return `(...args: any[]) => Promise<${returnType}>`; }
+    function toFnType(returnType) {
+        return `(...args: any[]) => Promise<${returnType}>`;
+    }
     function recurse(o, indent = "  ") {
         const inner = [];
         for (const key in o) {
@@ -143,13 +151,16 @@ function objectToTypeWithReturn(name, obj, auraType = "AuraFunctionHandler") {
     return lines.join("\n");
 }
 export function build(silent = false) {
-    const spin = silent ? null : new Spinner("Scanning functions & generating types...");
+    const spin = silent
+        ? null
+        : new Spinner("Scanning functions & generating types...");
     if (spin)
         spin.start();
     try {
         const folder = join(process.cwd(), "Aura", "Functions");
         const structure = scanFolderWithTypes(folder);
-        const tsType = 'import type { SSEHandler } from "@inflector/aura";\n' + objectToTypeWithReturn("AuraFunctions", structure);
+        const tsType = 'import type { SSEHandler } from "@inflector/aura";\n' +
+            objectToTypeWithReturn("AuraFunctions", structure);
         const generatedDir = join(process.cwd(), "Aura", ".generated");
         if (!fs.existsSync(generatedDir)) {
             fs.mkdirSync(generatedDir, { recursive: true });
@@ -182,7 +193,7 @@ async function askUser(question) {
     process.stdout.write(chalk.yellow("? ") + chalk.bold(question) + chalk.dim(" [Y/n] "));
     for await (const line of console) {
         const answer = line.trim().toLowerCase();
-        if (answer === 'y' || answer === 'yes' || answer === '')
+        if (answer === "y" || answer === "yes" || answer === "")
             return true;
         return false;
     }
@@ -214,8 +225,8 @@ async function fetchWithAuth(url, options = {}, spinner) {
         ...options,
         headers: {
             ...options.headers,
-            "aura-deploy-key": token ?? ""
-        }
+            "aura-deploy-key": token ?? "",
+        },
     });
     if (res.status === 401 || res.status === 403 || res.status === 400) {
         if (spinner)
@@ -231,14 +242,14 @@ async function fetchWithAuth(url, options = {}, spinner) {
                 if (spinner)
                     spinner.start(); // Restart spinner
                 const newToken = await getToken();
-                // We don't log "Retrying" if we have a spinner running, 
+                // We don't log "Retrying" if we have a spinner running,
                 // just update the spinner text if you want, or let it spin.
                 res = await fetch(url, {
                     ...options,
                     headers: {
                         ...options.headers,
-                        "aura-deploy-key": newToken ?? ""
-                    }
+                        "aura-deploy-key": newToken ?? "",
+                    },
                 });
             }
             else {
@@ -254,12 +265,12 @@ async function fetchWithAuth(url, options = {}, spinner) {
 // --- Commands ---
 async function pull() {
     // 1. Check Auth first
-    if (!await checkAndLogin())
+    if (!(await checkAndLogin()))
         return;
     const spin = new Spinner("Pulling workspace configuration...");
     spin.start();
     try {
-        const Config = JSON.parse(fs.readFileSync('./Aura/config.json', 'utf-8'));
+        const Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
         const res = await fetchWithAuth(Config.Url + "/api/client/pull/" + Config.WorkSpace, {}, spin);
         if (!res.ok) {
             const text = await res.text();
@@ -286,18 +297,18 @@ async function pull() {
         log.error(err.message);
     }
 }
-function init() {
+function init(c = "vite") {
     log.info("Initializing Aura project...");
     const filesContent = {
         config: {
-            path: './Aura/config.json',
+            path: "./Aura/config.json",
             content: JSON.stringify({
                 Url: "http://localhost:3000",
-                Project: "your-project-id"
-            }, null, 2) + "\n"
+                Project: "your-project-id",
+            }, null, 2) + "\n",
         },
         indexTs: {
-            path: './Aura/index.ts',
+            path: "./Aura/index.ts",
             content: `import { CreateAura } from "@inflector/aura"
 import * as AuraConfig from "./config.json"
 import * as Tables from "./schema.ts"
@@ -306,19 +317,19 @@ export const Aura = CreateAura<AuraFunctions, typeof Tables>({
     config: AuraConfig,
     Tables
 })
-`
+`,
         },
         schemaTs: {
-            path: './Aura/schema.ts',
-            content: `// Define your schema here\n`
-        }
+            path: "./Aura/schema.ts",
+            content: `// Define your schema here\n`,
+        },
     };
-    if (!fs.existsSync('./Aura')) {
-        fs.mkdirSync('./Aura', { recursive: true });
+    if (!fs.existsSync("./Aura")) {
+        fs.mkdirSync("./Aura", { recursive: true });
     }
-    Object.values(filesContent).forEach(file => {
+    Object.values(filesContent).forEach((file) => {
         if (!fs.existsSync(file.path)) {
-            fs.writeFileSync(file.path, file.content, 'utf-8');
+            fs.writeFileSync(file.path, file.content, "utf-8");
             console.log(chalk.green("   + ") + chalk.dim(file.path));
         }
         else {
@@ -330,15 +341,17 @@ export const Aura = CreateAura<AuraFunctions, typeof Tables>({
 }
 async function push() {
     // 1. Check Auth first
-    if (!await checkAndLogin())
+    if (!(await checkAndLogin()))
         return;
     const spin = new Spinner("Preparing deployment...");
     spin.start();
     try {
-        const Config = JSON.parse(fs.readFileSync('./Aura/config.json', 'utf-8'));
+        const Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
         let schemaContent = "";
         try {
-            schemaContent = fs.readFileSync('./Aura/schema.ts', 'utf-8').replace("@inflector/aura", "@inflector/optima");
+            schemaContent = fs
+                .readFileSync("./Aura/schema.ts", "utf-8")
+                .replace("@inflector/aura", "@inflector/optima");
         }
         catch {
             spin.stop("Schema missing", false);
@@ -346,7 +359,7 @@ async function push() {
         }
         // Utility to convert all paths to POSIX (forward slash) format
         function toPosixPath(p) {
-            return p.split('\\').join('/');
+            return p.split("\\").join("/");
         }
         function collectFunctions(baseDir, baseRel = "") {
             let results = {};
@@ -367,7 +380,7 @@ async function push() {
             }
             return results;
         }
-        const functionsDir = './Aura/Functions';
+        const functionsDir = "./Aura/Functions";
         const functions = collectFunctions(functionsDir);
         const fnCount = Object.keys(functions).length;
         spin.setText(`Pushing schema & ${fnCount} functions...`);
@@ -378,8 +391,8 @@ async function push() {
             },
             body: JSON.stringify({
                 "schema.ts": schemaContent,
-                functions
-            })
+                functions,
+            }),
         }, spin); // Pass spinner
         if (!res.ok) {
             const text = await res.text();
@@ -404,13 +417,13 @@ async function ping() {
     const spin = new Spinner("Pinging server...");
     spin.start();
     try {
-        const Config = JSON.parse(fs.readFileSync('./Aura/config.json', 'utf-8'));
+        const Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
         const token = await getToken();
         // Start Timer
         const start = performance.now();
         // Use standard fetch here to avoid forcing login for simple ping
         const res = await fetch(Config.Url + "/api/ping", {
-            headers: token ? { "aura-deploy-key": token } : {}
+            headers: token ? { "aura-deploy-key": token } : {},
         });
         // End Timer
         const end = performance.now();
@@ -493,7 +506,7 @@ function login() {
                 await Bun.secrets.set({
                     name: `aura-deploy-key/${Config.Url}-${Config.WorkSpace}`,
                     service: "aura@inflector",
-                    value: loginToken
+                    value: loginToken,
                 });
                 if (spin)
                     spin.stop("Login successful", true);
@@ -511,6 +524,136 @@ function login() {
         };
     });
 }
+import { createServer as createViteServer, mergeConfig, loadConfigFromFile, } from "vite";
+import path from "node:path";
+export async function dev() {
+    let Config;
+    try {
+        Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
+    }
+    catch {
+        log.error("Config file not found. Run `aura init` first.");
+        return;
+    }
+    // Load user Vite config
+    const configFile = path.resolve(process.cwd(), "vite.config.ts");
+    const configResult = await loadConfigFromFile({ command: "serve", mode: "development" }, configFile);
+    const userConfig = configResult?.config;
+    if (!userConfig) {
+        log.error("Could not load vite.config.ts");
+        return;
+    }
+    const AURA_KEY = process.env.AURA_KEY;
+    // Merge proxy into their server config
+    const finalConfig = mergeConfig(userConfig, {
+        // FIX: Tell Vite NOT to try loading the config file again,
+        // because we already loaded it manually above.
+        configFile: false,
+        server: {
+            proxy: {
+                "/api": {
+                    target: Config.Url,
+                    changeOrigin: true,
+                    secure: false,
+                    configure(proxy, _options) {
+                        proxy.on("proxyReq", (proxyReq, req, res) => {
+                            if (AURA_KEY) {
+                                proxyReq.setHeader("Authorization", `Bearer ${AURA_KEY}`);
+                            }
+                        });
+                    },
+                },
+            },
+        },
+    });
+    const vite = await createViteServer(finalConfig);
+    // Note: bindCLIShortcuts exists in Vite 5+.
+    // If you are on an older version, remove this line.
+    if (vite.bindCLIShortcuts) {
+        vite.bindCLIShortcuts({ print: true });
+    }
+    await vite.listen();
+    vite.printUrls();
+}
+function start() {
+    let Config;
+    try {
+        Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
+    }
+    catch {
+        console.log(chalk.red("✖") + "  Config file not found. Run `aura init` first.");
+        process.exit(1);
+    }
+    const upstreamUrl = Config.Url.replace(/\/$/, "");
+    const AURA_KEY = process.env.AURA_KEY;
+    Bun.serve({
+        hostname: "0.0.0.0",
+        port: 80,
+        idleTimeout: 0,
+        async fetch(req) {
+            const url = new URL(req.url);
+            // --- API PROXY ---
+            if (url.pathname.startsWith("/api")) {
+                const targetUrl = `${upstreamUrl}${url.pathname}${url.search}`;
+                const headers = new Headers(req.headers);
+                headers.delete("host");
+                headers.set("x-forwarded-host", url.host);
+                headers.set("x-forwarded-proto", url.protocol.replace(":", ""));
+                // Inject Authorization
+                if (AURA_KEY)
+                    headers.set("Authorization", `Bearer ${AURA_KEY}`);
+                try {
+                    return await fetch(targetUrl, {
+                        method: req.method,
+                        headers,
+                        body: req.method === "GET" || req.method === "HEAD"
+                            ? undefined
+                            : req.body,
+                    });
+                }
+                catch {
+                    return new Response(JSON.stringify({ error: "Upstream Proxy Failed" }), { status: 502, headers: { "Content-Type": "application/json" } });
+                }
+            }
+            // --- STATIC FILES ---
+            const filePath = `./dist${url.pathname}`;
+            const file = Bun.file(filePath);
+            if (await file.exists()) {
+                return new Response(file, {
+                    headers: { "Content-Type": getMimeType(filePath) },
+                });
+            }
+            // --- SPA FALLBACK ---
+            const indexFile = Bun.file("./dist/index.html");
+            if (await indexFile.exists()) {
+                return new Response(indexFile, {
+                    headers: { "Content-Type": "text/html" },
+                });
+            }
+            return new Response("Not Found", { status: 404 });
+        },
+    });
+    console.log(`Server running on http://localhost`);
+    console.log(chalk.dim(`   • Proxying /api → ${upstreamUrl}`));
+    console.log(chalk.dim(`   • Serving static → ./dist`));
+    function getMimeType(path) {
+        if (path.endsWith(".js"))
+            return "application/javascript";
+        if (path.endsWith(".css"))
+            return "text/css";
+        if (path.endsWith(".html"))
+            return "text/html";
+        if (path.endsWith(".json"))
+            return "application/json";
+        if (path.endsWith(".png"))
+            return "image/png";
+        if (path.endsWith(".jpg") || path.endsWith(".jpeg"))
+            return "image/jpeg";
+        if (path.endsWith(".svg"))
+            return "image/svg+xml";
+        return "application/octet-stream";
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     const Command = args[0];
@@ -535,6 +678,11 @@ async function main() {
             case "login":
                 await login();
                 break;
+            case "dev":
+                return await dev();
+            case "start":
+                start();
+                break;
             case undefined:
                 log.info("Available commands: init, pull, push, build, login, ping");
                 break;
@@ -547,6 +695,9 @@ async function main() {
         log.error("Unexpected Error: " + e.message);
     }
     log.br();
-    process.exit(0);
+    // Only exit for short-lived commands
+    if (!["start", "dev"].includes(Command ?? "")) {
+        process.exit(0);
+    }
 }
 main();

package/dist/database.d.ts

@@ -1,10 +1,8 @@
 import { Infer, InferAdd, Where } from "@inflector/optima";
 declare class RemoteTable<TDef extends Record<string, any>> {
-    private URL;
     private Name;
     private WorkSpace;
-    private getAuthHeaders;
-    constructor(url: string, name: string, workspace: string);
+    constructor(name: string, workspace: string);
     Get: () => {
         where: Where<{ [K_1 in keyof TDef as K_1 extends `__${string}` ? never : TDef[K_1] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? K_1 : never : never]: TDef[K_1] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U : never; } & { [K_2 in keyof TDef as K_2 extends `__${string}` ? never : TDef[K_2] extends import("@inflector/optima").ColumnBuilder<any, infer C extends import("@inflector/optima").ColumnConfig, any> ? C["notnull"] extends true ? never : K_2 : never]: TDef[K_2] extends import("@inflector/optima").ColumnBuilder<infer U, any, any> ? U | null : never; } extends infer T ? { [K in keyof T]: T[K]; } : never> extends boolean ? () => {
             limit: (arg: number) => {
@@ -254,6 +252,6 @@ declare class RemoteTable<TDef extends Record<string, any>> {
 }
 export declare const AuraDatabase: <T extends {
     [key: string]: Record<string, any>;
-}>(url: string, workspace: string, tables: T) => { [K in keyof T]: RemoteTable<T[K]>; };
+}>(workspace: string, tables: T) => { [K in keyof T]: RemoteTable<T[K]>; };
 export {};
 //# sourceMappingURL=database.d.ts.map

package/dist/database.d.ts.map

@@ -1 +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;AAMjE,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;IAEzB,OAAO,CAAC,cAAc;gBAKV,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAMxD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wvBAYF;IACD,MAAM;;ovBAYL;IACD,MAAM;;wvBAYL;IACD,GAAG,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,gvBAe5B;IACD,OAAO,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,EAAE,gvBAelC;IACD,MAAM,GAAI,QAAQ,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;;wvBAarC;IACD,KAAK;;4BAYJ;IACD,KAAK;;6BAYJ;IACD,SAAS,GAAI,UAAU,CAAC,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,CAAA;KAAE,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,EAAE,OAAO,OAAO,gBA+B7J;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"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAS,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAKlE,cAAM,WAAW,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAChD,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,SAAS,CAAS;gBAEd,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAI3C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wvBAsBD;IACF,MAAM;;ovBAgBJ;IACF,MAAM;;wvBAgBJ;IACF,GAAG,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,gvBAiB3B;IACF,OAAO,GAAI,QAAQ,QAAQ,CAAC,IAAI,CAAC,EAAE,gvBAiBjC;IACF,MAAM,GAAI,QAAQ,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;;wvBAiBpC;IACF,KAAK;;4BAgBH;IACF,KAAK;;6BAgBH;IACF,SAAS,GACP,UACI,CAAC,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,CAAA;KAAE,KAAK,GAAG,CAAC,GACnD,CAAC,CAAC,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,EACxD,QAAQ,GAAG,EACX,OAAO,OAAO,gBAgCd;CACH;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,EAC3E,WAAW,MAAM,EACjB,QAAQ,CAAC,QAEe,CAAC,kCAW1B,CAAC"}

package/dist/database.js

@@ -1,105 +1,82 @@
 import { createFluentBuilder } from "./fluent";
 import axios from "axios";
-import { getToken } from "./auth";
 import { SSE } from "sse.js";
 class RemoteTable {
-    URL;
     Name;
     WorkSpace;
-    getAuthHeaders() {
-        const token = getToken(this.WorkSpace);
-        return token ? { Authorization: `Bearer ${token}` } : {};
-    }
-    constructor(url, name, workspace) {
-        this.URL = url;
+    constructor(name, workspace) {
         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',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "Get",
                 settings: data,
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+            }, { withCredentials: true })).data;
         });
     };
     GetOne = () => {
         return createFluentBuilder(async (data) => {
-            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
-                operation: 'GetOne',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "GetOne",
                 settings: data,
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+            }, { withCredentials: true })).data;
         });
     };
     Delete = () => {
         return createFluentBuilder(async (data) => {
-            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
-                operation: 'Delete',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "Delete",
                 settings: { ...data, returning: true },
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+            }, { withCredentials: true })).data;
         });
     };
     Add = (record) => {
         return createFluentBuilder(async () => {
-            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
-                operation: 'Add',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "Add",
                 settings: {
-                    returning: true
+                    returning: true,
                 },
-                data: record
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+                data: record,
+            }, { withCredentials: true })).data;
         });
     };
     AddMany = (record) => {
         return createFluentBuilder(async () => {
-            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
-                operation: 'AddMany',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "AddMany",
                 settings: {
-                    returning: true
+                    returning: true,
                 },
-                data: record
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+                data: record,
+            }, { withCredentials: true })).data;
         });
     };
     Update = (record) => {
         return createFluentBuilder(async (data) => {
-            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
-                operation: 'Update',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "Update",
                 settings: { ...data, returning: true },
-                data: record
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+                data: record,
+            }, { withCredentials: true })).data;
         });
     };
     Count = () => {
         return createFluentBuilder(async (data) => {
-            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
-                operation: 'Count',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "Count",
                 settings: data,
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+            }, { withCredentials: true })).data;
         });
     };
     Exist = () => {
         return createFluentBuilder(async (data) => {
-            return (await axios.post(`${this.URL}/api/db/${this.WorkSpace}/${this.Name}`, {
-                operation: 'Exist',
+            return (await axios.post(`/api/db/${this.WorkSpace}/${this.Name}`, {
+                operation: "Exist",
                 settings: data,
-            }, {
-                headers: this.getAuthHeaders()
-            })).data;
+            }, { withCredentials: true })).data;
         });
     };
     Subscribe = (callback, where, init) => {
@@ -110,9 +87,9 @@ class RemoteTable {
             params.push("init=true");
         const query = params.length ? "?" + params.join("&") : "";
         const tableName = this.Name;
-        const url = `${this.URL}/api/db/${this.WorkSpace}/${this.Name}${query}`;
+        const url = `/api/db/${this.WorkSpace}/${this.Name}${query}`;
         const source = new SSE(url, {
-            headers: this.getAuthHeaders(),
+            withCredentials: true,
         });
         source.addEventListener(tableName, (event) => {
             try {
@@ -123,8 +100,8 @@ class RemoteTable {
                 // Ignore parse errors
             }
         });
-        source.addEventListener('error', (error) => {
-            console.error('SSE stream error:', error);
+        source.addEventListener("error", (error) => {
+            console.error("SSE stream error:", error);
         });
         source.stream();
         return () => {
@@ -132,12 +109,12 @@ class RemoteTable {
         };
     };
 }
-export const AuraDatabase = (url, workspace, tables) => {
+export const AuraDatabase = (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);
+            Tables[key] = new RemoteTable(key, workspace);
         }
     }
     return Tables;

package/dist/function.d.ts

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

package/dist/function.d.ts.map

@@ -1 +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,CAyHvG"}
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../src/function.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CAAE,SAAS,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,GAAG,CAmHvF"}

package/dist/function.js

@@ -1,10 +1,4 @@
-export function createFunctionHandler(baseUrl, workspace, functionsFolder) {
-    // Helper to get token for Bearer auth
-    const getToken = () => {
-        if (typeof window === 'undefined')
-            return '';
-        return localStorage.getItem(`aura_bearer_token_${workspace}`) || '';
-    };
+export function createFunctionHandler(workspace, functionsFolder) {
     const handler = new Proxy({}, {
         get(_, prop) {
             return createNestedProxy([prop]);
@@ -18,22 +12,20 @@ export function createFunctionHandler(baseUrl, workspace, functionsFolder) {
             },
             // 1. Remove 'async' here to prevent native Promise wrapping
             apply(_, __, args) {
-                const url = [baseUrl, "api", "fn", workspace, ...path].join("/");
+                const url = ["api", "fn", workspace, ...path].join("/");
                 const isFormData = args != null && args.length === 1 && args[0] instanceof FormData;
-                const body = isFormData ? args[0] : JSON.stringify(args ?? {});
-                const token = getToken();
+                const body = isFormData ? args[0] : JSON.stringify(args[0] ?? {});
                 const headers = {
                     "Accept": "text/event-stream,application/json",
                 };
                 if (!isFormData)
                     headers["Content-Type"] = "application/json";
-                if (token)
-                    headers["Authorization"] = `Bearer ${token}`;
                 // 2. Start the fetch properly (without await)
                 const requestPromise = fetch(url, {
                     method: "POST",
                     body,
                     headers,
+                    credentials: "include"
                 });
                 // 3. Return a custom "Thenable" object with full Promise interface
                 const thenable = {

package/dist/hooks/react.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/hooks/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAS,MAAM,IAAI,CAAA;AAK3C,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;AAkB5B,wBAAgB,QAAQ,CACtB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,CAAC,EAAE;IACR,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,guBAwDF;AAED,wBAAgB,SAAS,CACvB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,EAAE;IACP,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,0uBAqDF;AAED,eAAO,MAAM,OAAO,GAAI,UAAU,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;;;;;;;;;aAGjF,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,UAAU,GAAG,QAGvC,CAAA"}
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/hooks/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAS,MAAM,IAAI,CAAA;AAI3C,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;AAkB5B,wBAAgB,QAAQ,CACtB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,CAAC,EAAE;IACR,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,guBAkDF;AAED,wBAAgB,SAAS,CACvB,IAAI,SAAS,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAElF,KAAK,EAAE,IAAI,EACX,OAAO,EAAE;IACP,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CACnE,0uBAgDF;AAED,eAAO,MAAM,OAAO,GAAI,UAAU,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;;;;;;;;;aAGjF,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,UAAU,GAAG,QAGvC,CAAA"}

package/dist/hooks/react.js

@@ -1,4 +1,3 @@
-import { authTokenVersion } from '../auth';
 import { useStore } from '@nanostores/react';
 import { useEffect, useState, useRef } from 'react';
 function deepEqual(a, b) {
@@ -20,8 +19,6 @@ function deepEqual(a, b) {
 }
 export function useTable(table, Options) {
     const [data, setData] = useState([]);
-    // Subscribe to token version changes for reactivity
-    const sessionVersion = useStore(authTokenVersion);
     // Use ref to track where clause changes with deep comparison
     const whereRef = useRef(Options?.where);
     const whereString = JSON.stringify(Options?.where);
@@ -30,9 +27,6 @@ export function useTable(table, Options) {
     }
     useEffect(() => {
         // Wait for auth to be initialized
-        if (sessionVersion < 0)
-            return;
-        // Subscribe to table
         const unsubscribe = table.Subscribe((event) => {
             setData((prev) => {
                 if (!prev)
@@ -44,7 +38,7 @@ export function useTable(table, Options) {
                     case 'AddMany':
                         return [...prev, ...event.data];
                     case 'Delete':
-                        return prev.filter((x) => !event.data.old.some((d) => deepEqual(d, x)));
+                        return prev.filter((x) => !event.data.some((d) => deepEqual(d, x)));
                     case 'Update':
                         return prev.map((item) => {
                             const update = event.data.find((d) => deepEqual(d.old, item));
@@ -58,13 +52,11 @@ export function useTable(table, Options) {
         return () => {
             unsubscribe();
         };
-    }, [table, whereString, sessionVersion]); // <--- include sessionVersion here
+    }, [table, whereString]); // <--- include sessionVersion here
     return data;
 }
 export function useRecord(table, Options) {
     const [data, setData] = useState(undefined);
-    // Subscribe to token version changes for reactivity
-    const sessionVersion = useStore(authTokenVersion);
     // Use ref to track where clause changes with deep comparison
     const whereRef = useRef(Options.where);
     const whereString = JSON.stringify(Options.where);
@@ -72,9 +64,6 @@ export function useRecord(table, Options) {
         whereRef.current = Options.where;
     }
     useEffect(() => {
-        // Wait for auth to be initialized
-        if (sessionVersion < 0)
-            return;
         const unsubscribe = table.Subscribe((event) => {
             setData((prev) => {
                 if (!prev && event.action !== 'Get' && event.action !== 'Add')
@@ -100,7 +89,7 @@ export function useRecord(table, Options) {
             });
         }, Options.where, true);
         return () => unsubscribe();
-    }, [table, whereString, sessionVersion]); // <--- include sessionVersion
+    }, [table, whereString]); // <--- include sessionVersion
     return data;
 }
 export const useUser = (provider) => {

package/dist/index.js

@@ -13,11 +13,11 @@ export const CreateAura = (Config) => {
     if (!Config.config?.WorkSpace || typeof Config.config.WorkSpace !== 'string') {
         throw new Error("CreateAura: Config.WorkSpace is required and must be a string");
     }
-    const auth = AuraAuth(Config.config.Url, Config.config.WorkSpace);
+    const auth = AuraAuth(Config.config.WorkSpace);
     return {
-        Database: AuraDatabase(Config.config.Url, Config.config.WorkSpace, Config.Tables),
-        Function: createFunctionHandler(Config.config.Url, Config.config.WorkSpace),
+        Database: AuraDatabase(Config.config.WorkSpace, Config.Tables),
+        Function: createFunctionHandler(Config.config.WorkSpace),
         Auth: auth,
-        Storage: AuraStorage(Config.config.Url, Config.config.WorkSpace, auth.Signal),
+        Storage: AuraStorage(Config.config.WorkSpace, auth.Signal),
     };
 };

package/dist/storage.d.ts

@@ -7,7 +7,7 @@ type FileAura = {
     UploadedBy?: string;
     UploadedAt: Date;
 };
-export declare const AuraStorage: (url: string, workspace: string, userAtom: any) => {
+export declare const AuraStorage: (workspace: string, userAtom: any) => {
     Upload: (file?: File, config?: {
         openSelector?: boolean;
         allowedTypes?: string[];

package/dist/storage.d.ts.map

@@ -1 +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;AAKF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM,EAAE,UAAU,GAAG;oBAQ1D,IAAI,WACH;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,KAC5D,OAAO,CAAC,QAAQ,CAAC;eA6DL,MAAM;iBAGE,MAAM;cAYT,MAAM,KAAG,OAAO,CAAC,QAAQ,CAAC;gBAY1B,OAAO,CAAC,QAAQ,EAAE,CAAC;6BAYvB,IAAI,EAAE,WACN;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;iBAmD5C,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;mBAYvB,MAAM,aAAY,OAAO,aAAoB,OAAO;;;;;CA6BhF,CAAA"}
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG;IACd,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;CAClB,CAAC;AAIF,eAAO,MAAM,WAAW,GAAI,WAAW,MAAM,EAAE,UAAU,GAAG;oBAEjD,IAAI,WACH;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,KAC1D,OAAO,CAAC,QAAQ,CAAC;eAmEP,MAAM;iBAGE,MAAM;cAkBT,MAAM,KAAG,OAAO,CAAC,QAAQ,CAAC;gBAkB1B,OAAO,CAAC,QAAQ,EAAE,CAAC;6BAkBzB,IAAI,EAAE,WACN;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;iBAqD1C,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;mBAmBtC,MAAM,aACA,OAAO,aACN,OAAO;;;;;CAmCvB,CAAC"}

package/dist/storage.js

@@ -1,11 +1,5 @@
 import axios from "axios";
-import { getToken } from "./auth";
-export const AuraStorage = (url, workspace, userAtom) => {
-    // Helper to get auth headers for Bearer token
-    const getAuthHeaders = () => {
-        const token = getToken(workspace);
-        return token ? { Authorization: `Bearer ${token}` } : {};
-    };
+export const AuraStorage = (workspace, userAtom) => {
     const UploadFn = async (file, config = {}) => {
         if (!userAtom.get().data)
             throw new Error("User not authenticated");
@@ -37,7 +31,9 @@ export const AuraStorage = (url, workspace, userAtom) => {
                         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, { headers: getAuthHeaders() })).data;
+                        const result = (await axios.post("/api/storage/" + workspace, fd, {
+                            withCredentials: true,
+                        })).data;
                         resolve(result);
                         cleanup();
                     }
@@ -47,7 +43,7 @@ export const AuraStorage = (url, workspace, userAtom) => {
                     }
                 };
                 // Handle cancel - cleanup after a delay if no file selected
-                input.addEventListener('cancel', () => {
+                input.addEventListener("cancel", () => {
                     reject(new Error("File selection cancelled"));
                     cleanup();
                 });
@@ -59,52 +55,52 @@ export const AuraStorage = (url, workspace, userAtom) => {
             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, {
-                headers: getAuthHeaders()
+            return (await axios.post("/api/storage/" + workspace, fd, {
+                withCredentials: true
             })).data;
         }
     };
     return {
         Upload: UploadFn,
         File: (id) => {
-            return `${url}/api/storage/${workspace}/${id}`;
+            return `/api/storage/${workspace}/${id}`;
         },
         Delete: async (id) => {
             if (!userAtom.get().data)
                 throw new Error("User not authenticated");
-            return (await axios.post(url + "/api/storage/" + workspace, {
+            return (await axios.post("/api/storage/" + workspace, {
                 operation: "Delete",
                 settings: {
                     FileID: id,
-                    Owner: userAtom.get().data.user.id
-                }
+                    Owner: userAtom.get().data.user.id,
+                },
             }, {
-                headers: getAuthHeaders()
+                withCredentials: true
             })).data;
         },
         Get: async (id) => {
             if (!userAtom.get().data)
                 throw new Error("User not authenticated");
-            return (await axios.post(url + "/api/storage/" + workspace, {
+            return (await axios.post("/api/storage/" + workspace, {
                 operation: "Get",
                 settings: {
                     FileID: id,
-                    Owner: userAtom.get().data.user.id
-                }
+                    Owner: userAtom.get().data.user.id,
+                },
             }, {
-                headers: getAuthHeaders()
+                withCredentials: true
             })).data;
         },
         List: async () => {
             if (!userAtom.get().data)
                 throw new Error("User not authenticated");
-            return (await axios.post(url + "/api/storage/" + workspace, {
+            return (await axios.post("/api/storage/" + workspace, {
                 operation: "List",
                 settings: {
-                    Owner: userAtom.get().data.user.id
-                }
+                    Owner: userAtom.get().data.user.id,
+                },
             }, {
-                headers: getAuthHeaders()
+                withCredentials: true
             })).data;
         },
         UploadMultiple: async (files, config = {}) => {
@@ -133,7 +129,7 @@ export const AuraStorage = (url, workspace, userAtom) => {
                                 cleanup();
                                 return;
                             }
-                            const uploadResults = await Promise.all(selectedFiles.map(f => UploadFn(f, config)));
+                            const uploadResults = await Promise.all(selectedFiles.map((f) => UploadFn(f, config)));
                             resolve(uploadResults);
                         }
                         catch (e) {
@@ -144,7 +140,7 @@ export const AuraStorage = (url, workspace, userAtom) => {
                         }
                     };
                     // Handle cancel
-                    input.addEventListener('cancel', () => {
+                    input.addEventListener("cancel", () => {
                         reject(new Error("File selection cancelled"));
                         cleanup();
                     });
@@ -153,27 +149,27 @@ export const AuraStorage = (url, workspace, userAtom) => {
             }
             else {
                 // Use given files directly
-                return await Promise.all(files.map(f => UploadFn(f, config)));
+                return await Promise.all(files.map((f) => UploadFn(f, config)));
             }
         },
         Exists: async (id) => {
             if (!userAtom.get().data)
                 throw new Error("User not authenticated");
-            return (await axios.post(url + "/api/storage/" + workspace, {
+            return (await axios.post("/api/storage/" + workspace, {
                 operation: "Exists",
                 settings: {
                     FileID: id,
-                    Owner: userAtom.get().data.user.id
-                }
+                    Owner: userAtom.get().data.user.id,
+                },
             }, {
-                headers: getAuthHeaders()
+                withCredentials: true
             })).data;
         },
         Download: async (id, download = true, asBase64) => {
             try {
-                const response = await axios.get(`${url}/api/storage/${workspace}/${id}?download=${download ? '1' : '0'}&base64=${asBase64 ? '1' : '0'}`, {
+                const response = await axios.get(`/api/storage/${workspace}/${id}?download=${download ? "1" : "0"}&base64=${asBase64 ? "1" : "0"}`, {
                     responseType: "blob",
-                    headers: getAuthHeaders()
+                    withCredentials: true
                 });
                 // Extract filename from content-disposition
                 const contentDisposition = response.headers["content-disposition"];
@@ -186,11 +182,13 @@ export const AuraStorage = (url, workspace, userAtom) => {
                 return {
                     blob: response.data,
                     fileName,
-                    mimeType: response.headers["content-type"] || "application/octet-stream"
+                    mimeType: response.headers["content-type"] || "application/octet-stream",
                 };
             }
             catch (error) {
-                if (error.response && error.response.data && error.response.data.message) {
+                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

@@ -1,6 +1,6 @@
 {
   "name": "@inflector/aura",
-  "version": "0.1.19",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -44,6 +44,7 @@
     "eventsource": "^4.1.0",
     "sse.js": "^2.7.2",
     "tsx": "^4.20.4",
+    "vite": "^7.3.1",
     "zod": "^3.25.67"
   }
 }