@gokiteam/goki-dev 0.2.0

package/src/db/Tables.js

@@ -0,0 +1,66 @@
+/**
+ * Database table names - single source of truth
+ * Use these constants instead of hardcoded strings
+ */
+
+export const Tables = Object.freeze({
+  // Pub/Sub tables
+  PUBSUB_TOPICS: 'pubsub_topics',
+  PUBSUB_SUBSCRIPTIONS: 'pubsub_subscriptions',
+  PUBSUB_MESSAGES: 'pubsub_messages',
+  PUBSUB_MESSAGE_HISTORY: 'pubsub_message_history',
+  PUBSUB_TOPIC_REGISTRY: 'pubsub_topic_registry',
+
+  // Logging tables
+  LOGGING_ENTRIES: 'logging_entries',
+  LOGGING_LOGS: 'logging_logs',
+
+  // MQTT tables
+  MQTT_CLIENTS: 'mqtt_clients',
+  MQTT_MESSAGES: 'mqtt_messages',
+  MQTT_SUBSCRIPTIONS: 'mqtt_subscriptions',
+
+  // Firestore tables
+  FIRESTORE_METADATA: 'firestore_metadata',
+
+  // Webhook tables
+  WEBHOOK_ROUTES: 'webhook_routes',
+  WEBHOOK_SETTINGS: 'webhook_settings',
+
+  // HTTP traffic proxy tables
+  HTTP_TRAFFIC: 'http_traffic',
+
+  // Cloud Functions tables
+  CLOUD_FUNCTIONS: 'cloud_functions',
+  CLOUD_FUNCTION_INVOCATIONS: 'cloud_function_invocations',
+
+  // System tables
+  SCHEMA_MIGRATIONS: 'schema_migrations'
+})
+
+// Export individual constants for convenience
+export const {
+  PUBSUB_TOPICS,
+  PUBSUB_SUBSCRIPTIONS,
+  PUBSUB_MESSAGES,
+  PUBSUB_MESSAGE_HISTORY,
+  PUBSUB_TOPIC_REGISTRY,
+  LOGGING_ENTRIES,
+  LOGGING_LOGS,
+  MQTT_CLIENTS,
+  MQTT_MESSAGES,
+  MQTT_SUBSCRIPTIONS,
+  FIRESTORE_METADATA,
+  WEBHOOK_ROUTES,
+  WEBHOOK_SETTINGS,
+  HTTP_TRAFFIC,
+  CLOUD_FUNCTIONS,
+  CLOUD_FUNCTION_INVOCATIONS,
+  SCHEMA_MIGRATIONS
+} = Tables
+
+// Helper to get all table names as array
+export const getAllTables = () => Object.values(Tables)
+
+// Helper to check if a table name is valid
+export const isValidTable = (tableName) => getAllTables().includes(tableName)

package/src/db/schemas/firestore.js

