@tetrascience-npm/tetrascience-react-ui 0.2.0 → 0.3.0-beta.1.1

package/dist/providers/athena.d.ts

@@ -0,0 +1,79 @@
+import * as _aws_sdk_client_athena from '@aws-sdk/client-athena';
+export { I as InvalidProviderConfigurationError, M as MissingTableError, P as ProviderConfiguration, a as ProviderConnectionError, b as ProviderError, Q as QueryError, c as QueryResult } from './types-Ck4uFaGp.js';
+
+/**
+ * Athena Data Provider
+ *
+ * TypeScript equivalent of AthenaProvider from
+ * ts-lib-ui-kit-streamlit/tetrascience/data_app_providers/provider.py
+ *
+ * @remarks
+ * This provider requires the `@aws-sdk/client-athena` package to be installed.
+ * It is an optional peer dependency - install it only if you need Athena support:
+ * ```bash
+ * npm install @aws-sdk/client-athena
+ * # or
+ * yarn add @aws-sdk/client-athena
+ * ```
+ */
+type AthenaClient = _aws_sdk_client_athena.AthenaClient;
+type AthenaSDK = typeof _aws_sdk_client_athena;
+/**
+ * Athena data provider
+ */
+declare class AthenaProvider {
+    private client;
+    private sdk;
+    private workgroup;
+    private database;
+    private outputLocation?;
+    /**
+     * Initialize the Athena data provider
+     *
+     * @param client - AWS Athena client
+     * @param sdk - AWS Athena SDK module (for accessing command classes)
+     * @param workgroup - Athena workgroup to use
+     * @param database - Default database/schema
+     * @param outputLocation - Optional S3 output location
+     */
+    constructor(client: AthenaClient, sdk: AthenaSDK, workgroup: string, database: string, outputLocation?: string);
+    /**
+     * Query the Athena database
+     *
+     * @param sqlQuery - SQL query to execute
+     * @param _params - Parameters to pass to the query (currently not used - Athena doesn't support parameterized queries)
+     * @returns Promise resolving to array of row objects
+     *
+     * @remarks
+     * **Security Note:** AWS Athena does not support parameterized queries.
+     * Unlike traditional databases, there is no native way to use bind parameters
+     * with Athena. Callers are responsible for properly sanitizing any user input
+     * before constructing the SQL query string. This is a known limitation of the
+     * Athena service, not a design flaw in this implementation.
+     */
+    query(sqlQuery: string, _params?: Record<string, unknown>): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Wait for query to complete
+     */
+    private waitForQueryCompletion;
+    /**
+     * Fetch all results from a completed query
+     */
+    private fetchAllResults;
+    /**
+     * Close the Athena client (no-op for AWS SDK clients)
+     */
+    close(): Promise<void>;
+}
+/**
+ * Get the TDP Athena provider
+ *
+ * Creates an Athena provider using TDP environment configuration
+ *
+ * @returns Promise resolving to Athena data provider
+ * @throws {InvalidProviderConfigurationError} If @aws-sdk/client-athena is not installed
+ * @throws {Error} If ATHENA_S3_OUTPUT_LOCATION is not set when using the 'primary' workgroup
+ */
+declare function getTdpAthenaProvider(): Promise<AthenaProvider>;
+
+export { AthenaProvider, getTdpAthenaProvider };

package/dist/providers/databricks.d.ts

@@ -0,0 +1,43 @@
+import * as _databricks_sql_dist_contracts_IDBSQLSession from '@databricks/sql/dist/contracts/IDBSQLSession';
+import * as _databricks_sql from '@databricks/sql';
+import { P as ProviderConfiguration } from './types-Ck4uFaGp.js';
+export { I as InvalidProviderConfigurationError, M as MissingTableError, a as ProviderConnectionError, b as ProviderError, Q as QueryError, c as QueryResult } from './types-Ck4uFaGp.js';
+
+type DBSQLClient = _databricks_sql.DBSQLClient;
+type IDBSQLSession = _databricks_sql_dist_contracts_IDBSQLSession.default;
+/**
+ * Databricks data provider
+ */
+declare class DatabricksProvider {
+    private client;
+    private session;
+    /**
+     * Initialize the Databricks data provider
+     *
+     * @param client - Databricks SQL client
+     * @param session - Databricks SQL session
+     */
+    constructor(client: DBSQLClient, session: IDBSQLSession);
+    /**
+     * Query the Databricks database
+     *
+     * @param sqlQuery - SQL query to execute
+     * @param _params - Parameters to pass to the query (currently not used)
+     * @returns Promise resolving to array of row objects
+     */
+    query(sqlQuery: string, _params?: Record<string, unknown>): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Close the Databricks connection
+     */
+    close(): Promise<void>;
+}
+/**
+ * Build a Databricks data provider from the configuration
+ *
+ * @param config - Provider configuration
+ * @returns Promise resolving to Databricks data provider
+ * @throws {InvalidProviderConfigurationError} If @databricks/sql is not installed or config is invalid
+ */
+declare function buildDatabricksProvider(config: ProviderConfiguration): Promise<DatabricksProvider>;
+
+export { DatabricksProvider, ProviderConfiguration, buildDatabricksProvider };

