@giaeulate/baas-sdk 1.0.0

package/src/client.ts

@@ -0,0 +1,263 @@
+/**
+ * BaaS Client SDK
+ * A fluent JavaScript/TypeScript client for the Go BaaS.
+ * 
+ * This is the main client that composes all feature modules.
+ */
+
+import { HttpClient } from './http-client';
+import { QueryBuilder } from './query-builder';
+import { RealtimeAction, RealtimeCallback } from './types';
+
+// Module imports
+import { createAuthModule, type AuthModule } from './modules/auth';
+import { createUsersModule, type UsersModule } from './modules/users';
+import { createProjectsModule, type ProjectsModule } from './modules/projects';
+import { createDatabaseModule, type DatabaseModule } from './modules/database';
+import { createStorageModule, type StorageModule } from './modules/storage';
+import { createBackupsModule, type BackupsModule } from './modules/backups';
+import { createMigrationsModule, type MigrationsModule } from './modules/migrations';
+import { createFunctionsModule, type FunctionsModule } from './modules/functions';
+import { createJobsModule, type JobsModule } from './modules/jobs';
+import { createEnvVarsModule, type EnvVarsModule } from './modules/env-vars';
+import { createEmailModule, type EmailModule } from './modules/email';
+import { createSearchModule, type SearchModule } from './modules/search';
+import { createGraphQLModule, type GraphQLModule } from './modules/graphql';
+import { createMetricsModule, type MetricsModule } from './modules/metrics';
+import { createAuditModule, type AuditModule } from './modules/audit';
+import { createWebhooksModule, type WebhooksModule } from './modules/webhooks';
+import { createLogDrainsModule, type LogDrainsModule } from './modules/log-drains';
+import { createBranchesModule, type BranchesModule } from './modules/branches';
+import { createRealtimeModule, type RealtimeModule } from './modules/realtime';
+import { createApiKeysModule, type ApiKeysModule } from './modules/api-keys';
+
+/**
+ * Main BaaS Client - Composes all feature modules
+ * 
+ * Usage:
+ * ```ts
+ * const client = new BaasClient();
+ * 
+ * // Authentication
+ * await client.auth.login('user@example.com', 'password');
+ * 
+ * // Database operations
+ * const schemas = await client.database.getSchemas();
+ * 
+ * // Query builder (fluent API)
+ * const users = await client.from('users').select('*').limit(10).get();
+ * ```
+ */
+export class BaasClient extends HttpClient {
+  // Feature modules
+  public readonly auth: AuthModule;
+  public readonly users: UsersModule;
+  public readonly projects: ProjectsModule;
+  public readonly database: DatabaseModule;
+  public readonly storage: StorageModule;
+  public readonly backups: BackupsModule;
+  public readonly migrations: MigrationsModule;
+  public readonly functions: FunctionsModule;
+  public readonly jobs: JobsModule;
+  public readonly envVars: EnvVarsModule;
+  public readonly email: EmailModule;
+  public readonly searchService: SearchModule;
+  public readonly graphqlService: GraphQLModule;
+  public readonly metrics: MetricsModule;
+  public readonly audit: AuditModule;
+  public readonly webhooks: WebhooksModule;
+  public readonly logDrains: LogDrainsModule;
+  public readonly branches: BranchesModule;
+  public readonly realtime: RealtimeModule;
+  public readonly apiKeys: ApiKeysModule;
+
+  constructor(url?: string, projectID?: string) {
+    super(url, projectID);
+
+    // Initialize all modules with this client instance
+    this.auth = createAuthModule(this);
+    this.users = createUsersModule(this);
+    this.projects = createProjectsModule(this);
+    this.database = createDatabaseModule(this);
+    this.storage = createStorageModule(this);
+    this.backups = createBackupsModule(this);
+    this.migrations = createMigrationsModule(this);
+    this.functions = createFunctionsModule(this);
+    this.jobs = createJobsModule(this);
+    this.envVars = createEnvVarsModule(this);
+    this.email = createEmailModule(this);
+    this.searchService = createSearchModule(this);
+    this.graphqlService = createGraphQLModule(this);
+    this.metrics = createMetricsModule(this);
+    this.audit = createAuditModule(this);
+    this.webhooks = createWebhooksModule(this);
+    this.logDrains = createLogDrainsModule(this);
+    this.branches = createBranchesModule(this);
+    this.realtime = createRealtimeModule(this);
+    this.apiKeys = createApiKeysModule(this);
+  }
+
+  /**
+   * Create a query builder for fluent data queries
+   */
+  from(table: string): QueryBuilder {
+    return new QueryBuilder(table, this.url, this);
+  }
+
+  // ============================================
+  // BACKWARD COMPATIBILITY METHODS
+  // These delegate to the appropriate modules
+  // ============================================
+
+  // Auth shortcuts
+  async login(email: string, password: string) { return this.auth.login(email, password); }
+  async verifyMFA(mfaToken: string, code: string) { return this.auth.verifyMFA(mfaToken, code); }
+  async getProfile() { return this.auth.getProfile(); }
+  async register(email: string, password: string) { return this.auth.register(email, password); }
+  async forgotPassword(email: string) { return this.auth.forgotPassword(email); }
+  async resetPassword(token: string, newPassword: string) { return this.auth.resetPassword(token, newPassword); }
+  async validateResetToken(token: string) { return this.auth.validateResetToken(token); }
+  async verifyEmail(token: string) { return this.auth.verifyEmail(token); }
+  async requestEmailVerification() { return this.auth.requestEmailVerification(); }
+  async getAuthProviders() { return this.auth.getAuthProviders(); }
+  async getAuthProvider(provider: string) { return this.auth.getAuthProvider(provider); }
+  async configureAuthProvider(provider: string, clientID: string, clientSecret: string, enabled: boolean) { 
+    return this.auth.configureAuthProvider(provider, clientID, clientSecret, enabled); 
+  }
+
+  // Users shortcuts
+  async listUsers(limit = 20, offset = 0) { return this.users.list(limit, offset); }
+  async updateUser(id: string, updates: any) { return this.users.update(id, updates); }
+  async deleteUser(id: string) { return this.users.delete(id); }
+
+  // Projects shortcuts
+  async listProjects() { return this.projects.list(); }
+  async createProject(name: string) { return this.projects.create(name); }
+
+  // Database shortcuts
+  async raw(query: string) { return this.database.raw(query); }
+  async getSchemas(options?: any) { return this.database.getSchemas(options); }
+  async getSchema(name: string) { return this.database.getSchema(name); }
+  async createTable(tableName: string, definition: any) { return this.database.createTable(tableName, definition); }
+  async dropTable(tableName: string) { return this.database.dropTable(tableName); }
+  async renameTable(tableName: string, newName: string) { return this.database.renameTable(tableName, newName); }
+  async addColumn(tableName: string, column: any) { return this.database.addColumn(tableName, column); }
+  async dropColumn(tableName: string, columnName: string) { return this.database.dropColumn(tableName, columnName); }
+  async modifyColumn(tableName: string, columnName: string, changes: any) { return this.database.modifyColumn(tableName, columnName, changes); }
+  async renameColumn(tableName: string, columnName: string, newName: string) { return this.database.renameColumn(tableName, columnName, newName); }
+  async setColumnDefault(tableName: string, columnName: string, defaultValue: string | null) { return this.database.setColumnDefault(tableName, columnName, defaultValue); }
+  async addForeignKey(tableName: string, fk: any) { return this.database.addForeignKey(tableName, fk); }
+  async listForeignKeys(tableName: string) { return this.database.listForeignKeys(tableName); }
+  async dropForeignKey(tableName: string, constraintName: string) { return this.database.dropForeignKey(tableName, constraintName); }
+  async addUniqueConstraint(tableName: string, columnName: string) { return this.database.addUniqueConstraint(tableName, columnName); }
+  async dropConstraint(tableName: string, constraintName: string) { return this.database.dropConstraint(tableName, constraintName); }
+  async queryData(tableName: string, options: any) { return this.database.queryData(tableName, options); }
+  async downloadExport(tableName: string, format: 'sql' | 'csv' | 'backup', filters?: any[]) { return this.database.downloadExport(tableName, format, filters); }
+
+  // Storage shortcuts
+  async upload(table: string, file: File) { return this.storage.upload(table, file); }
+
+  // Functions shortcuts
+  async invokeFunction(id: string, data?: any) { return this.functions.invoke(id, data); }
+
+  // API Keys shortcuts
+  async createApiKey(name: string, permissions?: string[], expiresAt?: string) { return this.apiKeys.create(name, permissions, expiresAt); }
+  async listApiKeys() { return this.apiKeys.list(); }
+  async revokeApiKey(keyId: string) { return this.apiKeys.revoke(keyId); }
+  async deleteApiKey(keyId: string) { return this.apiKeys.delete(keyId); }
+
+  // Backups shortcuts
+  async createBackup(options?: any) { return this.backups.create(options); }
+  async listBackups() { return this.backups.list(); }
+  async getBackup(backupId: string) { return this.backups.get(backupId); }
+  async restoreBackup(backupId: string) { return this.backups.restore(backupId); }
+  async deleteBackup(backupId: string) { return this.backups.delete(backupId); }
+  getBackupDownloadUrl(backupId: string) { return this.backups.getDownloadUrl(backupId); }
+  async listBackupTables() { return this.backups.listTables(); }
+  async importFile(formData: FormData) { return this.backups.importFile(formData); }
+
+  // Search shortcuts
+  async search(query: string, options?: any) { return this.searchService.search(query, options); }
+  async createSearchIndex(table: string, columns: string[]) { return this.searchService.createIndex(table, columns); }
+
+  // GraphQL shortcuts
+  async graphql(query: string, variables?: Record<string, any>) { return this.graphqlService.query(query, variables); }
+  getGraphQLPlaygroundUrl() { return this.graphqlService.getPlaygroundUrl(); }
+
+  // Migrations shortcuts
+  async createMigration(input: any) { return this.migrations.create(input); }
+  async listMigrations() { return this.migrations.list(); }
+  async getMigration(id: string) { return this.migrations.get(id); }
+  async applyMigration(id: string) { return this.migrations.apply(id); }
+  async rollbackMigration(id: string) { return this.migrations.rollback(id); }
+  async deleteMigration(id: string) { return this.migrations.delete(id); }
+  async generateMigration(tableName: string, changes: any[]) { return this.migrations.generate(tableName, changes); }
+
+  // Email shortcuts
+  async sendEmail(input: any) { return this.email.send(input); }
+  async getEmailConfig() { return this.email.getConfig(); }
+  async saveEmailConfig(config: any) { return this.email.saveConfig(config); }
+  async createEmailTemplate(template: any) { return this.email.createTemplate(template); }
+  async listEmailTemplates() { return this.email.listTemplates(); }
+  async getEmailTemplate(id: string) { return this.email.getTemplate(id); }
+  async updateEmailTemplate(id: string, template: any) { return this.email.updateTemplate(id, template); }
+  async deleteEmailTemplate(id: string) { return this.email.deleteTemplate(id); }
+  async getEmailLogs(options?: any) { return this.email.getLogs(options); }
+
+  // Metrics shortcuts
+  async getDashboardStats() { return this.metrics.getDashboardStats(); }
+  async getRequestLogs(options?: any) { return this.metrics.getRequestLogs(options); }
+  async getApplicationLogs(options?: any) { return this.metrics.getApplicationLogs(options); }
+  async getMetricTimeseries(metric: string, options?: any) { return this.metrics.getTimeseries(metric, options); }
+
+  // Jobs shortcuts
+  async createJob(input: any) { return this.jobs.create(input); }
+  async listJobs() { return this.jobs.list(); }
+  async getJob(id: string) { return this.jobs.get(id); }
+  async updateJob(id: string, input: any) { return this.jobs.update(id, input); }
+  async deleteJob(id: string) { return this.jobs.delete(id); }
+  async toggleJob(id: string, enabled: boolean) { return this.jobs.toggle(id, enabled); }
+  async runJobNow(id: string) { return this.jobs.runNow(id); }
+  async getJobExecutions(id: string, limit?: number) { return this.jobs.getExecutions(id, limit); }
+
+  // Env Vars shortcuts
+  async createEnvVar(input: any) { return this.envVars.create(input); }
+  async listEnvVars() { return this.envVars.list(); }
+  async getEnvVar(id: string) { return this.envVars.get(id); }
+  async updateEnvVar(id: string, value: string) { return this.envVars.update(id, value); }
+  async deleteEnvVar(id: string) { return this.envVars.delete(id); }
+
+  // Branches shortcuts
+  async createBranch(input: any) { return this.branches.create(input); }
+  async listBranches() { return this.branches.list(); }
+  async getBranch(id: string) { return this.branches.get(id); }
+  async deleteBranch(id: string) { return this.branches.delete(id); }
+  async mergeBranch(id: string, targetBranchId: string) { return this.branches.merge(id, targetBranchId); }
+  async resetBranch(id: string) { return this.branches.reset(id); }
+
+  // Log Drains shortcuts
+  async createLogDrain(input: any) { return this.logDrains.create(input); }
+  async listLogDrains() { return this.logDrains.list(); }
+  async getLogDrain(id: string) { return this.logDrains.get(id); }
+  async updateLogDrain(id: string, input: any) { return this.logDrains.update(id, input); }
+  async deleteLogDrain(id: string) { return this.logDrains.delete(id); }
+  async toggleLogDrain(id: string, enabled: boolean) { return this.logDrains.toggle(id, enabled); }
+  async testLogDrain(id: string) { return this.logDrains.test(id); }
+
+  // Webhooks shortcuts
+  async listWebhooks() { return this.webhooks.list(); }
+  async getWebhook(id: string) { return this.webhooks.get(id); }
+  async createWebhook(input: any) { return this.webhooks.create(input); }
+  async updateWebhook(id: string, input: any) { return this.webhooks.update(id, input); }
+  async deleteWebhook(id: string) { return this.webhooks.delete(id); }
+  async testWebhook(id: string) { return this.webhooks.test(id); }
+
+  // Audit shortcuts
+  async listAuditLogs(options?: any) { return this.audit.list(options); }
+  async getAuditActions() { return this.audit.getActions(); }
+
+  // Realtime shortcuts
+  subscribe<T = any>(table: string, action: RealtimeAction, callback: RealtimeCallback<T>) { 
+    return this.realtime.subscribe<T>(table, action, callback); 
+  }
+}