@@ -0,0 +1,18 @@
+// Firestore metadata schema
+
+export const METADATA_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS firestore_metadata (
+    _id TEXT PRIMARY KEY,
+    collection_name TEXT NOT NULL UNIQUE,
+    document_count INTEGER DEFAULT 0,
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch())
+  )
+`
+
+export const FIRESTORE_INDEXES = []
+
+export const FIRESTORE_SCHEMAS = [
+  METADATA_SCHEMA,
+  ...FIRESTORE_INDEXES
+]

package/src/db/schemas/functions.js

@@ -0,0 +1,65 @@
+// Cloud Functions emulator table schemas
+
+export const CLOUD_FUNCTIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS cloud_functions (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    source TEXT NOT NULL,
+    source_path TEXT,
+    entry_point TEXT NOT NULL,
+    trigger_type TEXT NOT NULL,
+    trigger_config TEXT DEFAULT '{}',
+    signature_type TEXT DEFAULT 'cloudevent',
+    runtime TEXT DEFAULT 'nodejs20',
+    environment_variables TEXT DEFAULT '{}',
+    timeout_seconds INTEGER DEFAULT 60,
+    description TEXT,
+    status TEXT DEFAULT 'stopped',
+    port INTEGER,
+    pid INTEGER,
+    error_message TEXT,
+    enabled INTEGER DEFAULT 1,
+    invocation_count INTEGER DEFAULT 0,
+    last_invoked_at TEXT,
+    last_status INTEGER,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+  )
+`
+
+export const CLOUD_FUNCTIONS_INDEXES = `
+  CREATE INDEX IF NOT EXISTS idx_cf_trigger_type ON cloud_functions(trigger_type);
+  CREATE INDEX IF NOT EXISTS idx_cf_status ON cloud_functions(status)
+`
+
+export const CLOUD_FUNCTION_INVOCATIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS cloud_function_invocations (
+    id TEXT PRIMARY KEY,
+    function_id TEXT NOT NULL,
+    function_name TEXT NOT NULL,
+    trigger_type TEXT NOT NULL,
+    trigger_source TEXT,
+    cloud_event TEXT,
+    response_status INTEGER,
+    response_body TEXT,
+    response_time_ms INTEGER,
+    error TEXT,
+    started_at TEXT NOT NULL,
+    completed_at TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (function_id) REFERENCES cloud_functions(id) ON DELETE CASCADE
+  )
+`
+
+export const CLOUD_FUNCTION_INVOCATIONS_INDEXES = `
+  CREATE INDEX IF NOT EXISTS idx_cfi_function_id ON cloud_function_invocations(function_id);
+  CREATE INDEX IF NOT EXISTS idx_cfi_started_at ON cloud_function_invocations(started_at);
+  CREATE INDEX IF NOT EXISTS idx_cfi_created_at ON cloud_function_invocations(created_at)
+`
+
+export const FUNCTIONS_SCHEMAS = [
+  CLOUD_FUNCTIONS_SCHEMA,
+  CLOUD_FUNCTIONS_INDEXES,
+  CLOUD_FUNCTION_INVOCATIONS_SCHEMA,
+  CLOUD_FUNCTION_INVOCATIONS_INDEXES
+]

package/src/db/schemas/httpTraffic.js

@@ -0,0 +1,43 @@
+// HTTP traffic proxy table schemas
+
+export const HTTP_TRAFFIC_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS http_traffic (
+    _id TEXT PRIMARY KEY,
+    method TEXT NOT NULL,
+    target_url TEXT NOT NULL,
+    target_host TEXT,
+    target_path TEXT,
+    query_params TEXT,
+    request_headers TEXT,
+    request_body TEXT,
+    request_cookies TEXT,
+    content_type TEXT,
+    status_code INTEGER,
+    response_headers TEXT,
+    response_body TEXT,
+    response_content_type TEXT,
+    response_time_ms INTEGER,
+    started_at TEXT,
+    completed_at TEXT,
+    source_service TEXT,
+    error TEXT,
+    mock_response TEXT,
+    is_mocked INTEGER DEFAULT 0,
+    trace_id TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  )
+`
+
+export const HTTP_TRAFFIC_INDEXES = [
+  'CREATE INDEX IF NOT EXISTS idx_http_traffic_target_host ON http_traffic(target_host)',
+  'CREATE INDEX IF NOT EXISTS idx_http_traffic_method ON http_traffic(method)',
+  'CREATE INDEX IF NOT EXISTS idx_http_traffic_status_code ON http_traffic(status_code)',
+  'CREATE INDEX IF NOT EXISTS idx_http_traffic_created_at ON http_traffic(created_at)',
+  'CREATE INDEX IF NOT EXISTS idx_http_traffic_source_service ON http_traffic(source_service)',
+  'CREATE INDEX IF NOT EXISTS idx_http_traffic_trace_id ON http_traffic(trace_id)'
+]
+
+export const HTTP_TRAFFIC_SCHEMAS = [
+  HTTP_TRAFFIC_SCHEMA,
+  ...HTTP_TRAFFIC_INDEXES
+]

package/src/db/schemas/logging.js

