@divetocode/supa-query-builder/dist/index.d.ts

unofficial supabase query builder

declare class SupabaseClient {
    private url;
    private apiKey;
    private options;
    constructor(url: string, apiKey: string, // ANON 키만 사용
    options?: any);
    from(table: string): SupabaseQueryBuilder;
    rls(table: string): SupabaseRLSReader;
}
declare class SupabaseServer {
    private url;
    private apiKey;
    private serverKey;
    private options;
    constructor(url: string, apiKey: string, // ANON 키
    serverKey: string, // SERVICE_ROLE 키
    options?: any);
    from(table: string): SupabaseQueryBuilder;
    rls(table: string): SupabaseRLSManager;
    schema(): SupabaseSchemaManager;
}
declare class SupabaseSchemaManager {
    private url;
    private apiKey;
    private serverKey;
    private options;
    constructor(url: string, apiKey: string, serverKey: string, options?: any);
    getTables(schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    getTableInfo(tableName: string, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    private reloadSchemaCache;
    private waitUntilVisible;
    createTable(tableName: string, columns: TableColumn[], options?: CreateTableOptions): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: any;
    }>;
    dropTable(tableName: string, schema?: string, cascade?: boolean): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    addColumn(tableName: string, column: TableColumn, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    alterColumn(tableName: string, columnName: string, changes: ColumnChanges, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    dropColumn(tableName: string, columnName: string, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    renameTable(oldName: string, newName: string, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    renameColumn(tableName: string, oldColumnName: string, newColumnName: string, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    createIndex(tableName: string, indexName: string, columns: string[], options?: IndexOptions): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    dropIndex(indexName: string, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    copyTable(sourceTable: string, targetTable: string, includeData?: boolean, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    tableExists(tableName: string, schema?: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    private executeRPC;
}
interface TableColumn {
    name: string;
    type: string;
    nullable?: boolean;
    defaultValue?: any;
    primaryKey?: boolean;
    unique?: boolean;
    references?: {
        table: string;
        column: string;
        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
    };
}
interface CreateTableOptions {
    schema?: string;
    enableRLS?: boolean;
    addCreatedAt?: boolean;
    addUpdatedAt?: boolean;
}
interface ColumnChanges {
    type?: string;
    nullable?: boolean;
    defaultValue?: any;
    dropDefault?: boolean;
}
interface IndexOptions {
    unique?: boolean;
    method?: 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin';
    schema?: string;
}
declare class SupabaseRLSReader {
    private table;
    private url;
    private apiKey;
    private options;
    constructor(table: string, url: string, apiKey: string, options?: any);
    testAccess(): Promise<{
        data: {
            canAccess: boolean;
            status: number;
            message: string;
        };
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    getPolicies(): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    private executeRPC;
}
declare class SupabaseRLSManager {
    private table;
    private url;
    private apiKey;
    private serverKey;
    private options;
    constructor(table: string, url: string, apiKey: string, serverKey: string, options?: any);
    enableRLS(): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    disableRLS(): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    createPolicy(policyName: string, operation: string, condition: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    createPublicReadPolicy(): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    createOpenPolicy(): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    dropPolicy(policyName: string): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    getPolicies(): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    checkRLSStatus(): Promise<{
        data: any;
        error: null;
    } | {
        data: null;
        error: unknown;
    }>;
    private executeRPC;
}
declare class SupabaseQueryBuilder {
    private table;
    private url;
    private apiKey;
    private authKey;
    private options;
    constructor(table: string, url: string, apiKey: string, // apikey 헤더
    authKey: string, // Authorization Bearer
    options?: any);
    select(columns?: string): SupabaseSelectBuilder;
    insert(data: any): SupabaseInsertBuilder;
    update(data: any): SupabaseUpdateBuilder;
    delete(): SupabaseDeleteBuilder;
}
declare class SupabaseSelectBuilder {
    private table;
    private url;
    private apiKey;
    private authKey;
    private columns;
    private filters;
    private orderClause;
    private rangeFrom?;
    private rangeTo?;
    private singleRow;
    private countMode?;
    private headOnly;
    private limitCount?;
    private offsetCount?;
    constructor(table: string, url: string, apiKey: string, authKey: string, columns: string, options?: {
        count?: 'exact' | 'planned' | 'estimated';
        head?: boolean;
    });
    eq(column: string, value: any): this;
    neq(column: string, value: any): this;
    gt(column: string, value: any): this;
    gte(column: string, value: any): this;
    lt(column: string, value: any): this;
    lte(column: string, value: any): this;
    not(column: string, operator: string, value: any): this;
    in(column: string, values: Array<string | number | boolean>): this;
    like(column: string, pattern: string): this;
    ilike(column: string, pattern: string): this;
    or(query: string): this;
    order(column: string, options?: {
        ascending: boolean;
    }): this;
    limit(n: number): this;
    offset(n: number): this;
    range(from: number, to: number): this;
    single(): this;
    then(resolve: (result: {
        data: any;
        error: any;
    }) => void): Promise<void>;
}
declare class SupabaseInsertBuilder {
    private table;
    private url;
    private apiKey;
    private authKey;
    private data;
    private selectColumns;
    constructor(table: string, url: string, apiKey: string, authKey: string, data: any);
    select(columns?: string): this;
    single(): this;
    then(resolve: (result: {
        data: any;
        error: any;
    }) => void): Promise<void>;
}
declare class SupabaseUpdateBuilder {
    private table;
    private url;
    private apiKey;
    private authKey;
    private data;
    private whereClause;
    private selectColumns;
    constructor(table: string, url: string, apiKey: string, authKey: string, data: any);
    eq(column: string, value: any): this;
    select(columns?: string): this;
    single(): this;
    then(resolve: (result: {
        data: any;
        error: any;
    }) => void): Promise<void>;
}
declare class SupabaseDeleteBuilder {
    private table;
    private url;
    private apiKey;
    private authKey;
    private whereClause;
    constructor(table: string, url: string, apiKey: string, authKey: string);
    eq(column: string, value: any): this;
    then(resolve: (result: {
        data: any;
        error: any;
    }) => void): Promise<void>;
}

export { ColumnChanges, CreateTableOptions, IndexOptions, SupabaseClient, SupabaseDeleteBuilder, SupabaseInsertBuilder, SupabaseQueryBuilder, SupabaseRLSManager, SupabaseRLSReader, SupabaseSchemaManager, SupabaseSelectBuilder, SupabaseServer, SupabaseUpdateBuilder, TableColumn };