@gokiteam/goki-dev-client 0.2.2

package/dist/helpers.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * @gokiteam/goki-dev - Helper Utilities
+ *
+ * Common test helpers and utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = waitFor;
+exports.sleep = sleep;
+exports.verifyAcrossServices = verifyAcrossServices;
+exports.findErrorLogs = findErrorLogs;
+exports.createTestContext = createTestContext;
+exports.runTest = runTest;
+const client_1 = require("./client");
+/**
+ * Wait for async operation with custom polling
+ */
+async function waitFor(predicate, options = {}) {
+    const timeout = options.timeout || 5000;
+    const interval = options.interval || 100;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        const result = await predicate();
+        if (result !== null) {
+            return result;
+        }
+        await new Promise(resolve => setTimeout(resolve, interval));
+    }
+    throw new Error(options.timeoutMessage || `Timeout after ${timeout}ms`);
+}
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function verifyAcrossServices(client, traceId, expectations) {
+    const results = {};
+    // Database verification
+    if (expectations.database) {
+        const dbResult = await client.postgres.query({
+            ...expectations.database,
+            traceId
+        });
+        results.database = dbResult.rows;
+    }
+    // Redis verification
+    if (expectations.redis) {
+        const redisResult = await client.redis.get({ key: expectations.redis.key, traceId });
+        results.redis = redisResult.value ? JSON.parse(redisResult.value) : null;
+    }
+    // Pub/Sub verification
+    if (expectations.pubsub) {
+        const pubsubResult = await client.pubsub.getMessages({ filter: expectations.pubsub.filter, traceId });
+        results.pubsub = pubsubResult.messages;
+    }
+    // Firestore verification
+    if (expectations.firestore) {
+        const firestoreResult = await client.firestore.getDocument({
+            collection: expectations.firestore.collection,
+            documentId: expectations.firestore.documentId,
+            traceId
+        });
+        results.firestore = firestoreResult.document;
+    }
+    // Logging verification
+    if (expectations.logging) {
+        const logsResult = await client.logging.getByTrace({ traceId });
+        results.logs = logsResult.entries;
+    }
+    return results;
+}
+/**
+ * Find error logs in a trace
+ */
+async function findErrorLogs(client, traceId) {
+    const logs = await client.logging.getByTrace({ traceId });
+    return logs.entries.filter((e) => e.severity === 'ERROR' || e.severity === 'CRITICAL');
+}
+async function createTestContext(clientConfig) {
+    const client = new client_1.DevToolsClient(clientConfig);
+    const traceId = client.generateTraceId('test');
+    const cleanup = [];
+    return {
+        client,
+        traceId,
+        cleanup
+    };
+}
+async function runTest(name, testFn, clientConfig) {
+    console.log(`\nRunning: ${name}`);
+    const ctx = await createTestContext(clientConfig);
+    try {
+        await testFn(ctx);
+        console.log(`Passed: ${name}`);
+    }
+    catch (error) {
+        console.error(`Failed: ${name}`);
+        console.error(error);
+        // Export data on failure
+        try {
+            const exportData = await ctx.client.platform.export({ traceId: ctx.traceId });
+            console.log(`Test data exported for debugging`);
+            console.log(JSON.stringify(exportData, null, 2));
+        }
+        catch (exportError) {
+            console.error('Failed to export data:', exportError);
+        }
+        throw error;
+    }
+    finally {
+        // Run cleanup
+        for (const cleanupFn of ctx.cleanup) {
+            try {
+                await cleanupFn();
+            }
+            catch (error) {
+                console.error('Cleanup error:', error);
+            }
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @gokiteam/goki-dev-client - Client SDK
+ *
+ * HTTP client for interacting with the Goki Developer Tools platform.
+ *
+ * @example Simple usage (singleton)
+ * ```typescript
+ * import { devTools } from '@gokiteam/goki-dev-client'
+ *
+ * const traceId = devTools.generateTraceId('user-login-test')
+ *
+ * // Wait for message
+ * const message = await devTools.pubsub.waitForMessage({
+ *   filter: {
+ *     topic: 'user-events',
+ *     predicate: {
+ *       jsonPath: '$.event',
+ *       operator: 'equals',
+ *       value: 'user-login'
+ *     }
+ *   },
+ *   timeout: 5000,
+ *   traceId
+ * })
+ *
+ * // Verify logs
+ * const errors = await devTools.logging.assertNoErrors({ traceId })
+ * ```
+ *
+ * @example Advanced usage (custom instance)
+ * ```typescript
+ * import { DevToolsClient } from '@gokiteam/goki-dev-client'
+ *
+ * const devTools = new DevToolsClient({
+ *   baseUrl: 'http://custom-host:9000',
+ *   timeout: 60000
+ * })
+ * ```
+ */
+export { DevToolsClient } from './client';
+export * from './types';
+export * from './helpers';
+import { DevToolsClient } from './client';
+/**
+ * Default singleton instance of DevToolsClient
+ *
+ * Configured from environment variables:
+ * - DEV_TOOLS_BASE: Base URL (default: http://localhost:9000)
+ *
+ * @example
+ * ```typescript
+ * import { devTools } from '@gokiteam/goki-dev-client'
+ *
+ * const traceId = devTools.generateTraceId('test')
+ * const message = await devTools.pubsub.waitForMessage({ ... })
+ * const logs = await devTools.logging.getByTrace({ traceId })
+ * ```
+ */
+export declare const devTools: DevToolsClient;

package/dist/index.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * @gokiteam/goki-dev-client - Client SDK
+ *
+ * HTTP client for interacting with the Goki Developer Tools platform.
+ *
+ * @example Simple usage (singleton)
+ * ```typescript
+ * import { devTools } from '@gokiteam/goki-dev-client'
+ *
+ * const traceId = devTools.generateTraceId('user-login-test')
+ *
+ * // Wait for message
+ * const message = await devTools.pubsub.waitForMessage({
+ *   filter: {
+ *     topic: 'user-events',
+ *     predicate: {
+ *       jsonPath: '$.event',
+ *       operator: 'equals',
+ *       value: 'user-login'
+ *     }
+ *   },
+ *   timeout: 5000,
+ *   traceId
+ * })
+ *
+ * // Verify logs
+ * const errors = await devTools.logging.assertNoErrors({ traceId })
+ * ```
+ *
+ * @example Advanced usage (custom instance)
+ * ```typescript
+ * import { DevToolsClient } from '@gokiteam/goki-dev-client'
+ *
+ * const devTools = new DevToolsClient({
+ *   baseUrl: 'http://custom-host:9000',
+ *   timeout: 60000
+ * })
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devTools = exports.DevToolsClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "DevToolsClient", { enumerable: true, get: function () { return client_1.DevToolsClient; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./helpers"), exports);
+// Export default singleton instance for convenience
+const client_2 = require("./client");
+/**
+ * Default singleton instance of DevToolsClient
+ *
+ * Configured from environment variables:
+ * - DEV_TOOLS_BASE: Base URL (default: http://localhost:9000)
+ *
+ * @example
+ * ```typescript
+ * import { devTools } from '@gokiteam/goki-dev-client'
+ *
+ * const traceId = devTools.generateTraceId('test')
+ * const message = await devTools.pubsub.waitForMessage({ ... })
+ * const logs = await devTools.logging.getByTrace({ traceId })
+ * ```
+ */
+exports.devTools = new client_2.DevToolsClient();

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/types.d.ts

@@ -0,0 +1,339 @@
+/**
+ * @gokiteam/goki-dev - Type Definitions
+ *
+ * TypeScript types for the Goki Developer Tools Client SDK
+ */
+export interface StandardResponse<T = any> {
+    success: boolean;
+    status: number;
+    message: string;
+    data: T & {
+        traceId: string;
+    };
+}
+export interface PageOptions {
+    limit?: number;
+    offset?: number;
+}
+export interface TimeRange {
+    start: string;
+    end: string;
+}
+export interface PubSubMessage {
+    id: string;
+    message_id: string;
+    data: string;
+    attributes?: Record<string, string>;
+    ordering_key?: string;
+    publish_time: string;
+    topic: string;
+    sender?: string;
+    view_count: number;
+    last_viewed_at?: number;
+    created_at: number;
+}
+export interface PubSubTopic {
+    name: string;
+    labels?: Record<string, string>;
+}
+export interface PubSubSubscription {
+    name: string;
+    topic: string;
+    ackDeadlineSeconds: number;
+    pushConfig?: Record<string, any>;
+}
+export interface PubSubHistoryFilter {
+    topic?: string;
+    sender?: string;
+    timeRange?: TimeRange;
+}
+export type LogSeverity = 'DEFAULT' | 'DEBUG' | 'INFO' | 'NOTICE' | 'WARNING' | 'ERROR' | 'CRITICAL' | 'ALERT' | 'EMERGENCY';
+export interface LogEntry {
+    logName: string;
+    resource: {
+        type: string;
+        labels: Record<string, string>;
+    };
+    timestamp: string;
+    severity: LogSeverity;
+    textPayload?: string;
+    jsonPayload?: Record<string, any>;
+    trace?: string;
+    insertId: string;
+}
+export interface LogFilter {
+    service?: string;
+    severity?: LogSeverity[];
+    timeRange?: TimeRange;
+}
+export interface PostgresQueryRequest {
+    database: string;
+    query: string;
+    params?: any[];
+    traceId?: string;
+}
+export interface PostgresQueryResponse {
+    rows: any[];
+    rowCount: number;
+    traceId: string;
+}
+export interface RedisKey {
+    key: string;
+    type: string;
+    ttl: number;
+}
+export interface RedisValue {
+    key: string;
+    type: string;
+    value: string;
+    ttl: number;
+}
+export interface FirestoreDocument {
+    id: string;
+    data: Record<string, any>;
+}
+export interface FirestoreQuery {
+    field: string;
+    op: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not-in' | 'array-contains';
+    value: any;
+}
+export interface FirestoreWhereClause {
+    field: string;
+    operator: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not-in' | 'array-contains';
+    value: any;
+}
+export interface DeleteByQueryRequest {
+    collection: string;
+    where: FirestoreWhereClause;
+    traceId?: string;
+}
+export interface DeleteByQueryResponse {
+    deletedCount: number;
+    traceId: string;
+}
+export interface DeleteByPrefixRequest {
+    collection: string;
+    prefix: string;
+    traceId?: string;
+}
+export interface DeleteByPrefixResponse {
+    deletedCount: number;
+    traceId: string;
+}
+export interface DeleteBatchRequest {
+    collection: string;
+    documentIds: string[];
+    traceId?: string;
+}
+export interface DeleteBatchResponse {
+    deletedCount: number;
+    failedIds: string[];
+    traceId: string;
+}
+export interface MqttClientInfo {
+    clientId: string;
+    connected: boolean;
+    connectedAt: string;
+    subscriptions: string[];
+}
+export interface MqttMessage {
+    clientId: string;
+    topic: string;
+    payload: string;
+    qos: 0 | 1 | 2;
+    timestamp: string;
+}
+export interface WaitForMessageRequest {
+    filter: {
+        topic: string;
+        predicate?: {
+            jsonPath: string;
+            operator: 'equals' | 'notEquals' | 'contains' | 'greaterThan' | 'lessThan';
+            value: any;
+        };
+        sender?: string;
+    };
+    timeout?: number;
+    traceId?: string;
+}
+export interface WaitForMessageResponse {
+    message: PubSubMessage;
+    foundAt: number;
+    traceId: string;
+}
+export interface WaitForLogRequest {
+    filter: {
+        traceId?: string;
+        service?: string;
+        severity?: LogSeverity;
+        textContains?: string;
+    };
+    timeout?: number;
+    traceId?: string;
+}
+export interface WaitForLogResponse {
+    entry: LogEntry;
+    foundAt: number;
+    traceId: string;
+}
+export interface WaitForConditionRequest {
+    type: 'postgres' | 'redis' | 'firestore';
+    condition: {
+        database?: string;
+        query?: string;
+        params?: any[];
+        key?: string;
+        collection?: string;
+        documentId?: string;
+        expect: Record<string, any>;
+    };
+    timeout?: number;
+    pollInterval?: number;
+    traceId?: string;
+}
+export interface WaitForConditionResponse {
+    met: boolean;
+    foundAt: number;
+    actualValue?: any;
+    traceId: string;
+}
+export interface AssertMessagePublishedRequest {
+    filter: {
+        topic: string;
+        since?: string;
+        dataContains?: string;
+        attributesMatch?: Record<string, string>;
+    };
+    traceId?: string;
+}
+export interface AssertMessagePublishedResponse {
+    found: boolean;
+    count: number;
+    firstMatch?: Partial<PubSubMessage>;
+    traceId: string;
+}
+export interface AssertNoErrorsRequest {
+    traceId: string;
+    sinceTimestamp?: string;
+}
+export interface AssertNoErrorsResponse {
+    hasErrors: boolean;
+    errorCount: number;
+    criticalCount: number;
+    errors?: Partial<LogEntry>[];
+    traceId: string;
+}
+export interface ClearServiceDataRequest {
+    services: ('pubsub' | 'logging' | 'mqtt' | 'redis' | 'postgres' | 'firestore')[];
+    keepSystemData?: boolean;
+    traceId?: string;
+}
+export interface ClearServiceDataResponse {
+    cleared: Record<string, number>;
+    traceId: string;
+}
+export interface SchedulerTickRequest {
+    traceId?: string;
+}
+export interface SchedulerTickResponse {
+    tickTime: string;
+    published: boolean;
+    traceId: string;
+}
+export interface PlatformStats {
+    topics: number;
+    subscriptions: number;
+    messages: number;
+    logEntries: number;
+    mqttClients: number;
+    mqttMessages: number;
+}
+export interface ExportData {
+    pubsub: {
+        topics: PubSubTopic[];
+        subscriptions: PubSubSubscription[];
+        messages: PubSubMessage[];
+    };
+    logging: {
+        entries: LogEntry[];
+    };
+    mqtt: {
+        clients: MqttClientInfo[];
+        messages: MqttMessage[];
+    };
+}
+export interface DockerContainer {
+    name: string;
+    containerName: string;
+    displayName: string;
+    description: string;
+    status: 'running' | 'stopped' | 'created' | 'restarting' | 'paused' | 'unknown';
+    statusText: string;
+    uptime: string | null;
+    ports: number | null;
+    image: string;
+    capabilities: {
+        canStart: boolean;
+        canStop: boolean;
+        canRestart: boolean;
+    };
+}
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export interface HttpTrafficEntry {
+    _id: string;
+    method: string;
+    targetUrl: string;
+    targetHost: string | null;
+    targetPath: string | null;
+    queryParams: string | null;
+    requestHeaders: string | null;
+    requestBody: string | null;
+    requestCookies: string | null;
+    contentType: string | null;
+    statusCode: number | null;
+    responseHeaders: string | null;
+    responseBody: string | null;
+    responseContentType: string | null;
+    responseTimeMs: number | null;
+    startedAt: string;
+    completedAt: string | null;
+    sourceService: string | null;
+    error: string | null;
+    traceId: string | null;
+    createdAt: string;
+}
+export interface HttpTrafficFilter {
+    method?: HttpMethod;
+    targetHost?: string;
+    sourceService?: string;
+    statusCode?: number;
+    traceId?: string;
+    since?: string;
+    until?: string;
+}
+export interface HttpTrafficWaitFilter {
+    method?: HttpMethod;
+    targetHost?: string;
+    sourceService?: string;
+    statusCode?: number;
+    traceId?: string;
+    pathContains?: string;
+}
+export interface HttpTrafficStats {
+    total: number;
+    errorCount: number;
+    errorRate: string;
+    avgResponseTimeMs: number;
+    byMethod: {
+        method: string;
+        count: number;
+    }[];
+    byHost: {
+        source_service: string | null;
+        count: number;
+    }[];
+    byStatus: {
+        status_code: number | null;
+        count: number;
+    }[];
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @gokiteam/goki-dev - Type Definitions
+ *
+ * TypeScript types for the Goki Developer Tools Client SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@gokiteam/goki-dev-client",
+  "version": "0.2.2",
+  "description": "Client SDK for Goki Developer Tools platform",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc && echo '{\"type\":\"commonjs\"}' > dist/package.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "goki",
+    "dev-tools",
+    "client",
+    "sdk"
+  ],
+  "author": "Goki Team",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}