supa-seed/dist/features/integration/strategies/generic-strategy.d.ts

A constraint-aware, framework-agnostic database seeding framework with deep PostgreSQL business logic discovery and MakerKit integration support

/**
 * Generic Framework Strategy
 * Fallback strategy for databases without specific framework patterns
 */
import type { createClient } from '@supabase/supabase-js';
import { SeedingStrategy, DatabaseSchema, FrameworkDetectionResult, UserData, User, ConstraintHandlingResult, ConstraintHandler, TableConstraints, StrategyConstraintResult } from '../strategy-interface';
import type { BusinessLogicAnalysisResult, RLSComplianceOptions, RLSComplianceResult, UserContext } from '../../analysis/business-logic-types';
import type { RelationshipAnalysisResult } from '../../analysis/relationship-analyzer';
import type { JunctionTableDetectionResult, JunctionSeedingOptions, JunctionSeedingResult } from '../../../schema/junction-table-handler';
import type { DependencyGraph } from '../../../schema/dependency-graph';
import type { TenantDiscoveryResult, TenantSeedingResult, TenantIsolationReport, TenantDataGenerationOptions, TenantInfo, TenantScopeInfo } from '../../../schema/tenant-types';
import type { StorageIntegrationResult, StorageConfig, StoragePermissionCheck, StorageQuotaInfo, MediaAttachment } from '../../generation/storage/storage-types';
type SupabaseClient = ReturnType<typeof createClient>;
export declare class GenericStrategy implements SeedingStrategy {
    name: string;
    private client;
    private discoveredConstraints;
    private constraintEngine?;
    private constraintRegistry?;
    private businessLogicAnalyzer?;
    private rlsCompliantSeeder?;
    private relationshipAnalyzer?;
    private junctionTableHandler?;
    private multiTenantManager?;
    private storageIntegrationManager?;
    initialize(client: SupabaseClient): Promise<void>;
    getPriority(): number;
    detect(schema: DatabaseSchema): Promise<FrameworkDetectionResult>;
    createUser(data: UserData): Promise<User>;
    private createUserDirectly;
    private createRelatedRecords;
    handleConstraints(table: string, data: any): Promise<ConstraintHandlingResult>;
    getRecommendations(): string[];
    supportsFeature(feature: string): boolean;
    /**
     * Discover constraints using generic analysis
     */
    discoverConstraints(tableNames?: string[]): Promise<StrategyConstraintResult>;
    /**
     * Get generic constraint handlers
     */
    getConstraintHandlers(): ConstraintHandler[];
    /**
     * Apply constraint fixes using generic logic
     */
    applyConstraintFixes(table: string, data: any, constraints: TableConstraints): Promise<ConstraintHandlingResult>;
    /**
     * Analyze business logic patterns for generic strategy
     */
    analyzeBusinessLogic(): Promise<BusinessLogicAnalysisResult>;
    /**
     * Seed data with RLS compliance for generic strategy
     */
    seedWithRLSCompliance(table: string, data: any[], userContext?: UserContext): Promise<RLSComplianceResult>;
    /**
     * Get RLS compliance options for generic strategy
     */
    getRLSComplianceOptions(): RLSComplianceOptions;
    /**
     * Analyze database relationships for generic strategy
     */
    analyzeRelationships(): Promise<RelationshipAnalysisResult>;
    /**
     * Get dependency graph for generic strategy
     */
    getDependencyGraph(): Promise<DependencyGraph>;
    /**
     * Detect junction tables with generic patterns
     */
    detectJunctionTables(): Promise<JunctionTableDetectionResult>;
    /**
     * Seed junction table with generic options
     */
    seedJunctionTable(tableName: string, options?: Partial<JunctionSeedingOptions>): Promise<JunctionSeedingResult>;
    /**
     * Get optimal seeding order for generic schemas
     */
    getSeedingOrder(): Promise<string[]>;
    /**
     * Multi-Tenant Methods Implementation (Basic Generic Support)
     */
    /**
     * Discover tenant-scoped tables and relationships
     */
    discoverTenantScopes(): Promise<TenantDiscoveryResult>;
    /**
     * Create tenant-aware data with basic support
     */
    createTenantScopedData(tenantId: string, tableName: string, data: any[], options?: Partial<TenantDataGenerationOptions>): Promise<any[]>;
    /**
     * Generate basic tenant accounts (generic implementation)
     */
    generateTenantAccounts(count: number, options?: Partial<TenantDataGenerationOptions>): Promise<TenantInfo[]>;
    /**
     * Basic tenant isolation validation
     */
    validateTenantIsolation(tenantId: string): Promise<TenantIsolationReport>;
    /**
     * Basic multi-tenant data seeding
     */
    seedMultiTenantData(tenants: TenantInfo[], options?: Partial<TenantDataGenerationOptions>): Promise<TenantSeedingResult>;
    /**
     * Get tenant scope information for a table
     */
    getTenantScopeInfo(tableName: string): Promise<TenantScopeInfo | null>;
    /**
     * Storage Integration Methods (Basic Generic Support)
     */
    /**
     * Integrate with Supabase Storage for file uploads
     */
    integrateWithStorage(setupId: string, accountId?: string, config?: Partial<StorageConfig>): Promise<StorageIntegrationResult>;
    /**
     * Check storage permissions (basic generic implementation)
     */
    checkStoragePermissions(bucketName: string): Promise<StoragePermissionCheck>;
    /**
     * Get storage quota information (basic generic implementation)
     */
    getStorageQuota(bucketName: string): Promise<StorageQuotaInfo>;
    /**
     * Generate media attachments (basic generic implementation)
     */
    generateMediaAttachments(entityId: string, entityType: string, count?: number, config?: Partial<StorageConfig>): Promise<MediaAttachment[]>;
    /**
     * Get storage configuration for generic strategy
     */
    getStorageConfig(): Partial<StorageConfig>;
}
export {};
//# sourceMappingURL=generic-strategy.d.ts.map