krisspy-sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,605 @@
+/**
+ * Krisspy SDK Types
+ */
+interface KrisspyClientOptions {
+    /** Base URL of the Krisspy API (default: https://api.krisspy.ai) */
+    url?: string;
+    /** Backend ID for this client */
+    backendId: string;
+    /** API key or access token */
+    apiKey?: string;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+    /** Enable debug logging */
+    debug?: boolean;
+    /**
+     * Use RLS (Row Level Security) endpoints for data access
+     * Default: true
+     *
+     * When true, uses /rls/data/* endpoints which require app user authentication
+     * and enforce row-level security policies.
+     *
+     * When false, uses legacy /data/* endpoints which require backend owner auth.
+     */
+    useRLS?: boolean;
+}
+interface User {
+    id: string;
+    email: string;
+    metadata?: Record<string, any>;
+    created_at?: string;
+    updated_at?: string;
+}
+interface Session {
+    access_token: string;
+    refresh_token?: string;
+    expires_at?: number;
+    expires_in?: number;
+    user: User;
+}
+interface AuthResponse {
+    data: {
+        user: User | null;
+        session: Session | null;
+    };
+    error: KrisspyError | null;
+}
+interface SignUpCredentials {
+    email: string;
+    password: string;
+    metadata?: Record<string, any>;
+}
+interface SignInCredentials {
+    email: string;
+    password: string;
+}
+interface OAuthProvider {
+    provider: 'google' | 'github' | 'microsoft';
+    redirectTo?: string;
+}
+interface QueryResponse<T = any> {
+    data: T[] | null;
+    error: KrisspyError | null;
+    count: number | null;
+}
+interface SingleResponse<T = any> {
+    data: T | null;
+    error: KrisspyError | null;
+}
+interface MutationResponse<T = any> {
+    data: T[] | null;
+    error: KrisspyError | null;
+    count: number;
+}
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'in' | 'is';
+interface Filter {
+    column: string;
+    operator: FilterOperator;
+    value: any;
+}
+interface OrderBy {
+    column: string;
+    ascending: boolean;
+}
+interface QueryOptions {
+    select?: string[];
+    filters?: Filter[];
+    order?: OrderBy[];
+    limit?: number;
+    offset?: number;
+}
+interface KrisspyError {
+    message: string;
+    code?: string;
+    details?: string;
+    hint?: string;
+    status?: number;
+}
+interface FunctionInvokeOptions {
+    body?: Record<string, any>;
+    headers?: Record<string, string>;
+}
+interface FunctionResponse<T = any> {
+    data: T | null;
+    error: KrisspyError | null;
+}
+interface FileUploadOptions {
+    cacheControl?: string;
+    contentType?: string;
+    upsert?: boolean;
+}
+interface FileObject {
+    id: string;
+    name: string;
+    bucket: string;
+    path: string;
+    size: number;
+    content_type: string;
+    created_at: string;
+    updated_at: string;
+}
+
+/**
+ * HTTP Client for Krisspy SDK
+ */
+
+interface HttpClientOptions {
+    baseUrl: string;
+    headers?: Record<string, string>;
+    debug?: boolean;
+}
+interface HttpResponse<T = any> {
+    data: T | null;
+    error: KrisspyError | null;
+    status: number;
+}
+declare class HttpClient {
+    private baseUrl;
+    private headers;
+    private debug;
+    constructor(options: HttpClientOptions);
+    /**
+     * Set authorization header
+     */
+    setAuth(token: string): void;
+    /**
+     * Remove authorization header
+     */
+    clearAuth(): void;
+    /**
+     * Update headers
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Build query string from params
+     */
+    private buildQueryString;
+    /**
+     * Make HTTP request
+     */
+    private request;
+    /**
+     * GET request
+     */
+    get<T>(path: string, params?: Record<string, any>): Promise<HttpResponse<T>>;
+    /**
+     * POST request
+     */
+    post<T>(path: string, body?: any, params?: Record<string, any>): Promise<HttpResponse<T>>;
+    /**
+     * PATCH request
+     */
+    patch<T>(path: string, body?: any, params?: Record<string, any>): Promise<HttpResponse<T>>;
+    /**
+     * PUT request
+     */
+    put<T>(path: string, body?: any, params?: Record<string, any>): Promise<HttpResponse<T>>;
+    /**
+     * DELETE request
+     */
+    delete<T>(path: string, params?: Record<string, any>): Promise<HttpResponse<T>>;
+}
+
+/**
+ * Auth Module - User authentication for Krisspy backends
+ */
+
+declare class KrisspyAuth {
+    private http;
+    private backendId;
+    private currentSession;
+    private currentUser;
+    private listeners;
+    private refreshInterval?;
+    constructor(http: HttpClient, backendId: string);
+    /**
+     * Get current session from storage
+     */
+    private restoreSession;
+    /**
+     * Store session
+     */
+    private saveSession;
+    /**
+     * Clear session from storage
+     */
+    private clearSession;
+    /**
+     * Set current session
+     */
+    private setSession;
+    /**
+     * Setup auto-refresh of token
+     */
+    private setupAutoRefresh;
+    /**
+     * Notify auth state change listeners
+     */
+    private notifyListeners;
+    /**
+     * Sign up with email and password
+     */
+    signUp(credentials: SignUpCredentials): Promise<AuthResponse>;
+    /**
+     * Sign in with email and password
+     */
+    signInWithPassword(credentials: SignInCredentials): Promise<AuthResponse>;
+    /**
+     * Sign in with OAuth provider
+     */
+    signInWithOAuth(options: OAuthProvider): Promise<{
+        data: {
+            url: string;
+        } | null;
+        error: KrisspyError | null;
+    }>;
+    /**
+     * Sign out
+     */
+    signOut(): Promise<{
+        error: KrisspyError | null;
+    }>;
+    /**
+     * Refresh the session token
+     */
+    refreshSession(): Promise<AuthResponse>;
+    /**
+     * Get current session
+     */
+    getSession(): Promise<{
+        data: {
+            session: Session | null;
+        };
+        error: KrisspyError | null;
+    }>;
+    /**
+     * Get current user
+     */
+    getUser(): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: KrisspyError | null;
+    }>;
+    /**
+     * Get current user synchronously
+     */
+    user(): User | null;
+    /**
+     * Get current session synchronously
+     */
+    session(): Session | null;
+    /**
+     * Update user metadata
+     */
+    updateUser(data: {
+        metadata?: Record<string, any>;
+        password?: string;
+    }): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: KrisspyError | null;
+    }>;
+    /**
+     * Request password reset
+     */
+    resetPasswordForEmail(email: string): Promise<{
+        error: KrisspyError | null;
+    }>;
+    /**
+     * Listen for auth state changes
+     */
+    onAuthStateChange(callback: (event: AuthChangeEvent) => void): {
+        unsubscribe: () => void;
+    };
+    /**
+     * Set session from external source (e.g., OAuth callback)
+     */
+    setSessionFromUrl(): Promise<AuthResponse>;
+}
+type AuthChangeEvent = 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED';
+
+/**
+ * Query Builder - Supabase-style fluent API for database queries
+ */
+
+declare class QueryBuilder<T = any> {
+    private http;
+    private backendId;
+    private tableName;
+    private queryParams;
+    private selectColumns;
+    private orderClauses;
+    private limitValue?;
+    private offsetValue?;
+    private isSingle;
+    private useRLS;
+    constructor(http: HttpClient, backendId: string, tableName: string, useRLS?: boolean);
+    /**
+     * Get the base path for data endpoints
+     * Uses /rls/data for RLS-enabled queries (requires auth)
+     * Uses /data for legacy queries (admin/owner only)
+     */
+    private getBasePath;
+    /**
+     * Select specific columns
+     * @example .select('id, name, price')
+     * @example .select('*')
+     */
+    select(columns?: string): this;
+    /**
+     * Filter: equals
+     * @example .eq('id', 123)
+     */
+    eq(column: string, value: any): this;
+    /**
+     * Filter: not equals
+     * @example .neq('status', 'deleted')
+     */
+    neq(column: string, value: any): this;
+    /**
+     * Filter: greater than
+     * @example .gt('price', 100)
+     */
+    gt(column: string, value: any): this;
+    /**
+     * Filter: greater than or equal
+     * @example .gte('age', 18)
+     */
+    gte(column: string, value: any): this;
+    /**
+     * Filter: less than
+     * @example .lt('stock', 10)
+     */
+    lt(column: string, value: any): this;
+    /**
+     * Filter: less than or equal
+     * @example .lte('price', 1000)
+     */
+    lte(column: string, value: any): this;
+    /**
+     * Filter: pattern matching (case sensitive)
+     * @example .like('name', '%iPhone%')
+     */
+    like(column: string, pattern: string): this;
+    /**
+     * Filter: pattern matching (case insensitive)
+     * @example .ilike('name', '%iphone%')
+     */
+    ilike(column: string, pattern: string): this;
+    /**
+     * Filter: value in list
+     * @example .in('status', ['active', 'pending'])
+     */
+    in(column: string, values: any[]): this;
+    /**
+     * Filter: is null/true/false
+     * @example .is('deleted_at', null)
+     */
+    is(column: string, value: null | boolean): this;
+    /**
+     * Order by column
+     * @example .order('created_at', { ascending: false })
+     */
+    order(column: string, options?: {
+        ascending?: boolean;
+    }): this;
+    /**
+     * Limit number of rows
+     * @example .limit(10)
+     */
+    limit(count: number): this;
+    /**
+     * Skip rows (for pagination)
+     * @example .range(0, 9) // First 10 rows
+     */
+    range(from: number, to: number): this;
+    /**
+     * Return single row (throws if multiple or none)
+     */
+    single(): QueryBuilder<T>;
+    /**
+     * Return first row or null
+     */
+    maybeSingle(): QueryBuilder<T>;
+    /**
+     * Build query params for the request
+     */
+    private buildParams;
+    /**
+     * Execute SELECT query
+     */
+    then<TResult = QueryResponse<T> | SingleResponse<T>>(resolve: (value: TResult) => void, reject?: (reason: any) => void): Promise<void>;
+    /**
+     * Execute the query
+     */
+    private execute;
+    /**
+     * Insert rows
+     * @example .insert({ name: 'iPhone', price: 999 })
+     * @example .insert([{ name: 'iPhone' }, { name: 'iPad' }])
+     */
+    insert(data: Partial<T> | Partial<T>[]): Promise<MutationResponse<T>>;
+    /**
+     * Update rows (requires filters)
+     * @example .update({ price: 899 }).eq('id', 123)
+     */
+    update(data: Partial<T>): Promise<MutationResponse<T>>;
+    /**
+     * Delete rows (requires filters)
+     * @example .delete().eq('id', 123)
+     */
+    delete(): Promise<MutationResponse<T>>;
+    /**
+     * Upsert rows (insert or update on conflict)
+     * @example .upsert({ id: 1, name: 'iPhone' })
+     */
+    upsert(data: Partial<T> | Partial<T>[], options?: {
+        onConflict?: string;
+    }): Promise<MutationResponse<T>>;
+}
+
+/**
+ * Krisspy Client - Main entry point for the SDK
+ */
+
+declare class KrisspyClient {
+    private http;
+    private backendId;
+    private _auth;
+    private useRLS;
+    constructor(options: KrisspyClientOptions);
+    /**
+     * Auth module for user authentication
+     *
+     * @example
+     * // Sign up
+     * const { data, error } = await krisspy.auth.signUp({
+     *   email: 'user@example.com',
+     *   password: 'secret123'
+     * })
+     *
+     * // Sign in
+     * const { data, error } = await krisspy.auth.signInWithPassword({
+     *   email: 'user@example.com',
+     *   password: 'secret123'
+     * })
+     *
+     * // Get current user
+     * const user = krisspy.auth.user()
+     *
+     * // Sign out
+     * await krisspy.auth.signOut()
+     */
+    get auth(): KrisspyAuth;
+    /**
+     * Create a query builder for a table
+     *
+     * @example
+     * // Select all rows
+     * const { data, error } = await krisspy.from('products').select('*')
+     *
+     * // Select with filters
+     * const { data, error } = await krisspy
+     *   .from('products')
+     *   .select('id, name, price')
+     *   .eq('active', true)
+     *   .order('created_at', { ascending: false })
+     *   .limit(10)
+     *
+     * // Insert
+     * const { data, error } = await krisspy
+     *   .from('products')
+     *   .insert({ name: 'iPhone', price: 999 })
+     *
+     * // Update
+     * const { data, error } = await krisspy
+     *   .from('products')
+     *   .update({ price: 899 })
+     *   .eq('id', 123)
+     *
+     * // Delete
+     * const { data, error } = await krisspy
+     *   .from('products')
+     *   .delete()
+     *   .eq('id', 123)
+     */
+    from<T = any>(table: string): QueryBuilder<T>;
+    /**
+     * Execute raw SQL query
+     *
+     * @example
+     * const { data, error } = await krisspy.rpc('SELECT * FROM products WHERE price > $1', [100])
+     */
+    rpc<T = any>(sql: string, params?: any[]): Promise<{
+        data: T | null;
+        error: any;
+    }>;
+    /**
+     * Invoke a serverless function
+     *
+     * @example
+     * const { data, error } = await krisspy.functions.invoke('hello-world', {
+     *   body: { name: 'John' }
+     * })
+     */
+    get functions(): {
+        invoke: <T = any>(functionName: string, options?: FunctionInvokeOptions) => Promise<FunctionResponse<T>>;
+        list: () => Promise<{
+            data: any[] | null;
+            error: any;
+        }>;
+    };
+    /**
+     * Get backend info
+     */
+    getBackendInfo(): Promise<{
+        data: any | null;
+        error: any;
+    }>;
+    /**
+     * List tables in the backend
+     */
+    listTables(): Promise<{
+        data: string[] | null;
+        error: any;
+    }>;
+    /**
+     * Get table schema (columns)
+     */
+    getTableSchema(table: string): Promise<{
+        data: any[] | null;
+        error: any;
+    }>;
+}
+
+/**
+ * @krisspy/sdk - Krisspy Cloud SDK
+ *
+ * Database, Auth, and Functions for your apps.
+ * A simpler alternative to Supabase.
+ *
+ * @example
+ * import { createClient } from '@krisspy/sdk'
+ *
+ * const krisspy = createClient({
+ *   backendId: 'your-backend-id',
+ *   apiKey: 'your-api-key', // optional
+ * })
+ *
+ * // Auth
+ * await krisspy.auth.signUp({ email, password })
+ * await krisspy.auth.signInWithPassword({ email, password })
+ *
+ * // Database
+ * const { data, error } = await krisspy
+ *   .from('products')
+ *   .select('*')
+ *   .eq('active', true)
+ *   .order('created_at', { ascending: false })
+ *   .limit(10)
+ *
+ * // Insert
+ * await krisspy.from('products').insert({ name: 'iPhone', price: 999 })
+ *
+ * // Functions
+ * await krisspy.functions.invoke('hello', { body: { name: 'World' } })
+ */
+
+/**
+ * Create a new Krisspy client
+ *
+ * @param options - Client configuration options
+ * @returns KrisspyClient instance
+ *
+ * @example
+ * const krisspy = createClient({
+ *   backendId: 'abc123',
+ *   apiKey: 'your-api-key',
+ *   url: 'https://api.krisspy.ai', // optional
+ * })
+ */
+declare function createClient(options: KrisspyClientOptions): KrisspyClient;
+
+export { type AuthChangeEvent, type AuthResponse, type FileObject, type FileUploadOptions, type Filter, type FilterOperator, type FunctionInvokeOptions, type FunctionResponse, HttpClient, KrisspyAuth, KrisspyClient, type KrisspyClientOptions, type KrisspyError, type MutationResponse, type OAuthProvider, type OrderBy, QueryBuilder, type QueryOptions, type QueryResponse, type Session, type SignInCredentials, type SignUpCredentials, type SingleResponse, type User, createClient };