aurabase-js 0.1.0

package/src/QueryBuilder.ts

@@ -0,0 +1,319 @@
+import { AuraBaseApiError } from './errors';
+import { PostgrestResponse, AuraBaseError } from './types';
+
+type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+
+export class QueryBuilder<T> {
+  private url: string;
+  private anonKey: string;
+  private accessToken: string | null;
+  private tableName: string;
+  private queryParams: URLSearchParams;
+  private headers: Record<string, string>;
+  private isSingle: boolean = false;
+
+  constructor(
+    url: string,
+    anonKey: string,
+    accessToken: string | null,
+    tableName: string,
+    headers: Record<string, string> = {}
+  ) {
+    this.url = url;
+    this.anonKey = anonKey;
+    this.accessToken = accessToken;
+    this.tableName = tableName;
+    this.queryParams = new URLSearchParams();
+    this.headers = { ...headers };
+  }
+
+  /**
+   * Select columns
+   * @example
+   * .select('id, name, email')
+   * .select('*')
+   */
+  select(columns: string = '*'): this {
+    this.queryParams.set('select', columns);
+    return this;
+  }
+
+  /**
+   * Filter by column equality
+   * @example
+   * .eq('id', 1)
+   * .eq('status', 'active')
+   */
+  eq(column: string, value: unknown): this {
+    this.queryParams.append(column, `eq.${value}`);
+    return this;
+  }
+
+  /**
+   * Filter by column inequality
+   */
+  neq(column: string, value: unknown): this {
+    this.queryParams.append(column, `neq.${value}`);
+    return this;
+  }
+
+  /**
+   * Filter by greater than
+   */
+  gt(column: string, value: unknown): this {
+    this.queryParams.append(column, `gt.${value}`);
+    return this;
+  }
+
+  /**
+   * Filter by greater than or equal
+   */
+  gte(column: string, value: unknown): this {
+    this.queryParams.append(column, `gte.${value}`);
+    return this;
+  }
+
+  /**
+   * Filter by less than
+   */
+  lt(column: string, value: unknown): this {
+    this.queryParams.append(column, `lt.${value}`);
+    return this;
+  }
+
+  /**
+   * Filter by less than or equal
+   */
+  lte(column: string, value: unknown): this {
+    this.queryParams.append(column, `lte.${value}`);
+    return this;
+  }
+
+  /**
+   * Filter by like pattern
+   */
+  like(column: string, pattern: string): this {
+    this.queryParams.append(column, `like.${pattern}`);
+    return this;
+  }
+
+  /**
+   * Filter by case-insensitive like pattern
+   */
+  ilike(column: string, pattern: string): this {
+    this.queryParams.append(column, `ilike.${pattern}`);
+    return this;
+  }
+
+  /**
+   * Filter by array contains
+   */
+  contains(column: string, value: unknown[]): this {
+    this.queryParams.append(column, `cs.{${value.join(',')}}`);
+    return this;
+  }
+
+  /**
+   * Filter by value in array
+   */
+  in(column: string, values: unknown[]): this {
+    this.queryParams.append(column, `in.(${values.join(',')})`);
+    return this;
+  }
+
+  /**
+   * Filter for null values
+   */
+  isNull(column: string): this {
+    this.queryParams.append(column, 'is.null');
+    return this;
+  }
+
+  /**
+   * Filter for non-null values
+   */
+  isNotNull(column: string): this {
+    this.queryParams.append(column, 'is.not.null');
+    return this;
+  }
+
+  /**
+   * Order results
+   * @example
+   * .order('created_at', { ascending: false })
+   */
+  order(column: string, options: { ascending?: boolean; nullsFirst?: boolean } = {}): this {
+    const { ascending = true, nullsFirst } = options;
+    let orderStr = column;
+    if (!ascending) orderStr += '.desc';
+    if (nullsFirst !== undefined) {
+      orderStr += nullsFirst ? '.nullsfirst' : '.nullslast';
+    }
+    this.queryParams.append('order', orderStr);
+    return this;
+  }
+
+  /**
+   * Limit results
+   */
+  limit(count: number): this {
+    this.queryParams.set('limit', String(count));
+    return this;
+  }
+
+  /**
+   * Offset results
+   */
+  offset(count: number): this {
+    this.queryParams.set('offset', String(count));
+    return this;
+  }
+
+  /**
+   * Range of results (offset + limit)
+   */
+  range(from: number, to: number): this {
+    this.queryParams.set('offset', String(from));
+    this.queryParams.set('limit', String(to - from + 1));
+    return this;
+  }
+
+  /**
+   * Return single result
+   */
+  single(): this {
+    this.isSingle = true;
+    return this;
+  }
+
+  /**
+   * Return single result or null
+   */
+  maybeSingle(): this {
+    this.isSingle = true;
+    return this;
+  }
+
+  private getHeaders(): Record<string, string> {
+    const token = this.accessToken || this.anonKey;
+    return {
+      'Content-Type': 'application/json',
+      'apikey': this.anonKey,
+      'Authorization': `Bearer ${token}`,
+      ...this.headers,
+    };
+  }
+
+  private async request<TResponse>(
+    method: HttpMethod,
+    body?: unknown
+  ): Promise<PostgrestResponse<TResponse>> {
+    const queryString = this.queryParams.toString();
+    const fullUrl = `${this.url}/rest/v1/${this.tableName}${queryString ? `?${queryString}` : ''}`;
+
+    const options: RequestInit = {
+      method,
+      headers: this.getHeaders(),
+    };
+
+    if (body && method !== 'GET') {
+      options.body = JSON.stringify(body);
+      (options.headers as Record<string, string>)['Prefer'] = 'return=representation';
+    }
+
+    try {
+      const response = await fetch(fullUrl, options);
+
+      let data: TResponse | null = null;
+      let error: AuraBaseError | null = null;
+
+      const text = await response.text();
+
+      if (text) {
+        try {
+          const parsed = JSON.parse(text);
+
+          if (!response.ok) {
+            error = {
+              message: parsed.message || parsed.error || `HTTP ${response.status}`,
+              code: parsed.code,
+              details: parsed.details,
+            };
+          } else {
+            data = this.isSingle && Array.isArray(parsed) ? parsed[0] ?? null : parsed;
+          }
+        } catch {
+          if (!response.ok) {
+            error = {
+              message: text || `HTTP ${response.status}`,
+            };
+          }
+        }
+      }
+
+      return {
+        data,
+        error,
+        status: response.status,
+        statusText: response.statusText,
+      };
+    } catch (err) {
+      return {
+        data: null,
+        error: {
+          message: err instanceof Error ? err.message : 'Network error',
+        },
+        status: 0,
+        statusText: 'Network Error',
+      };
+    }
+  }
+
+  /**
+   * Execute SELECT query
+   */
+  async then<TResult = T[]>(
+    resolve: (value: PostgrestResponse<TResult>) => void | PromiseLike<void>,
+    reject?: (reason: unknown) => void | PromiseLike<void>
+  ): Promise<void> {
+    try {
+      const result = await this.request<TResult>('GET');
+      await resolve(result);
+    } catch (err) {
+      if (reject) {
+        await reject(err);
+      }
+    }
+  }
+
+  /**
+   * Insert row(s)
+   */
+  async insert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>> {
+    const rows = Array.isArray(row) ? row : [row];
+    return this.request<T>('POST', rows.length === 1 ? rows[0] : rows);
+  }
+
+  /**
+   * Update row(s)
+   */
+  async update(data: Partial<T>): Promise<PostgrestResponse<T>> {
+    return this.request<T>('PATCH', data);
+  }
+
+  /**
+   * Upsert row(s)
+   */
+  async upsert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>> {
+    const rows = Array.isArray(row) ? row : [row];
+    this.headers['Prefer'] = 'resolution=merge-duplicates,return=representation';
+    return this.request<T>('POST', rows.length === 1 ? rows[0] : rows);
+  }
+
+  /**
+   * Delete row(s)
+   */
+  async delete(): Promise<PostgrestResponse<T>> {
+    return this.request<T>('DELETE');
+  }
+}