@@ -0,0 +1,74 @@
+// Logging table schemas and indexes
+
+export const LOGS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS logging_logs (
+    _id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL,
+    log_id TEXT NOT NULL,
+    log_name TEXT NOT NULL,
+    created_at TEXT,
+    updated_at TEXT,
+    UNIQUE(project_id, log_id)
+  )
+`
+
+export const ENTRIES_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS logging_entries (
+    _id TEXT PRIMARY KEY,
+    log_name TEXT NOT NULL,
+    service_name TEXT,
+    resource TEXT,
+    labels TEXT,
+    text_payload TEXT,
+    json_payload TEXT,
+    proto_payload TEXT,
+    severity TEXT,
+    insert_id TEXT,
+    timestamp TEXT,
+    receive_timestamp TEXT,
+    trace TEXT,
+    span_id TEXT,
+    trace_sampled INTEGER,
+    http_request TEXT,
+    operation TEXT,
+    source_location TEXT,
+    source TEXT,
+    level TEXT,
+    error_message TEXT,
+    stack_trace TEXT,
+    event TEXT,
+    duration REAL,
+    error_code TEXT,
+    error_status INTEGER,
+    error_reason TEXT,
+    error_resource TEXT,
+    property_id TEXT,
+    device_id TEXT,
+    door_id TEXT,
+    subscription_name TEXT,
+    message_id TEXT,
+    created_at TEXT
+  )
+`
+
+export const LOGGING_INDEXES = [
+  'CREATE INDEX IF NOT EXISTS idx_entries_log_name ON logging_entries(log_name)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_service_name ON logging_entries(service_name)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_severity ON logging_entries(severity)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_timestamp ON logging_entries(timestamp)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_trace ON logging_entries(trace)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_source ON logging_entries(source)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_event ON logging_entries(event)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_property_id ON logging_entries(property_id)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_device_id ON logging_entries(device_id)',
+  'CREATE INDEX IF NOT EXISTS idx_logs_project_id ON logging_logs(project_id)',
+  // Dedupe index: equality on text_payload + service_name, range on timestamp
+  'CREATE INDEX IF NOT EXISTS idx_dedupe_logs_v2 ON logging_entries(text_payload, service_name, timestamp)',
+  'CREATE INDEX IF NOT EXISTS idx_entries_created_at ON logging_entries(created_at)'
+]
+
+export const LOGGING_SCHEMAS = [
+  LOGS_SCHEMA,
+  ENTRIES_SCHEMA,
+  ...LOGGING_INDEXES
+]

package/src/db/schemas/migrations.js

