@gokiteam/goki-dev-client 0.2.2

package/dist/client.d.ts

@@ -0,0 +1,380 @@
+/**
+ * @gokiteam/goki-dev-client - Main Client
+ *
+ * HTTP client for Goki Developer Tools
+ */
+import { AxiosInstance } from 'axios';
+import type * as Types from './types';
+export interface DevToolsClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+}
+export declare class PubSubClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    /**
+     * Extract short topic name from a full path like 'projects/X/topics/Y' -> 'Y'
+     */
+    private extractTopicName;
+    publish(params: {
+        topic: string;
+        message: any;
+        attributes?: Record<string, string>;
+        traceId?: string;
+    }): Promise<{
+        messageIds: string[];
+    } & {
+        traceId: string;
+    }>;
+    waitForMessage(params: Types.WaitForMessageRequest): Promise<Types.WaitForMessageResponse>;
+    assertMessagePublished(params: Types.AssertMessagePublishedRequest): Promise<Types.AssertMessagePublishedResponse>;
+    getMessages(params?: {
+        filter?: Types.PubSubHistoryFilter;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        messages: Types.PubSubMessage[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    searchMessages(params: {
+        query: string;
+        filter?: Partial<Types.PubSubHistoryFilter>;
+        traceId?: string;
+    }): Promise<{
+        messages: Types.PubSubMessage[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    listTopics(params?: {
+        traceId?: string;
+    }): Promise<{
+        topics: Types.PubSubTopic[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    createTopic(params: {
+        topic: string;
+        traceId?: string;
+    }): Promise<{
+        topic: Types.PubSubTopic;
+    } & {
+        traceId: string;
+    }>;
+    deleteTopic(params: {
+        topic: string;
+        traceId?: string;
+    }): Promise<void>;
+}
+export declare class LoggingClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    getByTrace(params: {
+        traceId: string;
+        queryTraceId?: string;
+    }): Promise<{
+        traceId: string;
+        entries: Types.LogEntry[];
+        count: number;
+    }>;
+    list(params?: {
+        filter?: Types.LogFilter;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        entries: Types.LogEntry[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    clear(params?: {
+        service?: string;
+        traceId?: string;
+    }): Promise<{
+        deletedCount: number;
+    } & {
+        traceId: string;
+    }>;
+    waitForLog(params: Types.WaitForLogRequest): Promise<Types.WaitForLogResponse>;
+    assertNoErrors(params: Types.AssertNoErrorsRequest): Promise<Types.AssertNoErrorsResponse>;
+}
+export declare class PostgresClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    query(params: Types.PostgresQueryRequest): Promise<Types.PostgresQueryResponse>;
+    listTables(params: {
+        database: string;
+        schema?: string;
+        traceId?: string;
+    }): Promise<{
+        tables: {
+            name: string;
+            rowCount: number;
+        }[];
+    } & {
+        traceId: string;
+    }>;
+    listRows(params: {
+        database: string;
+        schema: string;
+        table: string;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        rows: any[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    waitForCondition(params: Types.WaitForConditionRequest & {
+        type: 'postgres';
+    }): Promise<Types.WaitForConditionResponse>;
+}
+export declare class RedisClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    get(params: {
+        key: string;
+        traceId?: string;
+    }): Promise<Types.RedisValue>;
+    scan(params: {
+        pattern: string;
+        count?: number;
+        traceId?: string;
+    }): Promise<{
+        keys: Types.RedisKey[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+    delete(params: {
+        key: string;
+        traceId?: string;
+    }): Promise<{
+        deleted: boolean;
+    } & {
+        traceId: string;
+    }>;
+    deletePattern(params: {
+        pattern: string;
+        traceId?: string;
+    }): Promise<{
+        deletedCount: number;
+    } & {
+        traceId: string;
+    }>;
+    waitForCondition(params: Types.WaitForConditionRequest & {
+        type: 'redis';
+    }): Promise<Types.WaitForConditionResponse>;
+}
+export declare class FirestoreClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    /**
+     * Parses a Firestore REST API typed value into a plain JS value.
+     */
+    private parseFirestoreValue;
+    /**
+     * Parses Firestore REST API fields object into a plain JS object.
+     */
+    private parseFirestoreFields;
+    /**
+     * Converts a raw Firestore REST API document to a clean FirestoreDocument.
+     * Raw format: { name: "projects/.../documents/collection/id", fields: { key: { stringValue: "..." } }, ... }
+     * Clean format: { id: "docId", data: { key: "..." } }
+     */
+    private parseRawDocument;
+    getDocument(params: {
+        collection: string;
+        documentId: string;
+        traceId?: string;
+    }): Promise<{
+        document: Types.FirestoreDocument;
+    }>;
+    query(params: {
+        collection: string;
+        where: Types.FirestoreQuery;
+        traceId?: string;
+    }): Promise<{
+        documents: Types.FirestoreDocument[];
+    }>;
+    listDocuments(params: {
+        collection: string;
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        documents: Types.FirestoreDocument[];
+        total: number;
+    }>;
+    deleteByQuery(params: Types.DeleteByQueryRequest): Promise<Types.DeleteByQueryResponse>;
+    deleteByPrefix(params: Types.DeleteByPrefixRequest): Promise<Types.DeleteByPrefixResponse>;
+    deleteBatch(params: Types.DeleteBatchRequest): Promise<Types.DeleteBatchResponse>;
+    waitForCondition(params: Types.WaitForConditionRequest & {
+        type: 'firestore';
+    }): Promise<Types.WaitForConditionResponse>;
+}
+export declare class MqttClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    listClients(params?: {
+        traceId?: string;
+    }): Promise<{
+        clients: Types.MqttClientInfo[];
+    } & {
+        traceId: string;
+    }>;
+    getMessages(params?: {
+        filter?: {
+            clientId?: string;
+            topic?: string;
+        };
+        page?: Types.PageOptions;
+        traceId?: string;
+    }): Promise<{
+        messages: Types.MqttMessage[];
+        total: number;
+    } & {
+        traceId: string;
+    }>;
+}
+export declare class DockerClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    list(params?: {
+        traceId?: string;
+    }): Promise<{
+        data: Types.DockerContainer[];
+    } & {
+        traceId: string;
+    }>;
+    start(params: {
+        containerName: string;
+        traceId?: string;
+    }): Promise<void>;
+    stop(params: {
+        containerName: string;
+        traceId?: string;
+    }): Promise<void>;
+    restart(params: {
+        containerName: string;
+        traceId?: string;
+    }): Promise<void>;
+    logs(params: {
+        containerName: string;
+        lines?: number;
+        traceId?: string;
+    }): Promise<{
+        data: string;
+    } & {
+        traceId: string;
+    }>;
+}
+export declare class PlatformClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    getStats(params?: {
+        traceId?: string;
+    }): Promise<{
+        stats: Types.PlatformStats;
+    } & {
+        traceId: string;
+    }>;
+    clearAll(params?: {
+        traceId?: string;
+    }): Promise<{
+        cleared: Record<string, number>;
+    } & {
+        traceId: string;
+    }>;
+    clearServices(params: Types.ClearServiceDataRequest): Promise<Types.ClearServiceDataResponse>;
+    export(params?: {
+        traceId?: string;
+    }): Promise<{
+        export: Types.ExportData;
+    } & {
+        traceId: string;
+    }>;
+}
+export declare class SchedulerClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    triggerTick(params?: {
+        traceId?: string;
+    }): Promise<Types.SchedulerTickResponse>;
+}
+export declare class HttpTrafficClient {
+    private client;
+    constructor(client: AxiosInstance);
+    private call;
+    list(params?: {
+        filter?: Types.HttpTrafficFilter;
+        limit?: number;
+        offset?: number;
+        traceId?: string;
+    }): Promise<{
+        entries: Types.HttpTrafficEntry[];
+        total: number;
+        limit: number;
+        offset: number;
+    } & {
+        traceId: string;
+    }>;
+    getDetails(params: {
+        id: string;
+        traceId?: string;
+    }): Promise<{
+        entry: Types.HttpTrafficEntry;
+    } & {
+        traceId: string;
+    }>;
+    clear(params?: {
+        traceId?: string;
+    }): Promise<{
+        message: string;
+    } & {
+        traceId: string;
+    }>;
+    waitFor(params: {
+        filter: Types.HttpTrafficWaitFilter;
+        timeout?: number;
+        traceId?: string;
+    }): Promise<{
+        entry: Types.HttpTrafficEntry;
+        foundAt: number;
+        traceId: string;
+    }>;
+    stats(params?: {
+        traceId?: string;
+    }): Promise<Types.HttpTrafficStats & {
+        traceId: string;
+    }>;
+}
+export declare class DevToolsClient {
+    private client;
+    private baseUrl;
+    pubsub: PubSubClient;
+    logging: LoggingClient;
+    postgres: PostgresClient;
+    redis: RedisClient;
+    firestore: FirestoreClient;
+    mqtt: MqttClient;
+    docker: DockerClient;
+    platform: PlatformClient;
+    scheduler: SchedulerClient;
+    httpTraffic: HttpTrafficClient;
+    constructor(config?: DevToolsClientConfig);
+    generateTraceId(prefix?: string): string;
+}
+export * from './types';