aurabase-js 0.1.0

package/.omc/state/hud-state.json

@@ -0,0 +1,6 @@
+{
+  "timestamp": "2026-03-09T11:49:17.080Z",
+  "backgroundTasks": [],
+  "sessionStartTimestamp": "2026-03-09T11:37:51.558Z",
+  "sessionId": "a7635597b80deb9e"
+}

package/.omc/state/hud-stdin-cache.json

@@ -0,0 +1 @@
+{"session_id":"85311ae7-4e13-466c-9bb0-4bf05ada3ed1","transcript_path":"C:\\Users\\Jay\\.claude\\projects\\D--000-FrontEnd-242-dino-game\\85311ae7-4e13-466c-9bb0-4bf05ada3ed1.jsonl","cwd":"D:\\000.FrontEnd\\242.dino_game\\packages\\aurabase-js","model":{"id":"GLM-5","display_name":"GLM-5"},"workspace":{"current_dir":"D:\\000.FrontEnd\\242.dino_game\\packages\\aurabase-js","project_dir":"D:\\000.FrontEnd\\242.dino_game","added_dirs":[]},"version":"2.1.71","output_style":{"name":"default"},"cost":{"total_cost_usd":1.0113789999999998,"total_duration_ms":1112478,"total_api_duration_ms":476001,"total_lines_added":1354,"total_lines_removed":2},"context_window":{"total_input_tokens":32475,"total_output_tokens":11628,"context_window_size":200000,"current_usage":{"input_tokens":169,"output_tokens":104,"cache_creation_input_tokens":0,"cache_read_input_tokens":48768},"used_percentage":24,"remaining_percentage":76},"exceeds_200k_tokens":false}

package/README.md

