@gokiteam/goki-dev 0.2.0

package/client/dist/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @gokiteam/goki-dev - Client SDK
+ *
+ * HTTP client for interacting with the Goki Developer Tools platform.
+ *
+ * @example Simple usage (singleton)
+ * ```typescript
+ * import { devTools } from '@gokiteam/goki-dev'
+ *
+ * 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'
+ *
+ * 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'
+ *
+ * const traceId = devTools.generateTraceId('test')
+ * const message = await devTools.pubsub.waitForMessage({ ... })
+ * const logs = await devTools.logging.getByTrace({ traceId })
+ * ```
+ */
+export declare const devTools: DevToolsClient;

package/client/dist/index.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * @gokiteam/goki-dev - Client SDK
+ *
+ * HTTP client for interacting with the Goki Developer Tools platform.
+ *
+ * @example Simple usage (singleton)
+ * ```typescript
+ * import { devTools } from '@gokiteam/goki-dev'
+ *
+ * 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'
+ *
+ * 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'
+ *
+ * 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/client/dist/package.json

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

package/client/dist/types.d.ts

@@ -0,0 +1,280 @@
+/**
+ * @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;
+    };
+}

package/client/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/config.development

@@ -0,0 +1,46 @@
+NODE_ENV=development
+
+# Server Ports
+WEB_UI_PORT=9000
+LOGGING_PORT=8087
+MQTT_PORT=8883
+AWS_IOT_PORT=8086
+FIRESTORE_PORT=8080
+
+# Pub/Sub (Official Emulator)
+PUBSUB_EMULATOR_HOST=localhost:8085
+PUBSUB_PROJECT_ID=tipi-development
+SHADOW_POLL_INTERVAL_MS=200
+SHADOW_SUBSCRIPTION_CHECK_INTERVAL_MS=5000
+
+# Firestore
+FIRESTORE_PROJECT_ID=goki-dev-local
+
+# Storage
+DATA_DIR=./data
+AUTO_FLUSH_INTERVAL_MS=5000
+
+# Redis (for app data)
+REDIS_HOST=localhost
+REDIS_PORT=6379
+
+# Redis for logs (optional - defaults to REDIS_HOST/PORT if not specified)
+# Uncomment to use separate Redis instance for logs:
+# REDIS_LOGS_HOST=localhost
+# REDIS_LOGS_PORT=6380
+
+# Postgres
+POSTGRES_HOST=localhost
+POSTGRES_PORT=5432
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=postgres
+
+# Logging
+LOG_LEVEL=debug
+
+# App Gateway
+APP_GATEWAY_PROPERTY_ID=550e8400-e29b-41d4-a716-446655440000
+APP_GATEWAY_DEVICE_NATIVE_URL=http://localhost:3000
+APP_GATEWAY_DEVICE_SIMULATOR_URL=http://localhost:3001
+APP_GATEWAY_SCAN_INTERVAL_SECONDS=30
+APP_GATEWAY_AUTO_START=true

package/config.test

@@ -0,0 +1,18 @@
+NODE_ENV=test
+
+# Server Ports
+WEB_UI_PORT=9001
+PUBSUB_PORT=8086
+LOGGING_PORT=8088
+MQTT_PORT=8884
+
+# Storage
+DATA_DIR=./data-test
+AUTO_FLUSH_INTERVAL_MS=1000
+
+# Redis
+REDIS_HOST=localhost
+REDIS_PORT=6380
+
+# Logging
+LOG_LEVEL=error

package/guidelines/CodingStyleGuideline.md

@@ -0,0 +1,148 @@
+# Coding Style
+
+We are using [**Standard Javascript Style**](https://standardjs.com/rules.html) as the coding convention. Please read the documentation. You can find further information in this [**link**](https://github.com/standard/eslint-config-standard) as well.
+## Guideline
+All rules are not checked by the linter, so the developer should follow them consciously:
+### Don't put extra empty lines and spaces
+
+```plain
+// Bad 😖
+async create(ctx) {
+  const { body } = ctx.request
+  ctx.body = await SendRequest({
+    endpoint: Endpoint.base(BaseUrls.user).post('/users'),
+    body
+  })
+},
+
+async update(ctx) {
+  // ... some code ...
+},
+
+// Good 😌
+async create (ctx) {
+  const {
+    body
+   } = ctx.request
+
+  ctx.body = await SendRequest(
+    {
+    endpoint: Endpoint.base(BaseUrls.user).post('/users'),
+    body
+    }
+  )
+},
+async update (ctx) {
+  // ... some code ...
+},
+```
+
+### Single argument instead of multiple arguments
+Pass a single object as an argument to your functions and destructure it.
+
+```plain
+// Bad 😖
+async create (users, hostels, roles) {
+  // ... some code ...
+},
+
+// Good 😌
+async create ({ users, hostels, roles }) {
+  // ... some code ...
+},
+```
+
+### Async/await patterns
+
+Always use async/await instead of callbacks or raw promises:
+
+```plain
+// Good 😌
+async function getDevice (deviceId) {
+  const device = await Device.get(deviceId)
+  return device.mask()
+}
+
+// Bad 😖
+function getDevice (deviceId) {
+  return Device.get(deviceId).then(device => device.mask())
+}
+```
+
+### Destructuring patterns
+
+Destructure function parameters and assignments:
+
+```plain
+// Good 😌
+async function create ({ data, traceId }) {
+  const { deviceId, propertyId } = data
+  // ... logic
+}
+
+// Bad 😖
+async function create (params) {
+  const data = params.data
+  const traceId = params.traceId
+  // ... logic
+}
+```
+
+### Function chaining
+
+Chain ODM methods for cleaner code:
+
+```plain
+// Good 😌
+device
+  .assign({ status: 'active' })
+  .replaceNested('settings.wifi.enabled', true)
+
+await device.update()
+
+// Bad 😖
+device.assign({ status: 'active' })
+device.replaceNested('settings.wifi.enabled', true)
+await device.update()
+```
+
+### Functional programming
+
+Prefer pure functions in logic layer:
+
+```plain
+// Good 😌 - Pure function
+export function calculateBatteryLevel ({ voltage, capacity }) {
+  return Math.floor((voltage / capacity) * 100)
+}
+
+// Bad 😖 - Side effects
+let batteryLevel = 0
+export function calculateBatteryLevel ({ voltage, capacity }) {
+  batteryLevel = Math.floor((voltage / capacity) * 100)
+  return batteryLevel
+}
+```
+
+### No empty lines inside function bodies
+
+```plain
+// Good 😌
+async function create (params) {
+  const { data, traceId } = params
+  const device = new Device(data)
+  await device.create()
+  return { device: device.mask() }
+}
+
+// Bad 😖
+async function create (params) {
+  const { data, traceId } = params
+
+  const device = new Device(data)
+
+  await device.create()
+
+  return { device: device.mask() }
+}
+```

package/guidelines/CommentingGuideline.md

@@ -0,0 +1,10 @@
+# Commenting
+
+We include important notes and messages for readers in our code. Avoid adding excessive or unnecessary comments.
+In the development phase, these tags help you to focus on the code and not forget any vital information.
+*   `TODO`: No problem, but additional code needs to be written, usually when you are skipping something.
+*   `FIXME`: This works, but it could be improved. (usually, code written in a hurry that needs rewriting).
+*   `BUG`: A logical problem exists that affects system output.
+*   `NOTE`: An important note for a specific code section.
+
+Never use `TODO` as a general tag instead of using specific tags like `FIXME`