@giaeulate/baas-sdk 1.0.0

package/src/modules/jobs.ts

@@ -0,0 +1,78 @@
+/**
+ * Jobs Module - Scheduled jobs (CRON) operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface JobInput {
+  name: string;
+  schedule: string;
+  function_id: string;
+  description?: string;
+  payload?: Record<string, any>;
+  timezone?: string;
+}
+
+export interface JobUpdateInput {
+  name?: string;
+  schedule?: string;
+  function_id?: string;
+  description?: string;
+  payload?: Record<string, any>;
+  timezone?: string;
+  enabled?: boolean;
+}
+
+export interface JobsModule {
+  create(input: JobInput): Promise<any>;
+  list(): Promise<any>;
+  get(id: string): Promise<any>;
+  update(id: string, input: JobUpdateInput): Promise<any>;
+  delete(id: string): Promise<any>;
+  toggle(id: string, enabled: boolean): Promise<any>;
+  runNow(id: string): Promise<any>;
+  getExecutions(id: string, limit?: number): Promise<any>;
+}
+
+export function createJobsModule(client: HttpClient): JobsModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+  const put = (endpoint: string, body?: unknown) => (client as any).put(endpoint, body);
+  const del = (endpoint: string) => (client as any).delete(endpoint);
+
+  return {
+    async create(input: JobInput) {
+      return post('/api/jobs', input);
+    },
+
+    async list() {
+      return get('/api/jobs');
+    },
+
+    async get(id: string) {
+      return get(`/api/jobs/${id}`);
+    },
+
+    async update(id: string, input: JobUpdateInput) {
+      return put(`/api/jobs/${id}`, input);
+    },
+
+    async delete(id: string) {
+      return del(`/api/jobs/${id}`);
+    },
+
+    async toggle(id: string, enabled: boolean) {
+      return post(`/api/jobs/${id}/toggle`, { enabled });
+    },
+
+    async runNow(id: string) {
+      return post(`/api/jobs/${id}/run`);
+    },
+
+    async getExecutions(id: string, limit?: number) {
+      const params = new URLSearchParams();
+      if (limit) params.set('limit', limit.toString());
+      return get(`/api/jobs/${id}/executions?${params.toString()}`);
+    },
+  };
+}

package/src/modules/log-drains.ts

@@ -0,0 +1,76 @@
+/**
+ * Log Drains Module
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface LogDrainInput {
+  name: string;
+  type: string;
+  url: string;
+  token?: string;
+  headers?: Record<string, string>;
+  filters?: {
+    levels?: string[];
+    sources?: string[];
+  };
+}
+
+export interface LogDrainUpdateInput {
+  name?: string;
+  url?: string;
+  token?: string;
+  headers?: Record<string, string>;
+  filters?: {
+    levels?: string[];
+    sources?: string[];
+  };
+  enabled?: boolean;
+}
+
+export interface LogDrainsModule {
+  create(input: LogDrainInput): Promise<any>;
+  list(): Promise<any>;
+  get(id: string): Promise<any>;
+  update(id: string, input: LogDrainUpdateInput): Promise<any>;
+  delete(id: string): Promise<any>;
+  toggle(id: string, enabled: boolean): Promise<any>;
+  test(id: string): Promise<any>;
+}
+
+export function createLogDrainsModule(client: HttpClient): LogDrainsModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+  const put = (endpoint: string, body?: unknown) => (client as any).put(endpoint, body);
+  const del = (endpoint: string) => (client as any).delete(endpoint);
+
+  return {
+    async create(input: LogDrainInput) {
+      return post('/api/log-drains', input);
+    },
+
+    async list() {
+      return get('/api/log-drains');
+    },
+
+    async get(id: string) {
+      return get(`/api/log-drains/${id}`);
+    },
+
+    async update(id: string, input: LogDrainUpdateInput) {
+      return put(`/api/log-drains/${id}`, input);
+    },
+
+    async delete(id: string) {
+      return del(`/api/log-drains/${id}`);
+    },
+
+    async toggle(id: string, enabled: boolean) {
+      return post(`/api/log-drains/${id}/toggle`, { enabled });
+    },
+
+    async test(id: string) {
+      return post(`/api/log-drains/${id}/test`);
+    },
+  };
+}

package/src/modules/metrics.ts

@@ -0,0 +1,72 @@
+/**
+ * Metrics Module - Monitoring and metrics operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface RequestLogsOptions {
+  limit?: number;
+  offset?: number;
+  method?: string;
+  status?: string;
+  path?: string;
+}
+
+export interface ApplicationLogsOptions {
+  limit?: number;
+  offset?: number;
+  level?: string;
+  source?: string;
+  search?: string;
+}
+
+export interface TimeseriesOptions {
+  interval?: string;
+  start?: string;
+  end?: string;
+}
+
+export interface MetricsModule {
+  getDashboardStats(): Promise<any>;
+  getRequestLogs(options?: RequestLogsOptions): Promise<any>;
+  getApplicationLogs(options?: ApplicationLogsOptions): Promise<any>;
+  getTimeseries(metric: string, options?: TimeseriesOptions): Promise<any>;
+}
+
+export function createMetricsModule(client: HttpClient): MetricsModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+
+  return {
+    async getDashboardStats() {
+      return get('/api/metrics/dashboard');
+    },
+
+    async getRequestLogs(options?: RequestLogsOptions) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set('limit', options.limit.toString());
+      if (options?.offset) params.set('offset', options.offset.toString());
+      if (options?.method) params.set('method', options.method);
+      if (options?.status) params.set('status', options.status);
+      if (options?.path) params.set('path', options.path);
+      return get(`/api/metrics/requests?${params.toString()}`);
+    },
+
+    async getApplicationLogs(options?: ApplicationLogsOptions) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set('limit', options.limit.toString());
+      if (options?.offset) params.set('offset', options.offset.toString());
+      if (options?.level) params.set('level', options.level);
+      if (options?.source) params.set('source', options.source);
+      if (options?.search) params.set('search', options.search);
+      return get(`/api/metrics/logs?${params.toString()}`);
+    },
+
+    async getTimeseries(metric: string, options?: TimeseriesOptions) {
+      const params = new URLSearchParams({ metric });
+      if (options?.interval) params.set('interval', options.interval);
+      if (options?.start) params.set('start', options.start);
+      if (options?.end) params.set('end', options.end);
+      return get(`/api/metrics/timeseries?${params.toString()}`);
+    },
+  };
+}

package/src/modules/migrations.ts

@@ -0,0 +1,51 @@
+/**
+ * Migrations Module - Database migration operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface MigrationsModule {
+  create(input: { name: string; description?: string; up_sql: string; down_sql?: string }): Promise<any>;
+  list(): Promise<any>;
+  get(id: string): Promise<any>;
+  apply(id: string): Promise<any>;
+  rollback(id: string): Promise<any>;
+  delete(id: string): Promise<any>;
+  generate(tableName: string, changes: any[]): Promise<any>;
+}
+
+export function createMigrationsModule(client: HttpClient): MigrationsModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+  const del = (endpoint: string) => (client as any).delete(endpoint);
+
+  return {
+    async create(input: { name: string; description?: string; up_sql: string; down_sql?: string }) {
+      return post('/api/migrations', input);
+    },
+
+    async list() {
+      return get('/api/migrations');
+    },
+
+    async get(id: string) {
+      return get(`/api/migrations/${id}`);
+    },
+
+    async apply(id: string) {
+      return post(`/api/migrations/${id}/apply`, {});
+    },
+
+    async rollback(id: string) {
+      return post(`/api/migrations/${id}/rollback`, {});
+    },
+
+    async delete(id: string) {
+      return del(`/api/migrations/${id}`);
+    },
+
+    async generate(tableName: string, changes: any[]) {
+      return post('/api/migrations/generate', { table_name: tableName, changes });
+    },
+  };
+}

package/src/modules/projects.ts

@@ -0,0 +1,25 @@
+/**
+ * Projects Module - Project management operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface ProjectsModule {
+  list(): Promise<any>;
+  create(name: string): Promise<any>;
+}
+
+export function createProjectsModule(client: HttpClient): ProjectsModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+
+  return {
+    async list() {
+      return get('/api/projects');
+    },
+
+    async create(name: string) {
+      return post('/api/projects', { name });
+    },
+  };
+}

package/src/modules/realtime.ts

@@ -0,0 +1,30 @@
+/**
+ * Realtime Module - WebSocket subscriptions
+ */
+
+import type { HttpClient } from '../http-client';
+import { RealtimeService } from '../realtime';
+import { RealtimeAction, RealtimeCallback } from '../types';
+
+export interface Subscription {
+  unsubscribe: () => void;
+}
+
+export interface RealtimeModule {
+  subscribe<T = any>(table: string, action: RealtimeAction, callback: RealtimeCallback<T>): Promise<Subscription>;
+}
+
+export function createRealtimeModule(client: HttpClient): RealtimeModule {
+  const service = new RealtimeService(
+    client.url,
+    client.getDynamicProjectID(),
+    () => client.getDynamicToken(),
+    typeof WebSocket !== 'undefined' ? WebSocket : undefined
+  );
+
+  return {
+    async subscribe<T = any>(table: string, action: RealtimeAction, callback: RealtimeCallback<T>): Promise<Subscription> {
+      return service.subscribe(table, action, callback);
+    },
+  };
+}

