@aerostack/react 0.1.0

package/.tshy/build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "../src",
+    "module": "nodenext",
+    "moduleResolution": "nodenext"
+  }
+}

package/.tshy/commonjs.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./build.json",
+  "include": [
+    "../src/**/*.ts",
+    "../src/**/*.cts",
+    "../src/**/*.tsx",
+    "../src/**/*.json"
+  ],
+  "exclude": [
+    "../src/**/*.mts",
+    "../src/package.json"
+  ],
+  "compilerOptions": {
+    "outDir": "../.tshy-build/commonjs"
+  }
+}

package/.tshy/esm.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./build.json",
+  "include": [
+    "../src/**/*.ts",
+    "../src/**/*.mts",
+    "../src/**/*.tsx",
+    "../src/**/*.json"
+  ],
+  "exclude": [
+    "../src/package.json"
+  ],
+  "compilerOptions": {
+    "outDir": "../.tshy-build/esm"
+  }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "@aerostack/react",
+    "version": "0.1.0",
+    "author": "Aerostack",
+    "type": "module",
+    "tshy": {
+        "exports": {
+            ".": "./src/index.ts",
+            "./package.json": "./package.json"
+        }
+    },
+    "sideEffects": false,
+    "scripts": {
+        "build": "tshy",
+        "lint": "eslint --cache --max-warnings=0 src",
+        "prepublishOnly": "npm run build"
+    },
+    "peerDependencies": {
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.26.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "eslint": "^9.26.0",
+        "globals": "^15.14.0",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "tshy": "^2.0.0",
+        "typescript": "~5.8.3",
+        "typescript-eslint": "^8.26.0"
+    },
+    "dependencies": {
+        "@aerostack/sdk-web": "*"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/esm/index.d.ts",
+                "default": "./dist/esm/index.js"
+            },
+            "require": {
+                "types": "./dist/commonjs/index.d.ts",
+                "default": "./dist/commonjs/index.js"
+            }
+        },
+        "./package.json": "./package.json"
+    },
+    "main": "./dist/commonjs/index.js",
+    "types": "./dist/commonjs/index.d.ts",
+    "module": "./dist/esm/index.js"
+}

package/src/context.tsx

@@ -0,0 +1,48 @@
+import React, { createContext, useContext, useMemo } from 'react';
+import { SDK } from '@aerostack/sdk-web';
+
+export interface AerostackContextType {
+    sdk: SDK;
+    projectId: string;
+}
+
+const AerostackContext = createContext<AerostackContextType | null>(null);
+
+export interface AerostackProviderProps {
+    projectId: string;
+    baseUrl?: string;
+    children: React.ReactNode;
+}
+
+export const AerostackProvider: React.FC<AerostackProviderProps> = ({
+    projectId,
+    baseUrl = 'https://api.aerostack.ai/v1',
+    children,
+}) => {
+    const sdk = useMemo(() => {
+        return new SDK({
+            serverURL: baseUrl,
+            // In web context, we might not have global security at init
+            // but we set it up for public access via projectId header if needed
+        });
+    }, [baseUrl]);
+
+    const value = useMemo(() => ({
+        sdk,
+        projectId,
+    }), [sdk, projectId]);
+
+    return (
+        <AerostackContext.Provider value={value}>
+            {children}
+        </AerostackContext.Provider>
+    );
+};
+
+export const useAerostack = () => {
+    const context = useContext(AerostackContext);
+    if (!context) {
+        throw new Error('useAerostack must be used within an AerostackProvider');
+    }
+    return context;
+};

package/src/hooks/useAI.ts

