@inflector/aura 0.1.0

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA2CnC,CAAlB;iBAAkB,CAAF;;;;;;;;;;;;;;;;qBAR6D,CAAC;;;;;;;;;;;;;;;;CAqC/E,CAAA"}

package/dist/auth.js

@@ -0,0 +1,71 @@
+import { createAuthClient } from "better-auth/client";
+import { anonymousClient } from "better-auth/client/plugins";
+import { computed } from "nanostores";
+export const AuraAuth = (url, workspace) => {
+    const authClient = createAuthClient({
+        baseURL: url + "/api/auth/" + workspace,
+        plugins: [
+            anonymousClient()
+        ],
+        fetchOptions: {
+            credentials: "include",
+        },
+    });
+    const Session = computed(authClient.useSession, (session) => {
+        if (!session?.data?.user)
+            return session;
+        return {
+            ...session,
+            data: {
+                ...session.data,
+                user: {
+                    ...session.data.user,
+                    image: session.data.user.image
+                        ? url + session.data.user.image
+                        : null,
+                },
+            },
+        };
+    });
+    authClient.getSession();
+    return {
+        Logout: authClient.signOut,
+        Email: {
+            SignUp: authClient.signUp.email,
+            Login: authClient.signIn.email,
+        },
+        Oauth: (() => {
+            const withDefaultCallback = (provider, data) => authClient.signIn.social({
+                provider,
+                callbackURL: window.location.href,
+                ...(data ?? {}),
+                // Let any explicit callbackURL from data override default
+                ...(data?.callbackURL ? { callbackURL: data.callbackURL } : {}),
+            });
+            return {
+                Google: (data) => withDefaultCallback("google", data),
+                Apple: (data) => withDefaultCallback("apple", data),
+                Discord: (data) => withDefaultCallback("discord", data),
+                Facebook: (data) => withDefaultCallback("facebook", data),
+                Github: (data) => withDefaultCallback("github", data),
+                Gitlab: (data) => withDefaultCallback("gitlab", data),
+                HuggingFace: (data) => withDefaultCallback("hf", data),
+                Linkedin: (data) => withDefaultCallback("linkedin", data),
+                Microsoft: (data) => withDefaultCallback("microsoft", data),
+                Redit: (data) => withDefaultCallback("redit", data),
+                Polar: (data) => withDefaultCallback("polar", data),
+                Spotify: (data) => withDefaultCallback("spotify", data),
+                Tiktok: (data) => withDefaultCallback("tiktok", data),
+                Twitch: (data) => withDefaultCallback("twitch", data),
+                X: (data) => withDefaultCallback("x", data),
+                VK: (data) => withDefaultCallback("vk", data),
+                Zoom: (data) => withDefaultCallback("zoom", data),
+            };
+        })(),
+        Signal: Session,
+        Anonymous: {
+            SignUp: authClient.signIn.anonymous,
+            Delete: authClient.deleteAnonymousUser,
+        }
+    };
+};

package/dist/bin.d.ts

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

package/dist/bin.d.ts.map

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

package/dist/bin.js

