@djangocfg/api 1.0.1

package/src/cfg/generated/storage.ts

@@ -0,0 +1,158 @@
+/**
+ * Storage adapters for cross-platform token storage.
+ *
+ * Supports:
+ * - LocalStorage (browser)
+ * - Cookies (SSR/browser)
+ * - Memory (Node.js/Electron/testing)
+ */
+
+import type { APILogger } from './logger';
+
+/**
+ * Storage adapter interface for cross-platform token storage.
+ */
+export interface StorageAdapter {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+/**
+ * LocalStorage adapter with safe try-catch for browser environments.
+ * Works in modern browsers with localStorage support.
+ */
+export class LocalStorageAdapter implements StorageAdapter {
+  private logger?: APILogger;
+
+  constructor(logger?: APILogger) {
+    this.logger = logger;
+  }
+
+  getItem(key: string): string | null {
+    try {
+      if (typeof window !== 'undefined' && window.localStorage) {
+        const value = localStorage.getItem(key);
+        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? 'found' : 'not found'}`);
+        return value;
+      }
+      this.logger?.warn('LocalStorage not available: window.localStorage is undefined');
+    } catch (error) {
+      this.logger?.error('LocalStorage.getItem failed:', error);
+    }
+    return null;
+  }
+
+  setItem(key: string, value: string): void {
+    try {
+      if (typeof window !== 'undefined' && window.localStorage) {
+        localStorage.setItem(key, value);
+        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn('LocalStorage not available: window.localStorage is undefined');
+      }
+    } catch (error) {
+      this.logger?.error('LocalStorage.setItem failed:', error);
+    }
+  }
+
+  removeItem(key: string): void {
+    try {
+      if (typeof window !== 'undefined' && window.localStorage) {
+        localStorage.removeItem(key);
+        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn('LocalStorage not available: window.localStorage is undefined');
+      }
+    } catch (error) {
+      this.logger?.error('LocalStorage.removeItem failed:', error);
+    }
+  }
+}
+
+/**
+ * Cookie-based storage adapter for SSR and browser environments.
+ * Useful for Next.js, Nuxt.js, and other SSR frameworks.
+ */
+export class CookieStorageAdapter implements StorageAdapter {
+  private logger?: APILogger;
+
+  constructor(logger?: APILogger) {
+    this.logger = logger;
+  }
+
+  getItem(key: string): string | null {
+    try {
+      if (typeof document === 'undefined') {
+        this.logger?.warn('Cookies not available: document is undefined (SSR context?)');
+        return null;
+      }
+      const value = `; ${document.cookie}`;
+      const parts = value.split(`; ${key}=`);
+      if (parts.length === 2) {
+        const result = parts.pop()?.split(';').shift() || null;
+        this.logger?.debug(`CookieStorage.getItem("${key}"): ${result ? 'found' : 'not found'}`);
+        return result;
+      }
+      this.logger?.debug(`CookieStorage.getItem("${key}"): not found`);
+    } catch (error) {
+      this.logger?.error('CookieStorage.getItem failed:', error);
+    }
+    return null;
+  }
+
+  setItem(key: string, value: string): void {
+    try {
+      if (typeof document !== 'undefined') {
+        document.cookie = `${key}=${value}; path=/; max-age=31536000`;
+        this.logger?.debug(`CookieStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn('Cookies not available: document is undefined (SSR context?)');
+      }
+    } catch (error) {
+      this.logger?.error('CookieStorage.setItem failed:', error);
+    }
+  }
+
+  removeItem(key: string): void {
+    try {
+      if (typeof document !== 'undefined') {
+        document.cookie = `${key}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+        this.logger?.debug(`CookieStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn('Cookies not available: document is undefined (SSR context?)');
+      }
+    } catch (error) {
+      this.logger?.error('CookieStorage.removeItem failed:', error);
+    }
+  }
+}
+
+/**
+ * In-memory storage adapter for Node.js, Electron, and testing environments.
+ * Data is stored in RAM and cleared when process exits.
+ */
+export class MemoryStorageAdapter implements StorageAdapter {
+  private storage: Map<string, string> = new Map();
+  private logger?: APILogger;
+
+  constructor(logger?: APILogger) {
+    this.logger = logger;
+  }
+
+  getItem(key: string): string | null {
+    const value = this.storage.get(key) || null;
+    this.logger?.debug(`MemoryStorage.getItem("${key}"): ${value ? 'found' : 'not found'}`);
+    return value;
+  }
+
+  setItem(key: string, value: string): void {
+    this.storage.set(key, value);
+    this.logger?.debug(`MemoryStorage.setItem("${key}"): success`);
+  }
+
+  removeItem(key: string): void {
+    this.storage.delete(key);
+    this.logger?.debug(`MemoryStorage.removeItem("${key}"): success`);
+  }
+}