@@ -0,0 +1,37 @@
+import { useState, useCallback } from 'react';
+import { useAerostack } from '../context.js';
+
+export interface ChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+
+export const useAI = () => {
+    const { sdk } = useAerostack();
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const chat = useCallback(async (messages: ChatMessage[], options?: any) => {
+        try {
+            setLoading(true);
+            setError(null);
+            const result = await sdk.ai.aiChat({
+                messages,
+                ...options,
+            });
+            return result.response;
+        } catch (err) {
+            const error = err instanceof Error ? err : new Error('AI chat failed');
+            setError(error);
+            throw error;
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    return {
+        chat,
+        loading,
+        error,
+    };
+};

package/src/hooks/useAuth.ts

@@ -0,0 +1,59 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useAerostack } from '../context.js';
+
+export interface User {
+    id: string;
+    email: string;
+    name?: string;
+    [key: string]: any;
+}
+
+export const useAuth = () => {
+    const { sdk } = useAerostack();
+    const [user, setUser] = useState<User | null>(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<Error | null>(null);
+
+    const refreshUser = useCallback(async () => {
+        try {
+            setLoading(true);
+            // Logic to fetch current user session from sdk.authentication
+            // const session = await sdk.authentication.getSession();
+            // setUser(session.user);
+        } catch (err) {
+            setError(err instanceof Error ? err : new Error('Failed to fetch user'));
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    useEffect(() => {
+        refreshUser();
+    }, [refreshUser]);
+
+    const signIn = async (credentials: any) => {
+        const result = await sdk.authentication.authSignin(credentials);
+        // setUser(result.user);
+        return result;
+    };
+
+    const signUp = async (credentials: any) => {
+        const result = await sdk.authentication.authSignup(credentials);
+        return result;
+    };
+
+    const signOut = async () => {
+        // await sdk.authentication.signOut();
+        setUser(null);
+    };
+
+    return {
+        user,
+        loading,
+        error,
+        signIn,
+        signUp,
+        signOut,
+        refreshUser,
+    };
+};

package/src/hooks/useCache.ts

@@ -0,0 +1,44 @@
+import { useState, useCallback } from 'react';
+import { useAerostack } from '../context.js';
+
+export const useCache = () => {
+    const { sdk } = useAerostack();
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const get = useCallback(async (key: string) => {
+        try {
+            setLoading(true);
+            setError(null);
+            const result = await sdk.cache.cacheGet({ key });
+            return result.value;
+        } catch (err) {
+            const error = err instanceof Error ? err : new Error('Cache get failed');
+            setError(error);
+            throw error;
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    const set = useCallback(async (key: string, value: any, ttl?: number) => {
+        try {
+            setLoading(true);
+            setError(null);
+            await sdk.cache.cacheSet({ key, value, ttl });
+        } catch (err) {
+            const error = err instanceof Error ? err : new Error('Cache set failed');
+            setError(error);
+            throw error;
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    return {
+        get,
+        set,
+        loading,
+        error,
+    };
+};

package/src/hooks/useDb.ts

@@ -0,0 +1,29 @@
+import { useState, useCallback } from 'react';
+import { useAerostack } from '../context.js';
+
+export const useDb = () => {
+    const { sdk } = useAerostack();
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const query = useCallback(async (sql: string, params?: any[]) => {
+        try {
+            setLoading(true);
+            setError(null);
+            const result = await sdk.database.dbQuery({ sql, params });
+            return result; // result is already DBQueryResult
+        } catch (err) {
+            const error = err instanceof Error ? err : new Error('Database query failed');
+            setError(error);
+            throw error;
+        } finally {
+            setLoading(false);
+        }
+    }, [sdk]);
+
+    return {
+        query,
+        loading,
+        error,
+    };
+};

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './context.js';
+export * from './hooks/useAuth.js';
+export * from './hooks/useDb.js';
+export * from './hooks/useAI.js';
+export * from './hooks/useCache.js';
+
+// Re-export core types for convenience
+export type { SDK } from '@aerostack/sdk-web';

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+    "compilerOptions": {
+        "incremental": false,
+        "target": "ES2020",
+        "lib": [
+            "ES2022",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "jsx": "react-jsx",
+        "module": "Node16",
+        "moduleResolution": "Node16",
+        "allowJs": true,
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "outDir": ".",
+        "strict": true,
+        "isolatedModules": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
+}