package/src/modules/search.ts

@@ -0,0 +1,37 @@
+/**
+ * Search Module - Full-text search operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface SearchOptions {
+  tables?: string[];
+  columns?: string[];
+  limit?: number;
+  offset?: number;
+}
+
+export interface SearchModule {
+  search(query: string, options?: SearchOptions): Promise<any>;
+  createIndex(table: string, columns: string[]): Promise<any>;
+}
+
+export function createSearchModule(client: HttpClient): SearchModule {
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+
+  return {
+    async search(query: string, options?: SearchOptions) {
+      return post('/api/search', {
+        query,
+        tables: options?.tables,
+        columns: options?.columns,
+        limit: options?.limit,
+        offset: options?.offset,
+      });
+    },
+
+    async createIndex(table: string, columns: string[]) {
+      return post('/api/search/index', { table, columns });
+    },
+  };
+}

package/src/modules/storage.ts

@@ -0,0 +1,27 @@
+/**
+ * Storage Module - File storage operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface StorageModule {
+  upload(table: string, file: File): Promise<any>;
+}
+
+export function createStorageModule(client: HttpClient): StorageModule {
+  return {
+    async upload(_table: string, file: File) {
+      const formData = new FormData();
+      formData.append('file', file);
+
+      const res = await fetch(`${client.url}/api/storage/upload`, {
+        method: 'POST',
+        headers: client.getHeaders(''),
+        body: formData
+      });
+      const data = await res.json();
+      if (!res.ok && res.status === 401) client.forceLogout();
+      return data;
+    },
+  };
+}

package/src/modules/users.ts

@@ -0,0 +1,31 @@
+/**
+ * Users Module - User management operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface UsersModule {
+  list(limit?: number, offset?: number): Promise<any>;
+  update(id: string, updates: { email?: string; role?: string; email_verified?: boolean }): Promise<any>;
+  delete(id: string): Promise<any>;
+}
+
+export function createUsersModule(client: HttpClient): UsersModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const put = (endpoint: string, body?: unknown) => (client as any).put(endpoint, body);
+  const del = (endpoint: string) => (client as any).delete(endpoint);
+
+  return {
+    async list(limit = 20, offset = 0) {
+      return get(`/api/users?limit=${limit}&offset=${offset}`);
+    },
+
+    async update(id: string, updates: { email?: string; role?: string; email_verified?: boolean }) {
+      return put(`/api/users/${id}`, updates);
+    },
+
+    async delete(id: string) {
+      return del(`/api/users/${id}`);
+    },
+  };
+}

package/src/modules/webhooks.ts

@@ -0,0 +1,58 @@
+/**
+ * Webhooks Module
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface WebhookInput {
+  url: string;
+  event_types: string[];
+}
+
+export interface WebhookUpdateInput {
+  url: string;
+  event_types: string[];
+  is_active: boolean;
+}
+
+export interface WebhooksModule {
+  list(): Promise<any>;
+  get(id: string): Promise<any>;
+  create(input: WebhookInput): Promise<any>;
+  update(id: string, input: WebhookUpdateInput): Promise<any>;
+  delete(id: string): Promise<any>;
+  test(id: string): Promise<any>;
+}
+
+export function createWebhooksModule(client: HttpClient): WebhooksModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+  const put = (endpoint: string, body?: unknown) => (client as any).put(endpoint, body);
+  const del = (endpoint: string) => (client as any).delete(endpoint);
+
+  return {
+    async list() {
+      return get('/api/webhooks');
+    },
+
+    async get(id: string) {
+      return get(`/api/webhooks/${id}`);
+    },
+
+    async create(input: WebhookInput) {
+      return post('/api/webhooks', input);
+    },
+
+    async update(id: string, input: WebhookUpdateInput) {
+      return put(`/api/webhooks/${id}`, input);
+    },
+
+    async delete(id: string) {
+      return del(`/api/webhooks/${id}`);
+    },
+
+    async test(id: string) {
+      return post(`/api/webhooks/${id}/test`);
+    },
+  };
+}

package/src/query-builder.ts

@@ -0,0 +1,157 @@
+/**
+ * QueryBuilder - Fluent API for data queries
+ */
+
+import type { HttpClient } from './http-client';
+import type { QueryFilter } from './types';
+
+export class QueryBuilder {
+  private table: string;
+  private url: string;
+  private client: HttpClient;
+  private queryParams: URLSearchParams = new URLSearchParams();
+  // @ts-ignore - used for future filter improvements
+  private filters: QueryFilter[] = [];
+
+  constructor(table: string, url: string, client: HttpClient) {
+    this.table = table;
+    this.url = url;
+    this.client = client;
+  }
+
+  select(columns: string = '*') {
+    this.queryParams.set('select', columns);
+    return this;
+  }
+
+  eq(column: string, value: any) {
+    this.queryParams.set(column, `eq.${value}`);
+    return this;
+  }
+
+  neq(column: string, value: any) {
+    this.queryParams.set(column, `neq.${value}`);
+    return this;
+  }
+
+  gt(column: string, value: any) {
+    this.queryParams.set(column, `gt.${value}`);
+    return this;
+  }
+
+  gte(column: string, value: any) {
+    this.queryParams.set(column, `gte.${value}`);
+    return this;
+  }
+
+  lt(column: string, value: any) {
+    this.queryParams.set(column, `lt.${value}`);
+    return this;
+  }
+
+  lte(column: string, value: any) {
+    this.queryParams.set(column, `lte.${value}`);
+    return this;
+  }
+
+  like(column: string, value: any) {
+    this.queryParams.set(column, `like.${value}`);
+    return this;
+  }
+
+  ilike(column: string, value: any) {
+    this.queryParams.set(column, `ilike.${value}`);
+    return this;
+  }
+
+  is(column: string, value: any) {
+    this.queryParams.set(column, `is.${value}`);
+    return this;
+  }
+
+  in(column: string, values: any[]) {
+    this.queryParams.set(column, `in.(${values.join(',')})`);
+    return this;
+  }
+
+  not(column: string, operator: string, value: any) {
+    this.queryParams.set(column, `not.${operator}.${value}`);
+    return this;
+  }
+
+  or(filters: string) {
+    this.queryParams.set('or', `(${filters})`);
+    return this;
+  }
+
+  order(column: string, { ascending = true } = {}) {
+    this.queryParams.set('order', `${column}.${ascending ? 'asc' : 'desc'}`);
+    return this;
+  }
+
+  limit(count: number) {
+    this.queryParams.set('limit', count.toString());
+    return this;
+  }
+
+  offset(count: number) {
+    this.queryParams.set('offset', count.toString());
+    return this;
+  }
+
+  async get() {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}?${this.queryParams.toString()}`, {
+      headers: this.getHeaders(),
+    });
+    return await this.handleResponse(res);
+  }
+
+  async insert(data: any) {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}`, {
+      method: 'POST',
+      headers: this.getHeaders(),
+      body: JSON.stringify(data),
+    });
+    return await this.handleResponse(res);
+  }
+
+  async update(id: string | number, data: any) {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}/${id}`, {
+      method: 'PATCH',
+      headers: this.getHeaders(),
+      body: JSON.stringify(data),
+    });
+    return await this.handleResponse(res);
+  }
+
+  async delete(id: string | number) {
+    const res = await fetch(`${this.url}/api/v1/data/${this.table}/${id}`, {
+      method: 'DELETE',
+      headers: this.getHeaders(),
+    });
+    if (res.status === 204) return { success: true };
+    return await this.handleResponse(res);
+  }
+
+  private getHeaders() {
+    return this.client.getHeaders();
+  }
+
+  private async handleResponse(res: Response) {
+    const text = await res.text();
+    let data = null;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+      // Silently fail parsing
+    }
+    
+    if (!res.ok) {
+      if (res.status === 401) {
+        this.client.forceLogout();
+      }
+      return { data: null, error: data?.error || 'Request failed', status: res.status };
+    }
+    return { data, error: null, status: res.status };
+  }
+}