@@ -0,0 +1,546 @@
+#!/usr/bin/env bun
+import chalk from "chalk";
+import * as fs from "node:fs";
+import { join, dirname } from "node:path";
+import { EventSource } from "eventsource";
+// --- UI & Styling Utilities ---
+const BORDER_COLOR = chalk.hex("#5C6BC0");
+const ACCENT_COLOR = chalk.cyanBright;
+const log = {
+    info: (msg) => console.log(chalk.blue("ℹ") + "  " + msg),
+    success: (msg) => console.log(chalk.green("✔") + "  " + msg),
+    warn: (msg) => console.log(chalk.yellow("⚠") + "  " + msg),
+    error: (msg) => console.log(chalk.red("✖") + "  " + msg),
+    dim: (msg) => console.log(chalk.dim(msg)),
+    br: () => console.log(""),
+};
+class Spinner {
+    timer = null;
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    i = 0;
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    start() {
+        if (this.timer)
+            return;
+        process.stdout.write("\x1B[?25l");
+        this.timer = setInterval(() => {
+            const frame = this.frames[this.i = (this.i + 1) % this.frames.length];
+            process.stdout.write(`\r${chalk.cyan(frame)}  ${this.text}`);
+        }, 80);
+    }
+    stop(message, success = true) {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        process.stdout.write("\r\x1B[K");
+        process.stdout.write("\x1B[?25h");
+        if (message) {
+            const icon = success ? chalk.green("✔") : chalk.red("✖");
+            console.log(`${icon}  ${message}`);
+        }
+    }
+    setText(text) {
+        this.text = text;
+    }
+}
+function printBanner() {
+    console.log("");
+    console.log(chalk.bold.hex("#FFA500")("   A U R A   ") + chalk.dim(" |  Inflector CLI"));
+    console.log(chalk.dim("   ──────────────────────────"));
+    console.log("");
+}
+function printBox(title, content) {
+    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("├" + "─".repeat(width) + "┤"));
+    lines.forEach(line => {
+        console.log(BORDER_COLOR("│") + "  " + ACCENT_COLOR(line.padEnd(width - 2)) + BORDER_COLOR("│"));
+    });
+    console.log(bottom);
+}
+// --- Type Inference Utilities ---
+function isAuraFunctionHandlerExport(content) {
+    return /export\s+default\s+AuraFunction\s*\(/.test(content);
+}
+function inferAuraFunctionReturnType(content) {
+    if (/return\s+sse\s*\(/.test(content))
+        return "SSEHandler";
+    if (/return\s*["'`][^"'`]+["'`]/.test(content))
+        return "string";
+    if (/return\s*\d+(\.\d+)?\s*;/.test(content))
+        return "number";
+    if (/return\s*(true|false)\s*;/.test(content))
+        return "boolean";
+    if (/return\s*\[[^\]]*\]\s*;/.test(content))
+        return "any[]";
+    if (/return\s*{[\s\S]*?};/.test(content))
+        return "Record<string, any>";
+    return "any";
+}
+function scanFolderWithTypes(folder) {
+    const result = {};
+    if (!fs.existsSync(folder))
+        return result;
+    const entries = fs.readdirSync(folder);
+    for (const entry of entries) {
+        const fullPath = join(folder, entry);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            result[entry] = scanFolderWithTypes(fullPath);
+        }
+        else if (stat.isFile() && /\.(ts|js)$/.test(entry)) {
+            const name = entry.replace(/\.[jt]s$/, "");
+            let content = "";
+            try {
+                content = fs.readFileSync(fullPath, "utf-8");
+            }
+            catch { }
+            if (isAuraFunctionHandlerExport(content)) {
+                result[name] = {
+                    type: "AuraFunctionHandler",
+                    returnType: inferAuraFunctionReturnType(content)
+                };
+            }
+            else {
+                result[name] = { type: "unknown" };
+            }
+        }
+    }
+    return result;
+}
+function objectToTypeWithReturn(name, obj, auraType = "AuraFunctionHandler") {
+    const lines = [];
+    function toFnType(returnType) { return `(...args: any[]) => Promise<${returnType}>`; }
+    function recurse(o, indent = "  ") {
+        const inner = [];
+        for (const key in o) {
+            const val = o[key];
+            if (val && typeof val === "object" && val.type === auraType) {
+                inner.push(`${indent}${key}: ${toFnType(val.returnType)};`);
+            }
+            else if (val && typeof val === "object" && val.type === "unknown") {
+                inner.push(`${indent}${key}: any;`);
+            }
+            else if (typeof val === "object") {
+                inner.push(`${indent}${key}: {`);
+                inner.push(...recurse(val, indent + "  "));
+                inner.push(`${indent}}`);
+            }
+        }
+        return inner;
+    }
+    lines.push(`export type ${name} = {`);
+    lines.push(...recurse(obj));
+    lines.push(`};`);
+    return lines.join("\n");
+}
+export function build(silent = false) {
+    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 generatedDir = join(process.cwd(), "Aura", ".generated");
+        if (!fs.existsSync(generatedDir)) {
+            fs.mkdirSync(generatedDir, { recursive: true });
+        }
+        const outFile = join(generatedDir, "index.ts");
+        fs.writeFileSync(outFile, tsType, "utf-8");
+        if (spin)
+            spin.stop("Types Generated", true);
+    }
+    catch (e) {
+        if (spin)
+            spin.stop("Build failed", false);
+        log.error(e.message);
+    }
+}
+// --- Auth & API Helpers ---
+async function getToken() {
+    try {
+        const Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
+        return await Bun.secrets.get({
+            name: `aura-deploy-key/${Config.Url}-${Config.WorkSpace}`,
+            service: "aura@inflector",
+        });
+    }
+    catch (e) {
+        return null;
+    }
+}
+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 === '')
+            return true;
+        return false;
+    }
+    return false;
+}
+/**
+ * Ensures user is logged in before proceeding with critical tasks.
+ */
+async function checkAndLogin() {
+    const token = await getToken();
+    if (!token) {
+        log.warn("No active session found.");
+        const shouldLogin = await askUser("Would you like to Login now?");
+        if (shouldLogin) {
+            return await login();
+        }
+        return false;
+    }
+    return true;
+}
+/**
+ * Wrapper for Fetch that handles 400, 401, 403 by prompting to login
+ * Accepts an optional Spinner to pause/resume during the prompt.
+ */
+async function fetchWithAuth(url, options = {}, spinner) {
+    const token = await getToken();
+    // First attempt
+    let res = await fetch(url, {
+        ...options,
+        headers: {
+            ...options.headers,
+            "aura-deploy-key": token ?? ""
+        }
+    });
+    if (res.status === 401 || res.status === 403 || res.status === 400) {
+        if (spinner)
+            spinner.stop(); // Stop spinner to allow user input
+        log.br();
+        log.error(`Authorization Error (${res.status})`);
+        console.log(chalk.dim("   Your session is invalid or missing."));
+        log.br();
+        const shouldLogin = await askUser("Would you like to log in now?");
+        if (shouldLogin) {
+            const loginSuccess = await login();
+            if (loginSuccess) {
+                if (spinner)
+                    spinner.start(); // Restart spinner
+                const newToken = await getToken();
+                // 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 ?? ""
+                    }
+                });
+            }
+            else {
+                throw new Error("Login failed. Operation cancelled.");
+            }
+        }
+        else {
+            throw new Error("Login required to proceed.");
+        }
+    }
+    return res;
+}
+// --- Commands ---
+async function pull() {
+    // 1. Check Auth first
+    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 res = await fetchWithAuth(Config.Url + "/api/client/pull/" + Config.WorkSpace, {}, spin);
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Pull failed (${res.status}): ${text}`);
+        }
+        const data = await res.json();
+        fs.writeFileSync("./Aura/schema.ts", data["schema.ts"].replace("@inflector/optima", "@inflector/aura"));
+        let fnCount = 0;
+        if (data.functions) {
+            Object.entries(data.functions).forEach(([relativePath, content]) => {
+                const functionFilePath = join("./Aura/Functions", relativePath);
+                fs.mkdirSync(dirname(functionFilePath), { recursive: true });
+                fs.writeFileSync(functionFilePath, content, "utf-8");
+                fnCount++;
+            });
+            build(true);
+        }
+        spin.stop("Pull successful", true);
+        console.log(chalk.dim(`   • Synced schema.ts`));
+        console.log(chalk.dim(`   • Synced ${fnCount} functions`));
+    }
+    catch (err) {
+        spin.stop("Pull failed", false);
+        log.error(err.message);
+    }
+}
+function init() {
+    log.info("Initializing Aura project...");
+    const filesContent = {
+        config: {
+            path: './Aura/config.json',
+            content: JSON.stringify({
+                Url: "http://localhost:3000",
+                Project: "your-project-id"
+            }, null, 2) + "\n"
+        },
+        indexTs: {
+            path: './Aura/index.ts',
+            content: `import { CreateAura } from "@inflector/aura"
+import * as AuraConfig from "./config.json"
+import * as Tables from "./schema.ts"
+import type { AuraFunctions } from "./.generated"
+export const Aura = CreateAura<AuraFunctions, typeof Tables>({
+    config: AuraConfig,
+    Tables
+})
+`
+        },
+        schemaTs: {
+            path: './Aura/schema.ts',
+            content: `// Define your schema here\n`
+        }
+    };
+    if (!fs.existsSync('./Aura')) {
+        fs.mkdirSync('./Aura', { recursive: true });
+    }
+    Object.values(filesContent).forEach(file => {
+        if (!fs.existsSync(file.path)) {
+            fs.writeFileSync(file.path, file.content, 'utf-8');
+            console.log(chalk.green("   + ") + chalk.dim(file.path));
+        }
+        else {
+            console.log(chalk.yellow("   ~ ") + chalk.dim(`${file.path} (exists)`));
+        }
+    });
+    log.br();
+    log.success("Initialization successful");
+}
+async function push() {
+    // 1. Check Auth first
+    if (!await checkAndLogin())
+        return;
+    const spin = new Spinner("Preparing deployment...");
+    spin.start();
+    try {
+        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");
+        }
+        catch {
+            spin.stop("Schema missing", false);
+            return;
+        }
+        function collectFunctions(baseDir, baseRel = "") {
+            let results = {};
+            if (!fs.existsSync(baseDir) || !fs.statSync(baseDir).isDirectory()) {
+                return results;
+            }
+            for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
+                const entryPath = join(baseDir, entry.name);
+                const relPath = baseRel ? join(baseRel, entry.name) : entry.name;
+                if (entry.isDirectory()) {
+                    Object.assign(results, collectFunctions(entryPath, relPath));
+                }
+                else if (entry.isFile()) {
+                    results[relPath] = fs.readFileSync(entryPath, "utf-8");
+                }
+            }
+            return results;
+        }
+        const functionsDir = './Aura/Functions';
+        const functions = collectFunctions(functionsDir);
+        const fnCount = Object.keys(functions).length;
+        spin.setText(`Pushing schema & ${fnCount} functions...`);
+        const res = await fetchWithAuth(Config.Url + "/api/client/push/" + Config.WorkSpace, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                "schema.ts": schemaContent,
+                functions
+            })
+        }, spin); // Pass spinner
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Push failed (${res.status}): ${text}`);
+        }
+        const data = await res.json();
+        if (data && data.success) {
+            spin.stop("Deployed successfully!", true);
+            build(true);
+        }
+        else {
+            spin.stop("Push response invalid", false);
+            console.log(data);
+        }
+    }
+    catch (err) {
+        spin.stop(); // Ensure spinner is stopped before logging error
+        log.error(err.message);
+    }
+}
+async function ping() {
+    const spin = new Spinner("Pinging server...");
+    spin.start();
+    try {
+        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 } : {}
+        });
+        // End Timer
+        const end = performance.now();
+        if (!res.ok) {
+            throw new Error(`Ping failed with status ${res.status}`);
+        }
+        await res.text();
+        const duration = Math.round(end - start);
+        let speedColor = chalk.green;
+        if (duration > 200)
+            speedColor = chalk.yellow;
+        if (duration > 500)
+            speedColor = chalk.red;
+        spin.stop(`Pong! ${chalk.dim("Latency:")} ${speedColor(duration + "ms")}`, true);
+    }
+    catch (err) {
+        spin.stop("Ping failed", false);
+        log.error(err.message);
+    }
+}
+/**
+ * Returns a Promise that resolves to true if login success, false otherwise
+ */
+function login() {
+    return new Promise((resolve) => {
+        let Config;
+        try {
+            Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
+        }
+        catch {
+            log.error("Config file not found. Run `aura init` first.");
+            resolve(false);
+            return;
+        }
+        const url = `${Config.Url}/api/client/login/${Config.WorkSpace}`;
+        const sse = new EventSource(url);
+        let closed = false;
+        let spin = null;
+        const close = (success) => {
+            if (closed)
+                return;
+            closed = true;
+            sse.close();
+            resolve(success);
+        };
+        const timeout = setTimeout(() => {
+            if (spin)
+                spin.stop("Login timed out", false);
+            close(false);
+        }, 5 * 60 * 1000);
+        sse.addEventListener("open", () => {
+            spin = new Spinner("Connecting to authentication server...");
+            spin.start();
+        });
+        sse.addEventListener("token-created", (e) => {
+            if (spin)
+                spin.stop();
+            try {
+                const { loginToken } = JSON.parse(e.data);
+                const loginUrl = `${Config.Url}/api/client/login-complete/${loginToken}`;
+                log.br();
+                printBox("Authentication Required", loginUrl);
+                log.br();
+                spin = new Spinner("Waiting for browser approval...");
+                spin.start();
+            }
+            catch {
+                log.error("Failed to parse token-created payload");
+            }
+        });
+        sse.addEventListener("token-revoked", async (e) => {
+            try {
+                const { loginToken } = JSON.parse(e.data);
+                if (!loginToken) {
+                    if (spin)
+                        spin.stop("Received event without token", false);
+                    close(false);
+                    return;
+                }
+                await Bun.secrets.set({
+                    name: `aura-deploy-key/${Config.Url}-${Config.WorkSpace}`,
+                    service: "aura@inflector",
+                    value: loginToken
+                });
+                if (spin)
+                    spin.stop("Login successful", true);
+                clearTimeout(timeout);
+                close(true);
+            }
+            catch {
+                if (spin)
+                    spin.stop("Failed to parse response", false);
+                close(false);
+            }
+        });
+        sse.onerror = () => {
+            // Optional: handle connection errors nicely
+        };
+    });
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const Command = args[0];
+    printBanner();
+    try {
+        switch (Command) {
+            case "ping":
+                await ping();
+                break;
+            case "init":
+                init();
+                break;
+            case "push":
+                await push();
+                break;
+            case "pull":
+                await pull();
+                break;
+            case "build":
+                build();
+                break;
+            case "login":
+                await login();
+                break;
+            case undefined:
+                log.info("Available commands: init, pull, push, build, login, ping");
+                break;
+            default:
+                log.warn(`Unknown Command: ${Command}`);
+                log.info("Try: init, pull, push, build, login");
+        }
+    }
+    catch (e) {
+        log.error("Unexpected Error: " + e.message);
+    }
+    log.br();
+    process.exit(0);
+}
+main();