@@ -0,0 +1,64 @@
+// Schema version tracking
+
+export const MIGRATIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    applied_at INTEGER DEFAULT (unixepoch())
+  )
+`
+
+export const CURRENT_SCHEMA_VERSION = 10
+
+export const MIGRATIONS = [
+  {
+    version: 1,
+    name: 'initial_schema',
+    description: 'Create initial tables for pubsub, logging, mqtt, and firestore'
+  },
+  {
+    version: 2,
+    name: 'logging_schema_update',
+    description: 'Add missing columns to logging_entries (span_id, trace_sampled, proto_payload, http_request, operation, source_location)'
+  },
+  {
+    version: 3,
+    name: 'add_service_name',
+    description: 'Add service_name column to logging_entries for efficient service filtering'
+  },
+  {
+    version: 4,
+    name: 'log_parsing_normalisation',
+    description: 'Add source, level, error_message columns and improved dedupe index'
+  },
+  {
+    version: 5,
+    name: 'webhook_proxy',
+    description: 'Add webhook_routes and webhook_settings tables for webhook proxy feature'
+  },
+  {
+    version: 6,
+    name: 'logging_nested_fields',
+    description: 'Add extracted nested log fields (stack_trace, event, duration, error_*, property_id, device_id, door_id, subscription_name, message_id)'
+  },
+  {
+    version: 7,
+    name: 'http_traffic',
+    description: 'Add http_traffic table for HTTP proxy request/response recording'
+  },
+  {
+    version: 8,
+    name: 'pubsub_topic_registry',
+    description: 'Add pubsub_topic_registry table for persisting topic/subscription declarations across emulator restarts'
+  },
+  {
+    version: 9,
+    name: 'cloud_functions',
+    description: 'Add cloud_functions and cloud_function_invocations tables for Cloud Functions emulator'
+  },
+  {
+    version: 10,
+    name: 'db_maintenance_indexes',
+    description: 'Add created_at indexes on unbounded tables for efficient retention cleanup'
+  }
+]

package/src/db/schemas/mqtt.js

@@ -0,0 +1,56 @@
+// MQTT table schemas and indexes
+
+export const CLIENTS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS mqtt_clients (
+    client_id TEXT PRIMARY KEY,
+    connected_at TEXT,
+    disconnected_at TEXT,
+    will TEXT,
+    clean INTEGER,
+    version INTEGER,
+    created_at INTEGER DEFAULT (unixepoch())
+  )
+`
+
+export const MESSAGES_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS mqtt_messages (
+    id TEXT PRIMARY KEY,
+    topic TEXT NOT NULL,
+    payload TEXT,
+    qos INTEGER,
+    retain INTEGER,
+    timestamp TEXT,
+    client_id TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    FOREIGN KEY (client_id) REFERENCES mqtt_clients(client_id) ON DELETE SET NULL
+  )
+`
+
+export const SUBSCRIPTIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS mqtt_subscriptions (
+    id TEXT PRIMARY KEY,
+    client_id TEXT NOT NULL,
+    topic TEXT NOT NULL,
+    qos INTEGER,
+    timestamp TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    FOREIGN KEY (client_id) REFERENCES mqtt_clients(client_id) ON DELETE CASCADE,
+    UNIQUE(client_id, topic)
+  )
+`
+
+export const MQTT_INDEXES = [
+  'CREATE INDEX IF NOT EXISTS idx_messages_topic ON mqtt_messages(topic)',
+  'CREATE INDEX IF NOT EXISTS idx_messages_client_id ON mqtt_messages(client_id)',
+  'CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON mqtt_messages(timestamp)',
+  'CREATE INDEX IF NOT EXISTS idx_subscriptions_client_id ON mqtt_subscriptions(client_id)',
+  'CREATE INDEX IF NOT EXISTS idx_subscriptions_topic ON mqtt_subscriptions(topic)',
+  'CREATE INDEX IF NOT EXISTS idx_mqtt_messages_created_at ON mqtt_messages(created_at)'
+]
+
+export const MQTT_SCHEMAS = [
+  CLIENTS_SCHEMA,
+  MESSAGES_SCHEMA,
+  SUBSCRIPTIONS_SCHEMA,
+  ...MQTT_INDEXES
+]

package/src/db/schemas/pubsub.js