@@ -0,0 +1,204 @@
+# aurabase-js
+
+AuraBase JavaScript/TypeScript 클라이언트 - Supabase 스타일의 SDK
+
+## 설치
+
+```bash
+npm install aurabase-js
+# 또는
+yarn add aurabase-js
+# 또는
+pnpm add aurabase-js
+```
+
+## 사용법
+
+### 클라이언트 생성
+
+```typescript
+import { createClient } from 'aurabase-js'
+
+const aurabase = createClient({
+  url: 'http://localhost:8000', // 또는 배포된 URL
+  anonKey: 'your-anon-key'
+})
+```
+
+### 데이터 조회 (SELECT)
+
+```typescript
+// 전체 조회
+const { data, error } = await aurabase
+  .from('todos')
+  .select('*')
+
+// 특정 컬럼 선택
+const { data, error } = await aurabase
+  .from('todos')
+  .select('id, title, completed')
+
+// 필터링
+const { data, error } = await aurabase
+  .from('todos')
+  .select('*')
+  .eq('completed', false)
+  .order('created_at', { ascending: false })
+  .limit(10)
+
+// 단일 결과
+const { data, error } = await aurabase
+  .from('todos')
+  .select('*')
+  .eq('id', 1)
+  .single()
+```
+
+### 데이터 삽입 (INSERT)
+
+```typescript
+// 단일 행 삽입
+const { data, error } = await aurabase
+  .from('todos')
+  .insert({ title: '새 할일', completed: false })
+
+// 여러 행 삽입
+const { data, error } = await aurabase
+  .from('todos')
+  .insert([
+    { title: '할일 1', completed: false },
+    { title: '할일 2', completed: true }
+  ])
+```
+
+### 데이터 수정 (UPDATE)
+
+```typescript
+const { data, error } = await aurabase
+  .from('todos')
+  .update({ completed: true })
+  .eq('id', 1)
+```
+
+### 데이터 삭제 (DELETE)
+
+```typescript
+const { data, error } = await aurabase
+  .from('todos')
+  .delete()
+  .eq('id', 1)
+```
+
+### Upsert
+
+```typescript
+const { data, error } = await aurabase
+  .from('todos')
+  .upsert({ id: 1, title: '업데이트된 할일', completed: true })
+```
+
+## 인증 (Auth)
+
+### 로그인
+
+```typescript
+const { data, error } = await aurabase.auth.signInWithPassword({
+  email: 'user@example.com',
+  password: 'password123'
+})
+
+if (data) {
+  console.log('로그인 성공:', data.user)
+  console.log('액세스 토큰:', data.session.access_token)
+}
+```
+
+### 회원가입
+
+```typescript
+const { data, error } = await aurabase.auth.signUp({
+  email: 'user@example.com',
+  password: 'password123',
+  username: 'myusername'
+})
+```
+
+### 로그아웃
+
+```typescript
+await aurabase.auth.signOut()
+```
+
+### 현재 사용자 조회
+
+```typescript
+const { data: { user } } = await aurabase.auth.getUser()
+```
+
+### 인증 상태 변경 감지
+
+```typescript
+const { data: { subscription } } = aurabase.auth.onAuthStateChange((event, session) => {
+  if (event === 'SIGNED_IN') {
+    console.log('로그인됨:', session?.user)
+  } else if (event === 'SIGNED_OUT') {
+    console.log('로그아웃됨')
+  }
+})
+
+// 구독 해제
+subscription.unsubscribe()
+```
+
+### 비밀번호 재설정
+
+```typescript
+await aurabase.auth.resetPasswordForEmail('user@example.com')
+```
+
+## 필터 메서드
+
+| 메서드 | 설명 | 예시 |
+|--------|------|------|
+| `.eq(column, value)` | 같음 | `.eq('status', 'active')` |
+| `.neq(column, value)` | 같지 않음 | `.neq('status', 'deleted')` |
+| `.gt(column, value)` | 초과 | `.gt('age', 18)` |
+| `.gte(column, value)` | 이상 | `.gte('age', 18)` |
+| `.lt(column, value)` | 미만 | `.lt('price', 100)` |
+| `.lte(column, value)` | 이하 | `.lte('price', 100)` |
+| `.like(column, pattern)` | LIKE 패턴 | `.like('name', '%John%')` |
+| `.ilike(column, pattern)` | 대소문자 구분 없는 LIKE | `.ilike('email', '%@gmail.com')` |
+| `.in(column, values)` | 값 목록 중 하나 | `.in('id', [1, 2, 3])` |
+| `.isNull(column)` | NULL | `.isNull('deleted_at')` |
+| `.isNotNull(column)` | NOT NULL | `.isNotNull('email')` |
+
+## RPC (원격 함수 호출)
+
+```typescript
+const { data, error } = await aurabase.rpc('my_function', {
+  arg1: 'value1',
+  arg2: 'value2'
+})
+```
+
+## TypeScript 지원
+
+```typescript
+interface Todo {
+  id: number
+  title: string
+  completed: boolean
+  created_at: string
+}
+
+// 타입 지정
+const { data, error } = await aurabase
+  .from<Todo>('todos')
+  .select('*')
+
+// data는 Todo[] 타입으로 추론됨
+```
+
+## 라이선스
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,392 @@
+interface AuraBaseClientOptions {
+    url: string;
+    anonKey: string;
+    headers?: Record<string, string>;
+}
+interface AuthSession {
+    access_token: string;
+    token_type: string;
+    user: User;
+}
+interface User {
+    id: number;
+    email: string;
+    username?: string;
+    role_id?: number;
+    created_at?: string;
+}
+interface AuthError {
+    error: string;
+    detail?: string | Array<{
+        msg: string;
+    }>;
+}
+interface PostgrestResponse<T> {
+    data: T | T[] | null;
+    error: AuraBaseError | null;
+    status: number;
+    statusText: string;
+}
+interface AuraBaseError {
+    message: string;
+    code?: string;
+    details?: string;
+}
+interface AuthStateChangeEvent {
+    SIGNED_IN: 'SIGNED_IN';
+    SIGNED_OUT: 'SIGNED_OUT';
+    TOKEN_REFRESHED: 'TOKEN_REFRESHED';
+    USER_UPDATED: 'USER_UPDATED';
+}
+type AuthChangeEvent = AuthStateChangeEvent[keyof AuthStateChangeEvent];
+interface Subscription {
+    unsubscribe: () => void;
+}
+interface SignInWithPasswordCredentials {
+    email: string;
+    password: string;
+}
+interface SignUpCredentials {
+    email: string;
+    password: string;
+    username?: string;
+}
+interface UpdateUserAttributes {
+    email?: string;
+    password?: string;
+    username?: string;
+}
+
+declare class QueryBuilder<T> {
+    private url;
+    private anonKey;
+    private accessToken;
+    private tableName;
+    private queryParams;
+    private headers;
+    private isSingle;
+    constructor(url: string, anonKey: string, accessToken: string | null, tableName: string, headers?: Record<string, string>);
+    /**
+     * Select columns
+     * @example
+     * .select('id, name, email')
+     * .select('*')
+     */
+    select(columns?: string): this;
+    /**
+     * Filter by column equality
+     * @example
+     * .eq('id', 1)
+     * .eq('status', 'active')
+     */
+    eq(column: string, value: unknown): this;
+    /**
+     * Filter by column inequality
+     */
+    neq(column: string, value: unknown): this;
+    /**
+     * Filter by greater than
+     */
+    gt(column: string, value: unknown): this;
+    /**
+     * Filter by greater than or equal
+     */
+    gte(column: string, value: unknown): this;
+    /**
+     * Filter by less than
+     */
+    lt(column: string, value: unknown): this;
+    /**
+     * Filter by less than or equal
+     */
+    lte(column: string, value: unknown): this;
+    /**
+     * Filter by like pattern
+     */
+    like(column: string, pattern: string): this;
+    /**
+     * Filter by case-insensitive like pattern
+     */
+    ilike(column: string, pattern: string): this;
+    /**
+     * Filter by array contains
+     */
+    contains(column: string, value: unknown[]): this;
+    /**
+     * Filter by value in array
+     */
+    in(column: string, values: unknown[]): this;
+    /**
+     * Filter for null values
+     */
+    isNull(column: string): this;
+    /**
+     * Filter for non-null values
+     */
+    isNotNull(column: string): this;
+    /**
+     * Order results
+     * @example
+     * .order('created_at', { ascending: false })
+     */
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): this;
+    /**
+     * Limit results
+     */
+    limit(count: number): this;
+    /**
+     * Offset results
+     */
+    offset(count: number): this;
+    /**
+     * Range of results (offset + limit)
+     */
+    range(from: number, to: number): this;
+    /**
+     * Return single result
+     */
+    single(): this;
+    /**
+     * Return single result or null
+     */
+    maybeSingle(): this;
+    private getHeaders;
+    private request;
+    /**
+     * Execute SELECT query
+     */
+    then<TResult = T[]>(resolve: (value: PostgrestResponse<TResult>) => void | PromiseLike<void>, reject?: (reason: unknown) => void | PromiseLike<void>): Promise<void>;
+    /**
+     * Insert row(s)
+     */
+    insert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>>;
+    /**
+     * Update row(s)
+     */
+    update(data: Partial<T>): Promise<PostgrestResponse<T>>;
+    /**
+     * Upsert row(s)
+     */
+    upsert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>>;
+    /**
+     * Delete row(s)
+     */
+    delete(): Promise<PostgrestResponse<T>>;
+}
+
+declare class AuthClient {
+    private url;
+    private anonKey;
+    private listeners;
+    private currentSession;
+    private storageKey;
+    constructor(url: string, anonKey: string);
+    private loadSession;
+    private saveSession;
+    private getHeaders;
+    private emitEvent;
+    /**
+     * Sign in with email and password
+     */
+    signInWithPassword(credentials: SignInWithPasswordCredentials): Promise<{
+        data: {
+            user: User;
+            session: AuthSession;
+        } | null;
+        error: AuthError | null;
+    }>;
+    /**
+     * Sign up with email and password
+     */
+    signUp(credentials: SignUpCredentials): Promise<{
+        data: {
+            user: User;
+        } | null;
+        error: AuthError | null;
+    }>;
+    /**
+     * Sign out
+     */
+    signOut(): Promise<{
+        error: AuthError | null;
+    }>;
+    /**
+     * Get current session
+     */
+    getSession(): {
+        data: {
+            session: AuthSession | null;
+        };
+    };
+    /**
+     * Get current user
+     */
+    getUser(): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: AuthError | null;
+    }>;
+    /**
+     * Update user
+     */
+    updateUser(attributes: UpdateUserAttributes): Promise<{
+        data: {
+            user: User;
+        } | null;
+        error: AuthError | null;
+    }>;
+    /**
+     * Request password reset
+     */
+    resetPasswordForEmail(email: string): Promise<{
+        error: AuthError | null;
+    }>;
+    /**
+     * Subscribe to auth state changes
+     */
+    onAuthStateChange(callback: (event: AuthChangeEvent, session: AuthSession | null) => void): {
+        data: {
+            subscription: Subscription;
+        };
+    };
+}
+
+declare class AuraBaseClient {
+    private url;
+    private anonKey;
+    private accessToken;
+    private customHeaders;
+    auth: AuthClient;
+    constructor(options: AuraBaseClientOptions);
+    /**
+     * Set access token for authenticated requests
+     */
+    setAccessToken(token: string | null): void;
+    /**
+     * Get the current access token
+     */
+    getAccessToken(): string | null;
+    /**
+     * Query a table
+     * @example
+     * const { data, error } = await client.from('todos').select('*')
+     */
+    from<T = unknown>(tableName: string): QueryBuilder<T>;
+    /**
+     * Execute raw SQL (RPC function call)
+     * @example
+     * const { data, error } = await client.rpc('my_function', { arg1: 'value' })
+     */
+    rpc<T = unknown>(functionName: string, params?: Record<string, unknown>): Promise<{
+        data: T | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * Get storage client (if available)
+     */
+    get storage(): {
+        from: (bucket: string) => StorageBucket;
+    };
+}
+/**
+ * Storage bucket operations
+ */
+declare class StorageBucket {
+    private url;
+    private anonKey;
+    private bucket;
+    private accessToken;
+    constructor(url: string, anonKey: string, bucket: string, accessToken: string | null);
+    private getHeaders;
+    /**
+     * Upload a file
+     */
+    upload(path: string, file: File | Blob, options?: {
+        contentType?: string;
+        upsert?: boolean;
+    }): Promise<{
+        data: {
+            path: string;
+        } | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * Download a file
+     */
+    download(path: string): Promise<{
+        data: Blob | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * Get public URL for a file
+     */
+    getPublicUrl(path: string): string;
+    /**
+     * Delete a file
+     */
+    remove(paths: string[]): Promise<{
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * List files in a bucket
+     */
+    list(prefix?: string): Promise<{
+        data: Array<{
+            name: string;
+            id: string;
+            created_at: string;
+        }> | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+}
+
+/**
+ * Create an AuraBase client
+ * @param options - Client options containing url and anonKey
+ * @returns AuraBaseClient instance
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from 'aurabase-js'
+ *
+ * const aurabase = createClient({
+ *   url: 'http://localhost:8000',
+ *   anonKey: 'your-anon-key'
+ * })
+ *
+ * // Query data
+ * const { data, error } = await aurabase
+ *   .from('todos')
+ *   .select('*')
+ *   .order('created_at', { ascending: false })
+ *   .limit(10)
+ *
+ * // Insert data
+ * const { data: newTodo, error: insertError } = await aurabase
+ *   .from('todos')
+ *   .insert({ title: 'My todo', completed: false })
+ *
+ * // Auth
+ * const { data, error } = await aurabase.auth.signInWithPassword({
+ *   email: 'user@example.com',
+ *   password: 'password'
+ * })
+ * ```
+ */
+declare function createClient(options: AuraBaseClientOptions): AuraBaseClient;
+
+export { AuraBaseClient, type AuraBaseClientOptions, type AuraBaseError, type AuthChangeEvent, type AuthError, type AuthSession, type PostgrestResponse, type SignInWithPasswordCredentials, type SignUpCredentials, type Subscription, type UpdateUserAttributes, type User, createClient, createClient as default };