package/dist/providers/snowflake.d.ts

@@ -0,0 +1,40 @@
+import * as snowflake_sdk from 'snowflake-sdk';
+import { P as ProviderConfiguration } from './types-Ck4uFaGp.js';
+export { I as InvalidProviderConfigurationError, M as MissingTableError, a as ProviderConnectionError, b as ProviderError, Q as QueryError, c as QueryResult } from './types-Ck4uFaGp.js';
+
+type SnowflakeConnection = snowflake_sdk.Connection;
+/**
+ * Snowflake data provider
+ */
+declare class SnowflakeProvider {
+    private connection;
+    /**
+     * Initialize the Snowflake data provider
+     *
+     * @param connection - Snowflake connection
+     */
+    constructor(connection: SnowflakeConnection);
+    /**
+     * Query the Snowflake database
+     *
+     * @param sqlText - SQL query to execute
+     * @param params - Parameters to pass to the query. For positional binds, use an array.
+     *                 For named binds, use an object with keys matching the bind variable names.
+     * @returns Promise resolving to array of row objects
+     */
+    query(sqlText: string, params?: Record<string, unknown> | unknown[]): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Close the Snowflake connection
+     */
+    close(): Promise<void>;
+}
+/**
+ * Build a Snowflake data provider from the configuration
+ *
+ * @param config - Provider configuration
+ * @returns Promise resolving to Snowflake data provider
+ * @throws {InvalidProviderConfigurationError} If snowflake-sdk is not installed or config is invalid
+ */
+declare function buildSnowflakeProvider(config: ProviderConfiguration): Promise<SnowflakeProvider>;
+
+export { ProviderConfiguration, SnowflakeProvider, buildSnowflakeProvider };

package/dist/providers/types-Ck4uFaGp.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Provider Exceptions
+ *
+ * TypeScript equivalents of the Python exceptions from
+ * ts-lib-ui-kit-streamlit/tetrascience/data_app_providers/exceptions.py
+ */
+/**
+ * Base class for provider errors
+ */
+declare class ProviderError extends Error {
+    constructor(message: string);
+}
+/**
+ * Raised when a table is missing in the database
+ */
+declare class MissingTableError extends ProviderError {
+    constructor(message: string);
+}
+/**
+ * Raised when a query fails
+ */
+declare class QueryError extends ProviderError {
+    constructor(message: string);
+}
+/**
+ * Raised when connecting to a provider fails
+ */
+declare class ProviderConnectionError extends ProviderError {
+    constructor(message: string);
+}
+/**
+ * Raised when the provider configuration is invalid
+ */
+declare class InvalidProviderConfigurationError extends ProviderError {
+    constructor(message: string);
+}
+
+/**
+ * Data App Provider Types
+ *
+ * TypeScript equivalents of the Python ProviderConfiguration Pydantic models
+ * from ts-lib-ui-kit-streamlit/tetrascience/data_app_providers/provider_typing.py
+ */
+/**
+ * Configuration model for data providers.
+ *
+ * This interface represents the configuration needed to connect to various
+ * database providers (Snowflake, Databricks, Athena, Benchling, etc.)
+ * attached to a data app.
+ */
+interface ProviderConfiguration {
+    /** Human-readable name of the provider */
+    name: string;
+    /** Provider type (snowflake, databricks, benchling, custom, etc.) */
+    type: string;
+    /** Optional URL to the provider's icon */
+    iconUrl?: string;
+    /** Dictionary containing connection details and credentials */
+    fields: Record<string, string | undefined>;
+}
+/**
+ * Standardized query result from data providers.
+ *
+ * This interface provides a consistent shape for query results across
+ * all provider types (Snowflake, Databricks, Athena), with optional
+ * metadata for API responses.
+ */
+interface QueryResult {
+    /** Array of row objects returned by the query */
+    data: Array<Record<string, unknown>>;
+    /** Number of rows returned */
+    rowCount: number;
+    /** Name of the provider that executed the query */
+    provider?: string;
+    /** Whether this is mock/demo data */
+    mock?: boolean;
+    /** Optional message (e.g., for errors or warnings) */
+    message?: string;
+}
+
+export { InvalidProviderConfigurationError as I, MissingTableError as M, QueryError as Q, ProviderConnectionError as a, ProviderError as b };
+export type { ProviderConfiguration as P, QueryResult as c };