@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/connector-postgres/dist/live-database-introspection.js

@@ -0,0 +1,21 @@
+import { KtxPostgresScanConnector, } from './connector.js';
+export function createPostgresLiveDatabaseIntrospection(options) {
+    return {
+        async extractSchema(connectionId) {
+            const connection = options.connections[connectionId];
+            const connector = new KtxPostgresScanConnector({
+                connectionId,
+                connection,
+                poolFactory: options.poolFactory,
+                endpointResolver: options.endpointResolver,
+                now: options.now,
+            });
+            try {
+                return await connector.introspect({ connectionId, driver: 'postgres' }, { runId: `postgres-${connectionId}` });
+            }
+            finally {
+                await connector.cleanup();
+            }
+        },
+    };
+}

package/node_modules/@ktx/connector-postgres/dist/package-exports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@ktx/connector-postgres/dist/package-exports.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+describe('@ktx/connector-postgres package exports', () => {
+    it('exports the connector, dialect, and live-database adapter', async () => {
+        const connector = await import('./index.js');
+        expect(connector.KtxPostgresDialect).toBeTypeOf('function');
+        expect(connector.KtxPostgresScanConnector).toBeTypeOf('function');
+        expect(connector.KtxPostgresHistoricSqlQueryClient).toBeTypeOf('function');
+        expect(connector.createPostgresLiveDatabaseIntrospection).toBeTypeOf('function');
+        expect(connector.isKtxPostgresConnectionConfig).toBeTypeOf('function');
+        expect(connector.postgresPoolConfigFromConfig).toBeTypeOf('function');
+    });
+});

package/node_modules/@ktx/connector-postgres/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@ktx/connector-postgres",
+  "version": "0.0.0-private",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "pg": "^8.19.0"
+  },
+  "license": "Apache-2.0"
+}

package/node_modules/@ktx/connector-posthog/dist/connector.d.ts

@@ -0,0 +1,90 @@
+import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxEventStreamDiscoveryPort, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '@ktx/context/scan';
+import { type KtxPostHogSampleColumnInfo } from './dialect.js';
+export interface KtxPostHogConnectionConfig {
+    driver?: string;
+    api_key?: string;
+    apiKey?: string;
+    project_id?: string;
+    projectId?: string;
+    region?: 'us' | 'eu';
+    host?: string;
+    readonly?: boolean;
+    [key: string]: unknown;
+}
+export interface KtxPostHogResolvedConnectionConfig {
+    apiKey: string;
+    projectId: string;
+    baseUrl: string;
+}
+export type KtxPostHogFetch = (url: string, init?: RequestInit) => Promise<Response>;
+export interface KtxPostHogScanConnectorOptions {
+    connectionId: string;
+    connection: KtxPostHogConnectionConfig | undefined;
+    env?: NodeJS.ProcessEnv;
+    fetch?: KtxPostHogFetch;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => Date;
+}
+export interface KtxPostHogReadOnlyQueryInput extends KtxReadOnlyQueryInput {
+    params?: Record<string, unknown>;
+}
+export interface KtxPostHogColumnDistinctValuesOptions {
+    maxCardinality: number;
+    limit: number;
+    sampleSize?: number;
+}
+export interface KtxPostHogColumnDistinctValuesResult {
+    values: string[] | null;
+    cardinality: number;
+}
+export declare function isKtxPostHogConnectionConfig(connection: KtxPostHogConnectionConfig | undefined): boolean;
+export declare function postHogConnectionConfigFromConfig(input: {
+    connectionId: string;
+    connection: KtxPostHogConnectionConfig | undefined;
+    env?: NodeJS.ProcessEnv;
+}): KtxPostHogResolvedConnectionConfig;
+export declare class KtxPostHogScanConnector implements KtxScanConnector {
+    readonly id: string;
+    readonly driver: "posthog";
+    readonly capabilities: import("@ktx/context/scan").KtxConnectorCapabilities;
+    readonly eventStreamDiscovery: KtxEventStreamDiscoveryPort;
+    private readonly connectionId;
+    private readonly resolved;
+    private readonly fetchImpl;
+    private readonly sleep;
+    private readonly now;
+    private readonly dialect;
+    constructor(options: KtxPostHogScanConnectorOptions);
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    introspect(input: KtxScanInput, _ctx: KtxScanContext): Promise<KtxSchemaSnapshot>;
+    sampleTable(input: KtxTableSampleInput & {
+        columnMetadata?: KtxPostHogSampleColumnInfo[];
+    }, _ctx: KtxScanContext): Promise<KtxTableSampleResult>;
+    sampleColumn(input: KtxColumnSampleInput, _ctx: KtxScanContext): Promise<KtxColumnSampleResult>;
+    columnStats(_input: KtxColumnStatsInput, _ctx: KtxScanContext): Promise<KtxColumnStatsResult | null>;
+    executeReadOnly(input: KtxPostHogReadOnlyQueryInput, _ctx: KtxScanContext): Promise<KtxQueryResult>;
+    getTableRowCount(tableName: string): Promise<number>;
+    getColumnDistinctValues(table: KtxTableRef, columnName: string, options: KtxPostHogColumnDistinctValuesOptions): Promise<KtxPostHogColumnDistinctValuesResult | null>;
+    private listEventTypes;
+    private listPropertyKeys;
+    private listPropertyValues;
+    cleanup(): Promise<void>;
+    qTableName(table: Pick<KtxTableRef, 'name'>): string;
+    quoteIdentifier(identifier: string): string;
+    private toSchemaTable;
+    private discoverHiddenTables;
+    private extractColumns;
+    private normalizeFieldType;
+    private isNullableField;
+    private isPrimaryKeyField;
+    private query;
+    private makeRequest;
+    private parseErrorMessage;
+    private parseRateLimitWaitTime;
+    private escapeHogQLString;
+    private positiveInteger;
+    private assertConnection;
+}

