@giaeulate/baas-sdk 1.0.2 → 1.0.4

package/src/client.ts

@@ -1,265 +0,0 @@
-/**
- * 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 { 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';
-import { createEnvironmentsModule, type EnvironmentsModule } from './modules/environments';
-
-/**
- * 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 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;
-  public readonly environments: EnvironmentsModule;
-
-  constructor(url?: string, apiKey?: string) {
-    super(url, apiKey);
-
-    // Initialize all modules with this client instance
-    this.auth = createAuthModule(this);
-    this.users = createUsersModule(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);
-    this.environments = createEnvironmentsModule(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); }
-
-  // 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);
-  }
-
-  // Environment shortcuts
-  async getEnvironmentStatus() { return this.environments.status(); }
-  async initTestEnvironment() { return this.environments.init(); }
-  async promoteTestToProd() { return this.environments.promote(); }
-  async revertTestEnvironment() { return this.environments.revert(); }
-}

package/src/http-client.ts

@@ -1,145 +0,0 @@
-/**
- * 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 apiKey: string = '';
-  public token: string | null = null;
-  private environment: string = 'prod';
-
-  constructor(url?: string, apiKey?: string) {
-    let baseUrl = url || (typeof window !== 'undefined' ? window.location.origin : 'http://localhost:8080');
-    this.url = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-
-    if (apiKey) this.apiKey = apiKey;
-
-    this.token = this.cleanValue(localStorage.getItem('baas_token'));
-  }
-
-  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 dynamicToken = this.getDynamicToken();
-
-    const headers: Record<string, string> = {
-      'apikey': this.apiKey,
-    };
-
-    if (contentType) {
-      headers['Content-Type'] = contentType;
-    }
-
-    if (dynamicToken) {
-      headers['Authorization'] = `Bearer ${dynamicToken}`;
-    }
-
-    if (this.environment && this.environment !== 'prod') {
-      headers['X-Environment'] = this.environment;
-    }
-
-    return headers;
-  }
-
-  public getDynamicToken() {
-    return this.cleanValue(this.token || localStorage.getItem('baas_token'));
-  }
-
-  /**
-   * 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' });
-  }
-
-  setEnvironment(env: string) {
-    this.environment = env;
-  }
-
-  getEnvironment(): string {
-    return this.environment;
-  }
-
-  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

@@ -1,42 +0,0 @@
-/**
- * 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 { 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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,46 +0,0 @@
-/**
- * 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');
-    },
-  };
-}