package/src/cfg/generated/tsconfig.json

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

package/src/cfg/services/auth/AuthService.ts

@@ -0,0 +1,165 @@
+/**
+ * Authentication Service
+ *
+ * Handles OTP authentication, token management, and user profile
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgAccountsTypes, CfgUserProfileTypes, Enums } from '../../generated';
+
+export class AuthService extends BaseClient {
+  /**
+   * Request OTP code
+   */
+  static async requestOTP(
+    identifier: string,
+    channel?: Enums.OTPRequestRequestChannel
+  ): Promise<{
+    success: boolean;
+    message?: string;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_accounts.otpRequestCreate({
+        identifier,
+        channel,
+      });
+      return { success: true, message: response.message };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Verify OTP and login
+   */
+  static async verifyOTP(
+    identifier: string,
+    otp: string,
+    channel?: Enums.OTPVerifyRequestChannel
+  ): Promise<{
+    success: boolean;
+    user?: CfgUserProfileTypes.User;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const { access, refresh } = await this.api.cfg_accounts.otpVerifyCreate({
+        identifier,
+        otp,
+        channel,
+      });
+
+      this.api.setToken(access, refresh);
+
+      const user = await this.api.cfg_user_profile.accountsProfileRetrieve();
+
+      return { success: true, user };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get current user profile
+   */
+  static async getCurrentUser(): Promise<{
+    success: boolean;
+    user?: CfgUserProfileTypes.User;
+    error?: string;
+  }> {
+    try {
+      const user = await this.api.cfg_user_profile.accountsProfileRetrieve();
+      return { success: true, user };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Update user profile
+   */
+  static async updateProfile(
+    data: CfgUserProfileTypes.PatchedUserProfileUpdateRequest
+  ): Promise<{
+    success: boolean;
+    user?: CfgUserProfileTypes.User;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const user = await this.api.cfg_user_profile.accountsProfilePartialUpdate(data);
+      return { success: true, user };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Refresh access token
+   */
+  static async refreshToken(): Promise<{ success: boolean; error?: string }> {
+    const refresh = this.api.getRefreshToken();
+    if (!refresh) {
+      return { success: false, error: 'No refresh token' };
+    }
+
+    try {
+      const { access } = await this.api.cfg_auth.accountsTokenRefreshCreate({ refresh });
+      this.api.setToken(access);
+      return { success: true };
+    } catch (error) {
+      this.api.clearTokens();
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Logout user
+   */
+  static logout(): void {
+    this.api.clearTokens();
+  }
+
+  /**
+   * Check if user is authenticated
+   */
+  static isAuthenticated(): boolean {
+    return this.api.isAuthenticated();
+  }
+
+  /**
+   * Get access token
+   */
+  static getToken(): string | null {
+    return this.api.getToken();
+  }
+
+  /**
+   * Get refresh token
+   */
+  static getRefreshToken(): string | null {
+    return this.api.getRefreshToken();
+  }
+}

package/src/cfg/services/auth/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Auth Module
+ *
+ * Authentication and user profile services
+ */
+
+export { AuthService } from './AuthService';

package/src/cfg/services/index.ts

@@ -0,0 +1,31 @@
+/**
+ * API Services
+ *
+ * Domain services with business logic and error handling
+ */
+
+// Base Client + API singleton
+export { BaseClient, api } from '../BaseClient';
+
+// Domain Services
+export { AuthService } from './auth';
+export { LeadsService } from './leads';
+export { SupportService } from './support';
+export { TasksService } from './tasks';
+export { WebhooksService } from './webhooks';
+
+// Payment Services
+export {
+  ApiKeysService,
+  PaymentsService,
+  SubscriptionsService,
+  PaymentDashboardService,
+} from './payments';
+
+// Newsletter Services
+export {
+  NewsletterService,
+  CampaignsService,
+  NewslettersListService,
+  BulkEmailService,
+} from './newsletter';

package/src/cfg/services/leads/LeadsService.ts

@@ -0,0 +1,133 @@
+/**
+ * Leads Service
+ *
+ * Handles lead submission and management
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgLeadsTypes, CfgLeadSubmissionTypes, Enums } from '../../generated';
+
+export class LeadsService extends BaseClient {
+  /**
+   * Submit lead (public)
+   */
+  static async submitLead(data: {
+    email: string;
+    name: string;
+    message: string;
+    company?: string;
+    phone?: string;
+    contact_type?: Enums.LeadSubmissionRequestContactType;
+  }): Promise<{
+    success: boolean;
+    lead?: CfgLeadSubmissionTypes.LeadSubmissionResponse;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const lead = await this.api.cfg_lead_submission.leadsSubmitCreate({
+        name: data.name,
+        email: data.email,
+        message: data.message,
+        company: data.company,
+        contact_type: data.contact_type || Enums.LeadSubmissionRequestContactType.EMAIL,
+        contact_value: data.phone,
+        site_url: typeof window !== 'undefined' ? window.location.href : '',
+      });
+      return { success: true, lead };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get leads list (admin)
+   */
+  static async getLeads(
+    page: number = 1,
+    pageSize: number = 20
+  ): Promise<{
+    success: boolean;
+    leads?: CfgLeadsTypes.PaginatedLeadSubmissionList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_leads.list({ page, page_size: pageSize });
+      return { success: true, leads: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get lead by ID (admin)
+   */
+  static async getLead(id: number): Promise<{
+    success: boolean;
+    lead?: CfgLeadsTypes.LeadSubmission;
+    error?: string;
+  }> {
+    try {
+      const lead = await this.api.cfg_leads.retrieve(id);
+      return { success: true, lead };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Update lead (admin)
+   */
+  static async updateLead(
+    id: number,
+    data: CfgLeadsTypes.PatchedLeadSubmissionRequest
+  ): Promise<{
+    success: boolean;
+    lead?: CfgLeadsTypes.LeadSubmission;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const lead = await this.api.cfg_leads.partialUpdate(id, data);
+      return { success: true, lead };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Delete lead (admin)
+   */
+  static async deleteLead(id: number): Promise<{
+    success: boolean;
+    error?: string;
+  }> {
+    try {
+      await this.api.cfg_leads.destroy(id);
+      return { success: true };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

package/src/cfg/services/leads/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Leads Module
+ *
+ * Lead submission and management
+ */
+
+export { LeadsService } from './LeadsService';

package/src/cfg/services/newsletter/BulkEmailService.ts

@@ -0,0 +1,35 @@
+/**
+ * Bulk Email Service
+ *
+ * Sends bulk emails
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgBulkEmailTypes } from '../../generated';
+
+export class BulkEmailService extends BaseClient {
+  /**
+   * Send bulk email
+   */
+  static async send(
+    data: CfgBulkEmailTypes.BulkEmailRequest
+  ): Promise<{
+    success: boolean;
+    response?: CfgBulkEmailTypes.BulkEmailResponse;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const response = await this.api.cfg_bulk_email.newsletterBulkCreate(data);
+      return { success: true, response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

package/src/cfg/services/newsletter/CampaignsService.ts

@@ -0,0 +1,138 @@
+/**
+ * Newsletter Campaigns Service
+ *
+ * Manages newsletter campaigns
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgCampaignsTypes } from '../../generated';
+
+export class CampaignsService extends BaseClient {
+  /**
+   * List campaigns
+   */
+  static async list(page?: number, pageSize?: number): Promise<{
+    success: boolean;
+    campaigns?: CfgCampaignsTypes.PaginatedNewsletterCampaignList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_campaigns.newsletterCampaignsList(page, pageSize);
+      return { success: true, campaigns: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Create campaign
+   */
+  static async create(
+    data: CfgCampaignsTypes.NewsletterCampaignRequest
+  ): Promise<{
+    success: boolean;
+    campaign?: CfgCampaignsTypes.NewsletterCampaign;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const campaign = await this.api.cfg_campaigns.newsletterCampaignsCreate(data);
+      return { success: true, campaign };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get campaign details
+   */
+  static async get(id: number): Promise<{
+    success: boolean;
+    campaign?: CfgCampaignsTypes.NewsletterCampaign;
+    error?: string;
+  }> {
+    try {
+      const campaign = await this.api.cfg_campaigns.newsletterCampaignsRetrieve(id);
+      return { success: true, campaign };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Update campaign
+   */
+  static async update(
+    id: number,
+    data: CfgCampaignsTypes.NewsletterCampaignRequest
+  ): Promise<{
+    success: boolean;
+    campaign?: CfgCampaignsTypes.NewsletterCampaign;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const campaign = await this.api.cfg_campaigns.newsletterCampaignsUpdate(id, data);
+      return { success: true, campaign };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Delete campaign
+   */
+  static async delete(id: number): Promise<{
+    success: boolean;
+    error?: string;
+  }> {
+    try {
+      await this.api.cfg_campaigns.newsletterCampaignsDestroy(id);
+      return { success: true };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Send campaign
+   */
+  static async send(
+    data: CfgCampaignsTypes.SendCampaignRequest
+  ): Promise<{
+    success: boolean;
+    response?: CfgCampaignsTypes.SendCampaignResponse;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_campaigns.newsletterCampaignsSendCreate(data);
+      return { success: true, response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}