@giaeulate/baas-sdk 1.0.0

package/src/modules/auth.ts

@@ -0,0 +1,158 @@
+/**
+ * Auth Module - Authentication operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface MFASetupResponse {
+  secret: string;
+  qr_code_url: string;
+  recovery_codes: string[];
+}
+
+export interface AuthModule {
+  login(email: string, password: string): Promise<any>;
+  logout(): Promise<void>;
+  verifyMFA(mfaToken: string, code: string): Promise<any>;
+  verifyMFAWithRecoveryCode(mfaToken: string, recoveryCode: string): Promise<any>;
+  setupMFA(): Promise<MFASetupResponse>;
+  enableMFA(secret: string, code: string, recoveryCodes?: string[]): Promise<any>;
+  disableMFA(code: string): Promise<any>;
+  getProfile(): Promise<any>;
+  register(email: string, password: string): Promise<any>;
+  forgotPassword(email: string): Promise<any>;
+  resetPassword(token: string, newPassword: string): Promise<any>;
+  validateResetToken(token: string): Promise<any>;
+  verifyEmail(token: string): Promise<any>;
+  requestEmailVerification(): Promise<any>;
+  // OAuth Configuration
+  getAuthProviders(): Promise<any>;
+  getAuthProvider(provider: string): Promise<any>;
+  configureAuthProvider(provider: string, clientID: string, clientSecret: string, enabled: boolean): Promise<any>;
+}
+
+export function createAuthModule(client: HttpClient): AuthModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+
+  return {
+    async login(email: string, password: string) {
+      const res = await fetch(`${client.url}/api/login`, {
+        method: 'POST',
+        headers: client.getHeaders(),
+        body: JSON.stringify({ email, password }),
+      });
+
+      const contentType = res.headers.get('content-type');
+      if (!contentType?.includes('application/json')) {
+        throw new Error(`Login failed: Server returned ${res.status}. Please check your connection.`);
+      }
+
+      const data = await res.json().catch(() => {
+        throw new Error(`Login failed: Invalid JSON response (status ${res.status})`);
+      });
+
+      if (!res.ok) {
+        throw new Error(data?.error || `Login failed: ${res.status}`);
+      }
+
+      if (data.token) {
+        client.token = data.token;
+        localStorage.setItem('baas_token', data.token);
+      }
+      return data;
+    },
+
+    async logout() {
+      try {
+        await post('/api/logout');
+      } finally {
+        client.token = null;
+        localStorage.removeItem('baas_token');
+      }
+    },
+
+    async verifyMFA(mfaToken: string, code: string) {
+      const data = await post('/api/mfa/finalize', { mfa_token: mfaToken, code });
+      if (data.token) {
+        client.token = data.token;
+        localStorage.setItem('baas_token', data.token);
+      }
+      return data;
+    },
+
+    async verifyMFAWithRecoveryCode(mfaToken: string, recoveryCode: string) {
+      const data = await post('/api/mfa/finalize', { mfa_token: mfaToken, recovery_code: recoveryCode });
+      if (data.token) {
+        client.token = data.token;
+        localStorage.setItem('baas_token', data.token);
+      }
+      return data;
+    },
+
+    async setupMFA(): Promise<MFASetupResponse> {
+      return post('/api/mfa/setup');
+    },
+
+    async enableMFA(secret: string, code: string, recoveryCodes?: string[]) {
+      const body: any = { secret, code };
+      if (recoveryCodes) {
+        body.recovery_codes = recoveryCodes;
+      }
+      return post('/api/mfa/enable', body);
+    },
+
+    async disableMFA(code: string) {
+      return post('/api/mfa/disable', { code });
+    },
+
+    async getProfile() {
+      return get('/api/profile');
+    },
+
+    async register(email: string, password: string) {
+      const data = await post('/api/register', { email, password });
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return data;
+    },
+
+    async forgotPassword(email: string) {
+      return post('/api/auth/forgot-password', { email });
+    },
+
+    async resetPassword(token: string, newPassword: string) {
+      return post('/api/auth/reset-password', { token, new_password: newPassword });
+    },
+
+    async validateResetToken(token: string) {
+      return get(`/api/auth/validate-reset-token?token=${token}`);
+    },
+
+    async verifyEmail(token: string) {
+      return post('/api/auth/verify-email', { token });
+    },
+
+    async requestEmailVerification() {
+      return post('/api/auth/request-verification');
+    },
+
+    async getAuthProviders() {
+      return get('/api/auth/providers');
+    },
+
+    async getAuthProvider(provider: string) {
+      return get(`/api/auth/providers/${provider}`);
+    },
+
+    async configureAuthProvider(provider: string, clientID: string, clientSecret: string, enabled: boolean) {
+      return post('/api/auth/providers', {
+        provider,
+        client_id: clientID,
+        client_secret: clientSecret,
+        enabled,
+      });
+    },
+  };
+}

package/src/modules/backups.ts

@@ -0,0 +1,68 @@
+/**
+ * Backups Module - Database backup operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface BackupsModule {
+  create(options?: { name?: string; tables?: string[] }): Promise<any>;
+  list(): Promise<any>;
+  get(backupId: string): Promise<any>;
+  restore(backupId: string): Promise<any>;
+  delete(backupId: string): Promise<any>;
+  getDownloadUrl(backupId: string): string;
+  listTables(): Promise<any>;
+  importFile(formData: FormData): Promise<any>;
+}
+
+export function createBackupsModule(client: HttpClient): BackupsModule {
+  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(options?: { name?: string; tables?: string[] }) {
+      return post('/api/backups', options || {});
+    },
+
+    async list() {
+      return get('/api/backups');
+    },
+
+    async get(backupId: string) {
+      return get(`/api/backups/${backupId}`);
+    },
+
+    async restore(backupId: string) {
+      return post(`/api/backups/${backupId}/restore`, {});
+    },
+
+    async delete(backupId: string) {
+      return del(`/api/backups/${backupId}`);
+    },
+
+    getDownloadUrl(backupId: string) {
+      const token = client.getDynamicToken();
+      const projectId = client.getDynamicProjectID();
+      return `${client.url}/api/backups/${backupId}/download?access_token=${token}&project_id=${projectId}`;
+    },
+
+    async listTables() {
+      return get('/api/backups/tables');
+    },
+
+    async importFile(formData: FormData) {
+      const headers = client.getHeaders();
+      delete headers['Content-Type'];
+      
+      const res = await fetch(`${client.url}/api/import`, {
+        method: 'POST',
+        headers,
+        body: formData,
+      });
+      const data = await res.json();
+      if (!res.ok && res.status === 401) client.forceLogout();
+      return data;
+    },
+  };
+}

package/src/modules/branches.ts

@@ -0,0 +1,46 @@
+/**
+ * Branches Module - Database branches operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface BranchesModule {
+  create(input: { name: string; source_branch?: string }): Promise<any>;
+  list(): Promise<any>;
+  get(id: string): Promise<any>;
+  delete(id: string): Promise<any>;
+  merge(id: string, targetBranchId: string): Promise<any>;
+  reset(id: string): Promise<any>;
+}
+
+export function createBranchesModule(client: HttpClient): BranchesModule {
+  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; source_branch?: string }) {
+      return post('/api/branches', input);
+    },
+
+    async list() {
+      return get('/api/branches');
+    },
+
+    async get(id: string) {
+      return get(`/api/branches/${id}`);
+    },
+
+    async delete(id: string) {
+      return del(`/api/branches/${id}`);
+    },
+
+    async merge(id: string, targetBranchId: string) {
+      return post(`/api/branches/${id}/merge`, { target_branch_id: targetBranchId });
+    },
+
+    async reset(id: string) {
+      return post(`/api/branches/${id}/reset`);
+    },
+  };
+}

package/src/modules/database.ts

@@ -0,0 +1,158 @@
+/**
+ * Database Module - Schema, table, and column operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface DatabaseModule {
+  // Schemas
+  getSchemas(options?: { search?: string; limit?: number; offset?: number }): Promise<any>;
+  getSchema(name: string): Promise<any>;
+  
+  // Tables
+  createTable(tableName: string, definition: Record<string, string | { type: string; nullable?: boolean; unique?: boolean; default?: string }>): Promise<any>;
+  dropTable(tableName: string): Promise<any>;
+  renameTable(tableName: string, newName: string): Promise<any>;
+  
+  // Columns
+  addColumn(tableName: string, column: { name: string; type: string; nullable?: boolean; default_value?: string }): Promise<any>;
+  dropColumn(tableName: string, columnName: string): Promise<any>;
+  modifyColumn(tableName: string, columnName: string, changes: { type: string; nullable?: boolean }): Promise<any>;
+  renameColumn(tableName: string, columnName: string, newName: string): Promise<any>;
+  setColumnDefault(tableName: string, columnName: string, defaultValue: string | null): Promise<any>;
+  
+  // Foreign Keys
+  addForeignKey(tableName: string, fk: { column: string; ref_table: string; ref_column: string; on_delete?: string; on_update?: string }): Promise<any>;
+  listForeignKeys(tableName: string): Promise<any>;
+  dropForeignKey(tableName: string, constraintName: string): Promise<any>;
+  
+  // Constraints
+  addUniqueConstraint(tableName: string, columnName: string): Promise<any>;
+  dropConstraint(tableName: string, constraintName: string): Promise<any>;
+  
+  // Data operations
+  raw(query: string): Promise<any>;
+  queryData(tableName: string, options: { page?: number; limit?: number; filters?: any[] }): Promise<any>;
+  downloadExport(tableName: string, format: 'sql' | 'csv' | 'backup', filters?: any[]): Promise<any>;
+}
+
+export function createDatabaseModule(client: HttpClient): DatabaseModule {
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+  const patch = (endpoint: string, body?: unknown) => (client as any).patch(endpoint, body);
+  const del = (endpoint: string) => (client as any).delete(endpoint);
+
+  return {
+    // Schemas
+    async getSchemas(options?: { search?: string; limit?: number; offset?: number }) {
+      const params = new URLSearchParams();
+      if (options?.search) params.append('search', options.search);
+      if (options?.limit) params.append('limit', options.limit.toString());
+      if (options?.offset) params.append('offset', options.offset.toString());
+      const query = params.toString();
+      return get(`/api/schemas${query ? `?${query}` : ''}`);
+    },
+
+    async getSchema(name: string) {
+      return get(`/api/schemas/${name}`);
+    },
+
+    // Tables
+    async createTable(tableName: string, definition: Record<string, string | { type: string; nullable?: boolean; unique?: boolean; default?: string }>) {
+      return post('/api/schemas/tables', { table_name: tableName, definition });
+    },
+
+    async dropTable(tableName: string) {
+      return del(`/api/schemas/tables/${tableName}`);
+    },
+
+    async renameTable(tableName: string, newName: string) {
+      return post(`/api/schemas/tables/${tableName}/rename`, { new_name: newName });
+    },
+
+    // Columns
+    async addColumn(tableName: string, column: { name: string; type: string; nullable?: boolean; default_value?: string }) {
+      return post(`/api/schemas/tables/${tableName}/columns`, column);
+    },
+
+    async dropColumn(tableName: string, columnName: string) {
+      return del(`/api/schemas/tables/${tableName}/columns/${columnName}`);
+    },
+
+    async modifyColumn(tableName: string, columnName: string, changes: { type: string; nullable?: boolean }) {
+      return patch(`/api/schemas/tables/${tableName}/columns/${columnName}`, changes);
+    },
+
+    async renameColumn(tableName: string, columnName: string, newName: string) {
+      return post(`/api/schemas/tables/${tableName}/columns/${columnName}/rename`, { new_name: newName });
+    },
+
+    async setColumnDefault(tableName: string, columnName: string, defaultValue: string | null) {
+      return patch(`/api/schemas/tables/${tableName}/columns/${columnName}/default`, { default_value: defaultValue });
+    },
+
+    // Foreign Keys
+    async addForeignKey(tableName: string, fk: { column: string; ref_table: string; ref_column: string; on_delete?: string; on_update?: string }) {
+      return post(`/api/schemas/tables/${tableName}/foreign-keys`, fk);
+    },
+
+    async listForeignKeys(tableName: string) {
+      return get(`/api/schemas/tables/${tableName}/foreign-keys`);
+    },
+
+    async dropForeignKey(tableName: string, constraintName: string) {
+      return del(`/api/schemas/tables/${tableName}/foreign-keys/${constraintName}`);
+    },
+
+    // Constraints
+    async addUniqueConstraint(tableName: string, columnName: string) {
+      return post(`/api/schemas/tables/${tableName}/constraints/unique`, { column: columnName });
+    },
+
+    async dropConstraint(tableName: string, constraintName: string) {
+      return del(`/api/schemas/tables/${tableName}/constraints/${constraintName}`);
+    },
+
+    // Data operations
+    async raw(query: string) {
+      return post('/api/v1/sql', { query });
+    },
+
+    async queryData(tableName: string, options: { page?: number; limit?: number; filters?: any[] }) {
+      const params = new URLSearchParams();
+      if (options.page) params.append('page', options.page.toString());
+      if (options.limit) params.append('limit', options.limit.toString());
+      if (options.filters && options.filters.length > 0) {
+        params.append('filters', JSON.stringify(options.filters));
+      }
+      return get(`/api/v1/data/${tableName}/query?${params.toString()}`);
+    },
+
+    async downloadExport(tableName: string, format: 'sql' | 'csv' | 'backup', filters?: any[]) {
+      const params = new URLSearchParams();
+      if (filters && filters.length > 0) {
+        params.append('filters', JSON.stringify(filters));
+      }
+
+      const res = await fetch(`${client.url}/api/v1/export/${tableName}/${format}?${params.toString()}`, {
+        headers: client.getHeaders()
+      });
+      
+      if (!res.ok) {
+        const data = await res.json();
+        return { error: data.error || `Export failed: ${res.status}` };
+      }
+
+      const blob = await res.blob();
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `${tableName}_${new Date().toISOString().split('T')[0]}.${format === 'backup' ? 'dump' : format}`;
+      document.body.appendChild(a);
+      a.click();
+      window.URL.revokeObjectURL(url);
+      document.body.removeChild(a);
+      return { success: true };
+    },
+  };
+}

package/src/modules/email.ts

@@ -0,0 +1,93 @@
+/**
+ * Email Module - Email service operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface EmailConfig {
+  provider: string;
+  smtp_host?: string;
+  smtp_port?: number;
+  smtp_user?: string;
+  smtp_password?: string;
+  sendgrid_api_key?: string;
+  resend_api_key?: string;
+  from_email: string;
+  from_name?: string;
+}
+
+export interface EmailTemplate {
+  name: string;
+  subject: string;
+  text_body?: string;
+  html_body?: string;
+}
+
+export interface SendEmailInput {
+  to: string[];
+  subject: string;
+  text_body?: string;
+  html_body?: string;
+  template_id?: string;
+  template_data?: Record<string, any>;
+}
+
+export interface EmailModule {
+  send(input: SendEmailInput): Promise<any>;
+  getConfig(): Promise<any>;
+  saveConfig(config: EmailConfig): Promise<any>;
+  createTemplate(template: EmailTemplate): Promise<any>;
+  listTemplates(): Promise<any>;
+  getTemplate(id: string): Promise<any>;
+  updateTemplate(id: string, template: Partial<EmailTemplate>): Promise<any>;
+  deleteTemplate(id: string): Promise<any>;
+  getLogs(options?: { limit?: number; offset?: number }): Promise<any>;
+}
+
+export function createEmailModule(client: HttpClient): EmailModule {
+  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 send(input: SendEmailInput) {
+      return post('/api/email/send', input);
+    },
+
+    async getConfig() {
+      return get('/api/email/config');
+    },
+
+    async saveConfig(config: EmailConfig) {
+      return post('/api/email/config', config);
+    },
+
+    async createTemplate(template: EmailTemplate) {
+      return post('/api/email/templates', template);
+    },
+
+    async listTemplates() {
+      return get('/api/email/templates');
+    },
+
+    async getTemplate(id: string) {
+      return get(`/api/email/templates/${id}`);
+    },
+
+    async updateTemplate(id: string, template: Partial<EmailTemplate>) {
+      return put(`/api/email/templates/${id}`, template);
+    },
+
+    async deleteTemplate(id: string) {
+      return del(`/api/email/templates/${id}`);
+    },
+
+    async getLogs(options?: { limit?: number; offset?: number }) {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set('limit', options.limit.toString());
+      if (options?.offset) params.set('offset', options.offset.toString());
+      return get(`/api/email/logs?${params.toString()}`);
+    },
+  };
+}

package/src/modules/env-vars.ts

@@ -0,0 +1,42 @@
+/**
+ * Environment Variables Module
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface EnvVarsModule {
+  create(input: { key: string; value: string; is_secret?: boolean }): Promise<any>;
+  list(): Promise<any>;
+  get(id: string): Promise<any>;
+  update(id: string, value: string): Promise<any>;
+  delete(id: string): Promise<any>;
+}
+
+export function createEnvVarsModule(client: HttpClient): EnvVarsModule {
+  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: { key: string; value: string; is_secret?: boolean }) {
+      return post('/api/env-vars', input);
+    },
+
+    async list() {
+      return get('/api/env-vars');
+    },
+
+    async get(id: string) {
+      return get(`/api/env-vars/${id}`);
+    },
+
+    async update(id: string, value: string) {
+      return put(`/api/env-vars/${id}`, { value });
+    },
+
+    async delete(id: string) {
+      return del(`/api/env-vars/${id}`);
+    },
+  };
+}

package/src/modules/functions.ts

@@ -0,0 +1,57 @@
+/**
+ * Functions Module - Edge function operations
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface FunctionsModule {
+  invoke(id: string, data?: any): Promise<any>;
+  list(): Promise<any>;
+  create(name: string, code: string): Promise<any>;
+  delete(id: string): Promise<any>;
+  update(id: string, code: string): Promise<any>;
+  
+  // Hooks
+  listHooks(): Promise<any>;
+  createHook(data: { 
+    event_type: string, 
+    function_id: string, 
+    table_name?: string,
+    config?: any 
+  }): Promise<any>;
+  deleteHook(id: string): Promise<any>;
+}
+
+export function createFunctionsModule(client: HttpClient): FunctionsModule {
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+  const get = (endpoint: string) => (client as any).get(endpoint);
+  const del = (endpoint: string) => (client as any).delete(endpoint);
+  const put = (endpoint: string, body?: unknown) => (client as any).put(endpoint, body);
+
+  return {
+    async invoke(id: string, data: any = {}) {
+      return post(`/api/functions/${id}/execute`, data);
+    },
+    async list() {
+      return get('/api/functions');
+    },
+    async create(name: string, code: string) {
+      return post('/api/functions', { name, code });
+    },
+    async delete(id: string) {
+      return del(`/api/functions/${id}`);
+    },
+    async update(id: string, code: string) {
+      return put(`/api/functions/${id}`, { code });
+    },
+    async listHooks() {
+      return get('/api/hooks');
+    },
+    async createHook(data: any) {
+      return post('/api/hooks', data);
+    },
+    async deleteHook(id: string) {
+      return del(`/api/hooks/${id}`);
+    },
+  };
+}

package/src/modules/graphql.ts

@@ -0,0 +1,24 @@
+/**
+ * GraphQL Module
+ */
+
+import type { HttpClient } from '../http-client';
+
+export interface GraphQLModule {
+  query(query: string, variables?: Record<string, any>): Promise<any>;
+  getPlaygroundUrl(): string;
+}
+
+export function createGraphQLModule(client: HttpClient): GraphQLModule {
+  const post = (endpoint: string, body?: unknown) => (client as any).post(endpoint, body);
+
+  return {
+    async query(query: string, variables?: Record<string, any>) {
+      return post('/api/graphql', { query, variables });
+    },
+
+    getPlaygroundUrl() {
+      return `${client.url}/api/graphql/playground`;
+    },
+  };
+}