@@ -0,0 +1,90 @@
+// Pub/Sub table schemas and indexes
+
+export const TOPICS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pubsub_topics (
+    name TEXT PRIMARY KEY,
+    labels TEXT,
+    message_storage_policy TEXT,
+    kms_key_name TEXT,
+    schema_settings TEXT,
+    satisfies_pzs INTEGER,
+    message_retention_duration TEXT,
+    created_at INTEGER DEFAULT (unixepoch())
+  )
+`
+
+export const SUBSCRIPTIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pubsub_subscriptions (
+    name TEXT PRIMARY KEY,
+    topic TEXT NOT NULL,
+    push_config TEXT,
+    ack_deadline_seconds INTEGER,
+    retain_acked_messages INTEGER,
+    message_retention_duration TEXT,
+    labels TEXT,
+    enable_message_ordering INTEGER,
+    expiration_policy TEXT,
+    filter TEXT,
+    dead_letter_policy TEXT,
+    retry_policy TEXT,
+    detached INTEGER,
+    enable_exactly_once_delivery INTEGER,
+    topic_message_retention_duration TEXT,
+    state TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    FOREIGN KEY (topic) REFERENCES pubsub_topics(name) ON DELETE CASCADE
+  )
+`
+
+export const MESSAGES_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pubsub_messages (
+    id TEXT PRIMARY KEY,
+    data TEXT,
+    attributes TEXT,
+    ordering_key TEXT,
+    publish_time TEXT,
+    topic TEXT NOT NULL,
+    ack_id TEXT,
+    delivery_attempt INTEGER DEFAULT 0,
+    last_delivery_time TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    FOREIGN KEY (topic) REFERENCES pubsub_topics(name) ON DELETE CASCADE
+  )
+`
+
+export const MESSAGE_HISTORY_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pubsub_message_history (
+    id TEXT PRIMARY KEY,
+    message_id TEXT NOT NULL,
+    data TEXT,
+    attributes TEXT,
+    ordering_key TEXT,
+    publish_time TEXT NOT NULL,
+    topic TEXT NOT NULL,
+    sender TEXT,
+    view_count INTEGER DEFAULT 0,
+    last_viewed_at INTEGER,
+    created_at INTEGER DEFAULT (unixepoch()),
+    FOREIGN KEY (topic) REFERENCES pubsub_topics(name) ON DELETE CASCADE
+  )
+`
+
+export const PUBSUB_INDEXES = [
+  'CREATE INDEX IF NOT EXISTS idx_subscriptions_topic ON pubsub_subscriptions(topic)',
+  'CREATE INDEX IF NOT EXISTS idx_messages_topic ON pubsub_messages(topic)',
+  'CREATE INDEX IF NOT EXISTS idx_messages_ack_id ON pubsub_messages(ack_id)',
+  'CREATE INDEX IF NOT EXISTS idx_history_topic ON pubsub_message_history(topic)',
+  'CREATE INDEX IF NOT EXISTS idx_history_publish_time ON pubsub_message_history(publish_time)',
+  'CREATE INDEX IF NOT EXISTS idx_history_sender ON pubsub_message_history(sender)',
+  'CREATE INDEX IF NOT EXISTS idx_history_view_count ON pubsub_message_history(view_count)',
+  'CREATE INDEX IF NOT EXISTS idx_history_last_viewed ON pubsub_message_history(last_viewed_at)',
+  'CREATE INDEX IF NOT EXISTS idx_messages_created_at ON pubsub_messages(created_at)'
+]
+
+export const PUBSUB_SCHEMAS = [
+  TOPICS_SCHEMA,
+  SUBSCRIPTIONS_SCHEMA,
+  MESSAGES_SCHEMA,
+  MESSAGE_HISTORY_SCHEMA,
+  ...PUBSUB_INDEXES
+]

package/src/db/schemas/pubsubRegistry.js