package/src/errors.ts

@@ -0,0 +1,15 @@
+import { AuraBaseError } from './types';
+
+export class AuraBaseApiError extends Error implements AuraBaseError {
+  code?: string;
+  details?: string;
+  status: number;
+
+  constructor(message: string, status: number, code?: string, details?: string) {
+    super(message);
+    this.name = 'AuraBaseApiError';
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+}

package/src/index.ts

@@ -0,0 +1,72 @@
+// AuraBase JavaScript Client
+// Supabase-style SDK for AuraBase
+
+import { AuraBaseClient } from './AuraBaseClient';
+import type {
+  AuraBaseClientOptions,
+  AuthSession,
+  User,
+  AuthError,
+  PostgrestResponse,
+  AuraBaseError,
+  SignInWithPasswordCredentials,
+  SignUpCredentials,
+  UpdateUserAttributes,
+  AuthChangeEvent,
+  Subscription,
+} from './types';
+
+export type {
+  AuraBaseClientOptions,
+  AuthSession,
+  User,
+  AuthError,
+  PostgrestResponse,
+  AuraBaseError,
+  SignInWithPasswordCredentials,
+  SignUpCredentials,
+  UpdateUserAttributes,
+  AuthChangeEvent,
+  Subscription,
+};
+
+export { AuraBaseClient };
+
+/**
+ * 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'
+ * })
+ * ```
+ */
+export function createClient(options: AuraBaseClientOptions): AuraBaseClient {
+  return new AuraBaseClient(options);
+}
+
+export default createClient;

package/src/types.ts

@@ -0,0 +1,79 @@
+// Types for AuraBase SDK
+
+export interface AuraBaseClientOptions {
+  url: string;
+  anonKey: string;
+  headers?: Record<string, string>;
+}
+
+export interface AuthSession {
+  access_token: string;
+  token_type: string;
+  user: User;
+}
+
+export interface User {
+  id: number;
+  email: string;
+  username?: string;
+  role_id?: number;
+  created_at?: string;
+}
+
+export interface AuthError {
+  error: string;
+  detail?: string | Array<{ msg: string }>;
+}
+
+export interface QueryOptions {
+  select?: string;
+  filter?: Record<string, unknown>;
+  order?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface PostgrestResponse<T> {
+  data: T | T[] | null;
+  error: AuraBaseError | null;
+  status: number;
+  statusText: string;
+}
+
+export interface AuraBaseError {
+  message: string;
+  code?: string;
+  details?: string;
+}
+
+export interface AuthStateChangeEvent {
+  SIGNED_IN: 'SIGNED_IN';
+  SIGNED_OUT: 'SIGNED_OUT';
+  TOKEN_REFRESHED: 'TOKEN_REFRESHED';
+  USER_UPDATED: 'USER_UPDATED';
+}
+
+export type AuthChangeEvent = AuthStateChangeEvent[keyof AuthStateChangeEvent];
+
+export interface Subscription {
+  unsubscribe: () => void;
+}
+
+export type AuthListener = (event: AuthChangeEvent, session: AuthSession | null) => void;
+
+export interface SignInWithPasswordCredentials {
+  email: string;
+  password: string;
+}
+
+export interface SignUpCredentials {
+  email: string;
+  password: string;
+  username?: string;
+}
+
+export interface UpdateUserAttributes {
+  email?: string;
+  password?: string;
+  username?: string;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}