package/node_modules/@ktx/connector-posthog/dist/connector.js

@@ -0,0 +1,441 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { assertReadOnlySql, limitSqlForExecution } from '@ktx/context/connections';
+import { createKtxConnectorCapabilities, } from '@ktx/context/scan';
+import { KtxPostHogDialect } from './dialect.js';
+import { getKtxPostHogColumnDescription, getKtxPostHogTableDescription } from './schema-descriptions.js';
+const allowedTableTypes = new Set(['posthog', 'system']);
+const excludedTables = new Set([
+    'query_log',
+    'system.teams',
+    'system.exports',
+    'system.ingestion_warnings',
+    'system.insight_variables',
+    'system.data_warehouse_sources',
+    'system.groups',
+    'system.group_type_mappings',
+]);
+const hiddenTablesToProbe = ['person_distinct_ids', 'cohort_people', 'static_cohort_people'];
+export function isKtxPostHogConnectionConfig(connection) {
+    return String(connection?.driver ?? '').toLowerCase() === 'posthog';
+}
+function resolveStringReference(value, env) {
+    if (value.startsWith('env:')) {
+        return env[value.slice('env:'.length)] ?? '';
+    }
+    if (value.startsWith('file:')) {
+        const rawPath = value.slice('file:'.length);
+        const path = rawPath.startsWith('~') ? resolve(homedir(), rawPath.slice(1)) : rawPath;
+        return readFileSync(path, 'utf-8').trim();
+    }
+    return value;
+}
+function stringConfigValue(connection, key, env) {
+    const value = connection?.[key];
+    return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(value.trim(), env) : undefined;
+}
+export function postHogConnectionConfigFromConfig(input) {
+    if (!isKtxPostHogConnectionConfig(input.connection)) {
+        throw new Error(`Native PostHog connector cannot run driver "${input.connection?.driver ?? 'unknown'}"`);
+    }
+    if (input.connection?.readonly !== true) {
+        throw new Error(`Native PostHog connector requires connections.${input.connectionId}.readonly: true`);
+    }
+    const env = input.env ?? process.env;
+    const apiKey = stringConfigValue(input.connection, 'api_key', env) ?? stringConfigValue(input.connection, 'apiKey', env);
+    const projectId = stringConfigValue(input.connection, 'project_id', env) ?? stringConfigValue(input.connection, 'projectId', env);
+    if (!apiKey) {
+        throw new Error(`Native PostHog connector requires connections.${input.connectionId}.api_key`);
+    }
+    if (!projectId) {
+        throw new Error(`Native PostHog connector requires connections.${input.connectionId}.project_id`);
+    }
+    const host = stringConfigValue(input.connection, 'host', env);
+    const region = input.connection?.region ?? 'us';
+    return {
+        apiKey,
+        projectId,
+        baseUrl: host ? host.replace(/\/$/, '') : region === 'eu' ? 'https://eu.posthog.com' : 'https://us.posthog.com',
+    };
+}
+export class KtxPostHogScanConnector {
+    id;
+    driver = 'posthog';
+    capabilities = createKtxConnectorCapabilities({
+        tableSampling: true,
+        columnSampling: true,
+        columnStats: false,
+        readOnlySql: true,
+        nestedAnalysis: true,
+        eventStreamDiscovery: true,
+        formalForeignKeys: false,
+        estimatedRowCounts: true,
+    });
+    eventStreamDiscovery = {
+        listEventTypes: (input, ctx) => this.listEventTypes(input, ctx),
+        listPropertyKeys: (input, ctx) => this.listPropertyKeys(input, ctx),
+        listPropertyValues: (input, ctx) => this.listPropertyValues(input, ctx),
+    };
+    connectionId;
+    resolved;
+    fetchImpl;
+    sleep;
+    now;
+    dialect = new KtxPostHogDialect();
+    constructor(options) {
+        this.connectionId = options.connectionId;
+        this.resolved = postHogConnectionConfigFromConfig({
+            connectionId: options.connectionId,
+            connection: options.connection,
+            env: options.env,
+        });
+        this.fetchImpl = options.fetch ?? fetch;
+        this.sleep = options.sleep ?? ((ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms)));
+        this.now = options.now ?? (() => new Date());
+        this.id = `posthog:${options.connectionId}`;
+    }
+    async testConnection() {
+        const response = await this.query('SELECT 1 AS test');
+        return response.error ? { success: false, error: response.error } : { success: true };
+    }
+    async introspect(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const response = await this.makeRequest('/query', { query: { kind: 'DatabaseSchemaQuery' } });
+        const tables = [];
+        for (const [tableName, tableInfo] of Object.entries(response.tables ?? {})) {
+            if (!allowedTableTypes.has(tableInfo.type) || excludedTables.has(tableName)) {
+                continue;
+            }
+            tables.push(this.toSchemaTable(tableName, tableInfo));
+        }
+        tables.push(...(await this.discoverHiddenTables()));
+        tables.sort((left, right) => left.name.localeCompare(right.name));
+        return {
+            connectionId: this.connectionId,
+            driver: 'posthog',
+            extractedAt: this.now().toISOString(),
+            scope: { catalogs: [this.resolved.projectId] },
+            metadata: {
+                project_id: this.resolved.projectId,
+                table_count: tables.length,
+                total_columns: tables.reduce((sum, table) => sum + table.columns.length, 0),
+            },
+            tables,
+        };
+    }
+    async sampleTable(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const sql = input.columnMetadata
+            ? this.dialect.generateSampleQueryWithMetadata(this.qTableName(input.table), input.limit, input.columnMetadata)
+            : this.dialect.generateSampleQuery(this.qTableName(input.table), input.limit, input.columns);
+        const result = await this.query(sql);
+        return { headers: result.headers, rows: result.rows, totalRows: result.totalRows };
+    }
+    async sampleColumn(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const result = await this.query(this.dialect.generateColumnSampleQuery(this.qTableName(input.table), input.column, input.limit));
+        const values = result.rows.filter((row) => row.length > 0 && row[0] !== null).map((row) => row[0]);
+        return { values, nullCount: null, distinctCount: null };
+    }
+    async columnStats(_input, _ctx) {
+        return null;
+    }
+    async executeReadOnly(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const limitedSql = limitSqlForExecution(assertReadOnlySql(input.sql), input.maxRows);
+        const prepared = this.dialect.prepareQuery(limitedSql, input.params);
+        const result = await this.query(prepared.sql, prepared.params);
+        return { ...result, rowCount: result.rows.length };
+    }
+    async getTableRowCount(tableName) {
+        const result = await this.query(`SELECT count() AS cnt FROM ${this.dialect.quoteIdentifier(tableName)}`);
+        return Number(result.rows[0]?.[0] ?? 0);
+    }
+    async getColumnDistinctValues(table, columnName, options) {
+        const sampleSize = options.sampleSize ?? 10000;
+        const tableName = this.qTableName(table);
+        const cardinalityResult = await this.query(this.dialect.generateCardinalitySampleQuery(tableName, columnName, sampleSize));
+        if (cardinalityResult.error || cardinalityResult.rows.length === 0) {
+            return null;
+        }
+        const cardinality = Number(cardinalityResult.rows[0]?.[0]);
+        if (!Number.isFinite(cardinality)) {
+            return null;
+        }
+        if (cardinality === 0) {
+            return { values: [], cardinality: 0 };
+        }
+        if (cardinality > options.maxCardinality) {
+            return { values: null, cardinality };
+        }
+        const valuesResult = await this.query(this.dialect.generateDistinctValuesQuery(tableName, columnName, options.limit));
+        if (valuesResult.error) {
+            return null;
+        }
+        return {
+            values: valuesResult.rows.filter((row) => row[0] !== null).map((row) => String(row[0])),
+            cardinality,
+        };
+    }
+    async listEventTypes(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const limit = this.positiveInteger(input.limit, 'limit');
+        const lookbackDays = this.positiveInteger(input.lookbackDays ?? 30, 'lookbackDays');
+        const minCount = this.positiveInteger(input.minCount ?? 0, 'minCount');
+        const eventColumn = this.dialect.quoteIdentifier(input.eventColumn);
+        const tableName = this.qTableName(input.table);
+        const havingClause = minCount > 0 ? `HAVING cnt >= ${minCount}` : '';
+        const result = await this.query(`
+      SELECT ${eventColumn} AS event, count() as cnt
+      FROM ${tableName}
+      WHERE timestamp > now() - INTERVAL ${lookbackDays} DAY
+      GROUP BY event
+      ${havingClause}
+      ORDER BY cnt DESC
+      LIMIT ${limit}
+    `);
+        if (result.error) {
+            return [];
+        }
+        return result.rows
+            .filter((row) => row[0] != null && String(row[0]).trim() !== '')
+            .map((row) => ({ value: String(row[0]), count: Number(row[1]) }));
+    }
+    async listPropertyKeys(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const sampleSize = this.positiveInteger(input.sampleSize, 'sampleSize');
+        const limit = this.positiveInteger(input.limit, 'limit');
+        const lookbackDays = input.lookbackDays === undefined ? null : this.positiveInteger(input.lookbackDays, 'lookbackDays');
+        const tableName = this.qTableName(input.table);
+        const jsonColumn = this.dialect.quoteIdentifier(input.jsonColumn);
+        const whereClause = lookbackDays === null ? '' : `WHERE timestamp > now() - INTERVAL ${lookbackDays} DAY`;
+        const result = await this.query(`
+      SELECT key, count() as cnt
+      FROM (
+        SELECT arrayJoin(JSONExtractKeys(${jsonColumn})) AS key
+        FROM ${tableName}
+        ${whereClause}
+        LIMIT ${sampleSize}
+      )
+      GROUP BY key
+      ORDER BY cnt DESC
+      LIMIT ${limit}
+    `);
+        if (result.error) {
+            return [];
+        }
+        return result.rows.map((row) => ({ key: String(row[0]), count: Number(row[1]) }));
+    }
+    async listPropertyValues(input, _ctx) {
+        this.assertConnection(input.connectionId);
+        const limit = this.positiveInteger(input.limit, 'limit');
+        const maxCardinality = this.positiveInteger(input.maxCardinality ?? 1000, 'maxCardinality');
+        const lookbackDays = input.lookbackDays === undefined ? null : this.positiveInteger(input.lookbackDays, 'lookbackDays');
+        const tableName = this.qTableName(input.table);
+        const jsonColumn = this.dialect.quoteIdentifier(input.jsonColumn);
+        const escapedKey = this.escapeHogQLString(input.propertyKey);
+        const timeFilter = lookbackDays === null ? '' : `WHERE timestamp > now() - INTERVAL ${lookbackDays} DAY`;
+        const cardinalityResult = await this.query(`
+      SELECT uniq(JSONExtractString(${jsonColumn}, '${escapedKey}')) as cardinality
+      FROM ${tableName}
+      ${timeFilter}
+      LIMIT 1000000
+    `);
+        if (cardinalityResult.error || cardinalityResult.rows.length === 0) {
+            return null;
+        }
+        const cardinality = Number(cardinalityResult.rows[0]?.[0]);
+        if (!Number.isFinite(cardinality) || cardinality > maxCardinality) {
+            return null;
+        }
+        const valuesResult = await this.query(`
+      SELECT DISTINCT JSONExtractString(${jsonColumn}, '${escapedKey}') as value
+      FROM ${tableName}
+      WHERE JSONExtractString(${jsonColumn}, '${escapedKey}') IS NOT NULL
+        AND JSONExtractString(${jsonColumn}, '${escapedKey}') != ''
+        ${lookbackDays === null ? '' : `AND timestamp > now() - INTERVAL ${lookbackDays} DAY`}
+      ORDER BY value
+      LIMIT ${limit}
+    `);
+        if (valuesResult.error) {
+            return null;
+        }
+        const values = valuesResult.rows
+            .map((row) => (row[0] != null ? String(row[0]) : ''))
+            .filter((value) => {
+            const trimmed = value.trim();
+            return trimmed !== '' && trimmed !== '[]' && trimmed !== '{}' && trimmed !== 'null';
+        });
+        return { values, cardinality };
+    }
+    async cleanup() { }
+    qTableName(table) {
+        return this.dialect.formatTableName(table);
+    }
+    quoteIdentifier(identifier) {
+        return this.dialect.quoteIdentifier(identifier);
+    }
+    toSchemaTable(tableName, tableInfo) {
+        return {
+            catalog: this.resolved.projectId,
+            db: null,
+            name: tableName,
+            kind: tableName === 'events' ? 'event_stream' : 'table',
+            comment: getKtxPostHogTableDescription(tableName) ?? null,
+            estimatedRows: tableInfo.row_count ?? null,
+            columns: this.extractColumns(tableName, tableInfo.fields),
+            foreignKeys: [],
+        };
+    }
+    async discoverHiddenTables() {
+        const tables = [];
+        for (const tableName of hiddenTablesToProbe) {
+            const result = await this.query(`SELECT * FROM ${tableName} LIMIT 0`);
+            if (result.error) {
+                continue;
+            }
+            tables.push({
+                catalog: this.resolved.projectId,
+                db: null,
+                name: tableName,
+                kind: 'table',
+                comment: getKtxPostHogTableDescription(tableName) ?? null,
+                estimatedRows: null,
+                columns: result.headers.map((header) => ({
+                    name: header,
+                    nativeType: 'String',
+                    normalizedType: 'VARCHAR',
+                    dimensionType: 'string',
+                    nullable: true,
+                    primaryKey: false,
+                    comment: getKtxPostHogColumnDescription(tableName, header) ?? null,
+                })),
+                foreignKeys: [],
+            });
+        }
+        return tables;
+    }
+    extractColumns(tableName, fields) {
+        const columns = [];
+        for (const [fieldName, fieldInfo] of Object.entries(fields)) {
+            if (fieldInfo.type === 'lazy_table' ||
+                fieldInfo.type === 'virtual_table' ||
+                fieldInfo.type === 'field_traverser' ||
+                fieldInfo.type === 'expression') {
+                continue;
+            }
+            const nativeType = this.normalizeFieldType(fieldInfo.type);
+            columns.push({
+                name: fieldName,
+                nativeType,
+                normalizedType: this.dialect.mapDataType(nativeType),
+                dimensionType: this.dialect.mapToDimensionType(nativeType),
+                nullable: this.isNullableField(tableName, fieldName, fieldInfo.type),
+                primaryKey: this.isPrimaryKeyField(tableName, fieldName),
+                comment: getKtxPostHogColumnDescription(tableName, fieldName) ?? null,
+            });
+        }
+        return columns;
+    }
+    normalizeFieldType(posthogType) {
+        const typeMap = {
+            string: 'String',
+            integer: 'Int64',
+            datetime: 'DateTime64',
+            boolean: 'UInt8',
+            bool: 'Boolean',
+            json: 'JSON',
+            array: 'Array(String)',
+            uuid: 'UUID',
+            event: 'String',
+        };
+        return typeMap[posthogType.toLowerCase()] ?? posthogType;
+    }
+    isNullableField(tableName, fieldName, fieldType) {
+        if (tableName === 'events' && ['uuid', 'event', 'timestamp', 'distinct_id'].includes(fieldName)) {
+            return false;
+        }
+        return !['uuid', 'event', 'timestamp', 'distinct_id'].includes(fieldType.toLowerCase());
+    }
+    isPrimaryKeyField(tableName, fieldName) {
+        return ((tableName === 'events' && fieldName === 'uuid') ||
+            (tableName === 'persons' && fieldName === 'id') ||
+            (tableName === 'sessions' && fieldName === 'session_id') ||
+            (tableName === 'groups' && fieldName === 'key'));
+    }
+    async query(sql, params) {
+        const response = await this.makeRequest('/query', {
+            query: {
+                kind: 'HogQLQuery',
+                query: sql,
+                ...(params && Object.keys(params).length > 0 ? { values: params } : {}),
+            },
+        });
+        if (response.error) {
+            return { headers: [], rows: [], totalRows: 0, rowCount: null, error: response.error };
+        }
+        const headers = response.columns ?? [];
+        const rows = response.results ?? [];
+        const headerTypes = response.types?.map((type) => type[1]);
+        return {
+            headers,
+            rows,
+            totalRows: rows.length,
+            rowCount: rows.length,
+            ...(headerTypes && headerTypes.length > 0 ? { headerTypes } : {}),
+        };
+    }
+    async makeRequest(endpoint, body, maxRetries = 3) {
+        const url = `${this.resolved.baseUrl}/api/projects/${this.resolved.projectId}${endpoint}`;
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+            const response = await this.fetchImpl(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.resolved.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            const errorText = await response.text();
+            const errorMessage = this.parseErrorMessage(errorText);
+            if (response.status === 429 && attempt < maxRetries) {
+                await this.sleep(this.parseRateLimitWaitTime(errorMessage) * 1000);
+                continue;
+            }
+            lastError = new Error(`PostHog API error (${response.status}): ${errorMessage}`);
+        }
+        throw lastError ?? new Error('PostHog API request failed after retries');
+    }
+    parseErrorMessage(errorText) {
+        try {
+            const errorJson = JSON.parse(errorText);
+            return String(errorJson.detail ?? errorJson.error ?? errorText);
+        }
+        catch {
+            return errorText;
+        }
+    }
+    parseRateLimitWaitTime(errorMessage) {
+        const match = errorMessage.match(/(?:Expected available in|retry after) (\d+) seconds?/i);
+        return match ? Number.parseInt(match[1] ?? '30', 10) + 2 : 30;
+    }
+    escapeHogQLString(value) {
+        return value.replace(/\\/g, '\\\\').replace(/'/g, "''");
+    }
+    positiveInteger(value, name) {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`PostHog event-stream discovery requires ${name} to be a non-negative integer`);
+        }
+        return value;
+    }
+    assertConnection(connectionId) {
+        if (connectionId !== this.connectionId) {
+            throw new Error(`PostHog connector ${this.connectionId} cannot scan connection ${connectionId}`);
+        }
+    }
+}

package/node_modules/@ktx/connector-posthog/dist/connector.test.d.ts

@@ -0,0 +1 @@
+export {};