@@ -0,0 +1,22 @@
+// Pub/Sub topic registry schema — persists topic+subscription declarations across emulator restarts
+
+export const PUBSUB_TOPIC_REGISTRY_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pubsub_topic_registry (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    topic_name TEXT NOT NULL,
+    subscription_name TEXT,
+    project_name TEXT NOT NULL,
+    registered_at INTEGER DEFAULT (unixepoch()),
+    UNIQUE(topic_name, subscription_name, project_name)
+  )
+`
+
+export const PUBSUB_TOPIC_REGISTRY_INDEXES = [
+  'CREATE INDEX IF NOT EXISTS idx_registry_topic ON pubsub_topic_registry(topic_name)',
+  'CREATE INDEX IF NOT EXISTS idx_registry_project ON pubsub_topic_registry(project_name)'
+]
+
+export const PUBSUB_TOPIC_REGISTRY_SCHEMAS = [
+  PUBSUB_TOPIC_REGISTRY_SCHEMA,
+  ...PUBSUB_TOPIC_REGISTRY_INDEXES
+]

package/src/db/schemas/webhooks.js

@@ -0,0 +1,28 @@
+// Webhook proxy table schemas
+
+export const WEBHOOK_ROUTES_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS webhook_routes (
+    prefix TEXT PRIMARY KEY,
+    target TEXT NOT NULL,
+    path_rewrite TEXT,
+    description TEXT,
+    enabled INTEGER DEFAULT 1,
+    request_count INTEGER DEFAULT 0,
+    last_request_at INTEGER,
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch())
+  )
+`
+
+export const WEBHOOK_SETTINGS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS webhook_settings (
+    key TEXT PRIMARY KEY,
+    value TEXT,
+    updated_at INTEGER DEFAULT (unixepoch())
+  )
+`
+
+export const WEBHOOK_SCHEMAS = [
+  WEBHOOK_ROUTES_SCHEMA,
+  WEBHOOK_SETTINGS_SCHEMA
+]

package/src/emulation/awsiot/Controllers.js

@@ -0,0 +1,91 @@
+import { publishToTopic } from './Logic.js'
+import { Logger } from '../../singletons/Logger.js'
+
+/**
+ * POST /topics/:topicName?qos=1
+ * Mimics AWS IoT Core HTTPS publishing API
+ *
+ * Accepts:
+ * - Binary payload (Buffer) in request body
+ * - QoS level in query parameter (optional, defaults to 1)
+ * - Authorization header (present but not validated in dev mode)
+ *
+ * Returns:
+ * - Empty 200 response (matching AWS IoT Core behavior)
+ */
+export const publish = async (ctx) => {
+  const { topicName } = ctx.params
+  const qos = parseInt(ctx.query.qos || '1')
+  const payload = ctx.request.body
+
+  try {
+    // Validate topic name
+    if (!topicName) {
+      ctx.status = 400
+      ctx.body = {
+        error: {
+          code: 400,
+          message: 'Topic name is required',
+          status: 'INVALID_ARGUMENT'
+        }
+      }
+      return
+    }
+
+    // Validate payload
+    if (!Buffer.isBuffer(payload)) {
+      ctx.status = 400
+      ctx.body = {
+        error: {
+          code: 400,
+          message: 'Payload must be binary (Buffer)',
+          status: 'INVALID_ARGUMENT'
+        }
+      }
+      return
+    }
+
+    // Validate QoS
+    if (qos !== 0 && qos !== 1) {
+      ctx.status = 400
+      ctx.body = {
+        error: {
+          code: 400,
+          message: 'QoS must be 0 or 1',
+          status: 'INVALID_ARGUMENT'
+        }
+      }
+      return
+    }
+
+    // Publish to MQTT broker
+    await publishToTopic({
+      topicName,
+      payload,
+      qos
+    })
+
+    // AWS IoT Core returns empty 200 response
+    ctx.status = 200
+    ctx.body = ''
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'AWS IoT HTTPS API: Controller error',
+      data: {
+        topic: topicName,
+        error: error.message,
+        stack: error.stack
+      }
+    })
+
+    ctx.status = 500
+    ctx.body = {
+      error: {
+        code: 500,
+        message: error.message || 'Internal server error',
+        status: 'INTERNAL'
+      }
+    }
+  }
+}

package/src/emulation/awsiot/Logic.js

@@ -0,0 +1,70 @@
+import { Broker } from '../../protocols/mqtt/Broker.js'
+import { Logger } from '../../singletons/Logger.js'
+
+/**
+ * Publish message to MQTT broker (mimics AWS IoT Core HTTPS API)
+ *
+ * AWS IoT Core HTTPS API: POST /topics/{topicName}?qos=1
+ * Body: Binary packet (Buffer)
+ * Response: Empty 200 response
+ *
+ * @param {Object} params
+ * @param {string} params.topicName - MQTT topic name
+ * @param {Buffer} params.payload - Binary message payload
+ * @param {number} params.qos - Quality of Service (0 or 1)
+ * @returns {Promise<Object>} Success status
+ */
+export const publishToTopic = async ({ topicName, payload, qos = 1 }) => {
+  try {
+    // Get MQTT broker instance
+    const broker = Broker.getInstance()
+
+    // Publish to MQTT broker
+    // Note: We're publishing as the broker itself (no client), so client will be null in handlers
+    broker.publish({
+      cmd: 'publish',
+      topic: topicName,
+      payload,
+      qos,
+      retain: false
+    }, (err) => {
+      if (err) {
+        Logger.log({
+          level: 'error',
+          message: 'Failed to publish to MQTT broker',
+          data: {
+            topic: topicName,
+            qos,
+            error: err.message
+          }
+        })
+        throw err
+      }
+    })
+
+    Logger.log({
+      level: 'debug',
+      message: 'AWS IoT HTTPS API: Published to MQTT broker',
+      data: {
+        topic: topicName,
+        qos,
+        payloadSize: payload.length
+      }
+    })
+
+    return {
+      success: true
+    }
+  } catch (error) {
+    Logger.log({
+      level: 'error',
+      message: 'AWS IoT HTTPS API: Publish failed',
+      data: {
+        topic: topicName,
+        error: error.message,
+        stack: error.stack
+      }
+    })
+    throw error
+  }
+}