package/src/http-client.ts

@@ -0,0 +1,144 @@
+/**
+ * Core HTTP Client
+ * Base class providing HTTP request infrastructure for all SDK modules
+ */
+
+import type { RequestOptions } from './types';
+
+export class HttpClient {
+  public url: string;
+  public projectID: string = '';
+  public token: string | null = null;
+
+  constructor(url?: string, projectID?: string) {
+    let baseUrl = url || (typeof window !== 'undefined' ? window.location.origin : 'http://localhost:8080');
+    this.url = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    
+    if (projectID) this.projectID = projectID;
+    
+    this.token = this.cleanValue(localStorage.getItem('baas_token'));
+    const storedProject = this.cleanValue(localStorage.getItem('baas_project_id'));
+    if (storedProject && !this.projectID) {
+      this.projectID = storedProject;
+    }
+  }
+
+  protected cleanValue(val: string | null): string | null {
+    if (!val || val === 'null' || val === 'undefined') return null;
+    return val.trim();
+  }
+
+  /**
+   * Public header generator for adapters
+   */
+  public getHeaders(contentType: string = 'application/json') {
+    const dynamicProject = this.getDynamicProjectID();
+    const dynamicToken = this.getDynamicToken();
+    
+    const headers: Record<string, string> = {
+      'X-Project-ID': dynamicProject,
+    };
+    
+    if (contentType) {
+      headers['Content-Type'] = contentType;
+    }
+
+    if (dynamicToken) {
+      headers['Authorization'] = `Bearer ${dynamicToken}`;
+    }
+    return headers;
+  }
+
+  public getDynamicToken() {
+    return this.cleanValue(this.token || localStorage.getItem('baas_token'));
+  }
+
+  public getDynamicProjectID() {
+    const stored = this.cleanValue(localStorage.getItem('baas_project_id'));
+    if (this.projectID && this.projectID !== 'default' && this.projectID !== '') {
+      return this.projectID;
+    }
+    return stored || 'default';
+  }
+
+  /**
+   * Core HTTP request method - DRY principle
+   */
+  protected async request<T = any>(endpoint: string, options: RequestOptions = {}): Promise<T> {
+    const { method = 'GET', body, headers: customHeaders, skipAuth = false } = options;
+    
+    const headers = { ...this.getHeaders(), ...customHeaders };
+    
+    const fetchOptions: RequestInit = {
+      method,
+      headers,
+    };
+    
+    if (body !== undefined) {
+      fetchOptions.body = JSON.stringify(body);
+    }
+    
+    const res = await fetch(`${this.url}${endpoint}`, fetchOptions);
+    
+    if (res.status === 204) {
+      return { success: true } as T;
+    }
+    
+    const data = await res.json().catch(() => null);
+    
+    if (!res.ok) {
+      if (res.status === 401 && !skipAuth) {
+        this.forceLogout();
+      }
+      if (res.status === 403 && data?.error === 'ip_not_allowed') {
+        this.handleIPBlocked(data.ip);
+      }
+      return { error: data?.error || `Request failed: ${res.status}`, ...data } as T;
+    }
+    
+    return data;
+  }
+
+  protected get<T = any>(endpoint: string): Promise<T> {
+    return this.request<T>(endpoint);
+  }
+
+  protected post<T = any>(endpoint: string, body?: unknown): Promise<T> {
+    return this.request<T>(endpoint, { method: 'POST', body });
+  }
+
+  protected put<T = any>(endpoint: string, body?: unknown): Promise<T> {
+    return this.request<T>(endpoint, { method: 'PUT', body });
+  }
+
+  protected patch<T = any>(endpoint: string, body?: unknown): Promise<T> {
+    return this.request<T>(endpoint, { method: 'PATCH', body });
+  }
+
+  protected delete<T = any>(endpoint: string): Promise<T> {
+    return this.request<T>(endpoint, { method: 'DELETE' });
+  }
+
+  logout() {
+    this.token = null;
+    localStorage.removeItem('baas_token');
+  }
+
+  forceLogout() {
+    this.logout();
+    if (typeof window !== 'undefined') {
+      if (!window.location.search.includes('expired')) {
+        window.location.href = '/auth/login?reason=expired';
+      }
+    }
+  }
+
+  handleIPBlocked(ip?: string) {
+    if (typeof window !== 'undefined') {
+      const params = ip ? `?ip=${encodeURIComponent(ip)}` : '';
+      if (!window.location.pathname.includes('/blocked')) {
+        window.location.href = `/blocked${params}`;
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+/**
+ * BaaS SDK - Main Entry Point
+ * 
+ * Re-exports all SDK components for easy importing:
+ * 
+ * ```ts
+ * import { BaasClient } from '@/sdk';
+ * // or
+ * import { BaasClient, QueryFilter } from '@/sdk';
+ * ```
+ */
+
+// Main client
+export { BaasClient } from './client';
+
+// Core utilities
+export { HttpClient } from './http-client';
+export { QueryBuilder } from './query-builder';
+
+// Types
+export type { QueryFilter, HttpMethod, RequestOptions, PaginationOptions, ApiResponse } from './types';
+
+// Module types (for advanced usage)
+export type { AuthModule } from './modules/auth';
+export type { UsersModule } from './modules/users';
+export type { ProjectsModule } from './modules/projects';
+export type { DatabaseModule } from './modules/database';
+export type { StorageModule } from './modules/storage';
+export type { BackupsModule } from './modules/backups';
+export type { MigrationsModule } from './modules/migrations';
+export type { FunctionsModule } from './modules/functions';
+export type { JobsModule, JobInput, JobUpdateInput } from './modules/jobs';
+export type { EnvVarsModule } from './modules/env-vars';
+export type { EmailModule, EmailConfig, EmailTemplate, SendEmailInput } from './modules/email';
+export type { SearchModule, SearchOptions } from './modules/search';
+export type { GraphQLModule } from './modules/graphql';
+export type { MetricsModule, RequestLogsOptions, ApplicationLogsOptions, TimeseriesOptions } from './modules/metrics';
+export type { AuditModule, AuditLogsOptions } from './modules/audit';
+export type { WebhooksModule, WebhookInput, WebhookUpdateInput } from './modules/webhooks';
+export type { LogDrainsModule, LogDrainInput, LogDrainUpdateInput } from './modules/log-drains';
+export type { BranchesModule } from './modules/branches';
+export type { RealtimeModule, Subscription } from './modules/realtime';
+export type { ApiKeysModule } from './modules/api-keys';

package/src/modules/api-keys.ts

@@ -0,0 +1,36 @@
+/**
+ * API Keys Module
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface ApiKeysModule {
+  create(name: string, permissions?: string[], expiresAt?: string): Promise<any>;
+  list(): Promise<any>;
+  revoke(keyId: string): Promise<any>;
+  delete(keyId: string): Promise<any>;
+}
+
+export function createApiKeysModule(client: HttpClient): ApiKeysModule {
+  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(name: string, permissions?: string[], expiresAt?: string) {
+      return post('/api/api-keys', { name, permissions, expires_at: expiresAt });
+    },
+
+    async list() {
+      return get('/api/api-keys');
+    },
+
+    async revoke(keyId: string) {
+      return post(`/api/api-keys/${keyId}/revoke`, {});
+    },
+
+    async delete(keyId: string) {
+      return del(`/api/api-keys/${keyId}`);
+    },
+  };
+}

package/src/modules/audit.ts

@@ -0,0 +1,46 @@
+/**
+ * Audit Module - Audit log operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface AuditLogsOptions {
+  limit?: number;
+  offset?: number;
+  action?: string;
+  user_id?: string;
+  method?: string;
+  path?: string;
+  status_code?: number;
+  start_date?: string;
+  end_date?: string;
+}
+
+export interface AuditModule {
+  list(options?: AuditLogsOptions): Promise<any>;
+  getActions(): Promise<any>;
+}
+
+export function createAuditModule(client: HttpClient): AuditModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+
+  return {
+    async list(options?: AuditLogsOptions) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set('limit', options.limit.toString());
+      if (options?.offset) params.set('offset', options.offset.toString());
+      if (options?.action) params.set('action', options.action);
+      if (options?.user_id) params.set('user_id', options.user_id);
+      if (options?.method) params.set('method', options.method);
+      if (options?.path) params.set('path', options.path);
+      if (options?.status_code) params.set('status_code', options.status_code.toString());
+      if (options?.start_date) params.set('start_date', options.start_date);
+      if (options?.end_date) params.set('end_date', options.end_date);
+      return get(`/api/audit/logs?${params.toString()}`);
+    },
+
+    async getActions() {
+      return get('/api/audit/actions');
+    },
+  };
+}