@bestoneconsulting/sap-b1-bridge 1.1.0 → 1.2.1

package/README.md

@@ -66,8 +66,8 @@ Before the bridge can talk to your on-premise systems, you need to register an a
 
 ```typescript
 const agent = await bridge.registerAgent({
-  name: "Production Server",
-  serverName: "SQLPROD01",
+  name: "Main Office",
+  serverName: "Production ERP",  // A friendly label — not a hostname or connection string
   capabilities: ["sql_server", "sap_service_layer", "sap_di_api"],
 });
 
@@ -75,6 +75,8 @@ console.log("Agent API Key:", agent.apiKey);
 // Give this API key to the agent software running on your Windows server
 ```
 
+The `serverName` field is a descriptive label to help you identify which server or environment this agent represents (e.g. "Production ERP", "US Warehouse", "Dev Server"). It is not used as a connection string.
+
 Contact [Best One Consulting](https://www.bestoneconsulting.com/) to obtain the Windows agent installer.
 
 ## Built-in Test Console
@@ -89,7 +91,7 @@ bridge.mountUI("/bridge");
 The test console includes:
 
 - **Query Console** - Execute SQL queries, SAP Service Layer requests, and DI API operations with a form-based interface. Select your target type and agent, enter your query or request details, and see results in real time.
-- **Agents** - Register new agents, view connection status, copy API keys, and delete agents.
+- **Agents** - Register new agents, view connection status, copy API keys, and delete agents. Displays the **WebSocket URL** that agents need to connect to, with a one-click copy button.
 - **History** - View recent query history with status, execution time, and row counts.
 - **Live WebSocket** - Real-time connection status indicator and automatic result updates via WebSocket.
 
@@ -335,6 +337,126 @@ const bridge = await createSAPB1Bridge(options, new MyDatabaseStorage());
 
 See the full [`IBridgeStorage` interface](https://github.com/bestoneconsulting/sap-b1-bridge/blob/main/bridge/storage.ts) for method signatures and return types.
 
+### Built-in PostgreSQL Storage (Drizzle ORM)
+
+The package includes a ready-to-use PostgreSQL storage adapter built on [Drizzle ORM](https://orm.drizzle.team/). This gives you persistent storage without writing any database code.
+
+**1. Install Drizzle dependencies:**
+
+```bash
+npm install drizzle-orm @neondatabase/serverless drizzle-kit
+```
+
+Or if you use a standard PostgreSQL server (not Neon):
+
+```bash
+npm install drizzle-orm pg drizzle-kit
+npm install -D @types/pg
+```
+
+**2. Set up the database connection and push the schema:**
+
+Create a `drizzle.config.ts` in your project root:
+
+```typescript
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  out: "./drizzle",
+  schema: "./src/db/schema.ts",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```
+
+Create `src/db/schema.ts` that re-exports the bridge schema (and any of your own tables):
+
+```typescript
+export { bridgeCompanies, bridgeAgents, bridgeQueries } from "@bestoneconsulting/sap-b1-bridge";
+
+// Add your own application tables here if needed
+```
+
+Push the schema to your database:
+
+```bash
+npx drizzle-kit push
+```
+
+This creates three tables: `bridge_companies`, `bridge_agents`, and `bridge_queries`. The `bridge_` prefix avoids conflicts with your own application tables.
+
+**3. Create the Drizzle client and pass it to the bridge:**
+
+For Neon serverless PostgreSQL:
+
+```typescript
+import express from "express";
+import { createServer } from "http";
+import { neon } from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-http";
+import { createSAPB1Bridge, createDrizzleBridgeStorage } from "@bestoneconsulting/sap-b1-bridge";
+
+const sql = neon(process.env.DATABASE_URL!);
+const db = drizzle(sql);
+
+const app = express();
+app.use(express.json());
+const server = createServer(app);
+
+const storage = createDrizzleBridgeStorage(db);
+
+const bridge = await createSAPB1Bridge(
+  { app, server, appName: "My SAP App" },
+  storage
+);
+
+bridge.mountUI("/bridge");
+server.listen(3000);
+```
+
+For standard PostgreSQL (using `pg`):
+
+```typescript
+import express from "express";
+import { createServer } from "http";
+import { Pool } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { createSAPB1Bridge, createDrizzleBridgeStorage } from "@bestoneconsulting/sap-b1-bridge";
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = drizzle(pool);
+
+const app = express();
+app.use(express.json());
+const server = createServer(app);
+
+const storage = createDrizzleBridgeStorage(db);
+
+const bridge = await createSAPB1Bridge(
+  { app, server, appName: "My SAP App" },
+  storage
+);
+
+bridge.mountUI("/bridge");
+server.listen(3000);
+```
+
+**Schema details:**
+
+| Table | Purpose |
+|-------|---------|
+| `bridge_companies` | Organization grouping for agents |
+| `bridge_agents` | Registered agents with API keys and connection status |
+| `bridge_queries` | Query history with status, results, and execution metrics |
+
+The Drizzle schema objects are exported for advanced use cases (custom queries, migrations, extending):
+
+```typescript
+import { bridgeCompanies, bridgeAgents, bridgeQueries } from "@bestoneconsulting/sap-b1-bridge";
+```
+
 ## Configuration Options
 
 | Option | Type | Default | Description |

package/dist/app-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { IBridgeStorage } from "./storage";
+export declare function createAppBridgeStorage(dbStorage: any): IBridgeStorage;

package/dist/app-adapter.js

@@ -0,0 +1,61 @@
+export function createAppBridgeStorage(dbStorage) {
+    return {
+        async getCompanies() {
+            return dbStorage.getCompanies();
+        },
+        async getCompany(id) {
+            return dbStorage.getCompany(id);
+        },
+        async createCompany(name, description) {
+            return dbStorage.createCompany({ name, description });
+        },
+        async updateCompany(id, updates) {
+            return dbStorage.updateCompany(id, updates);
+        },
+        async deleteCompany(id) {
+            return dbStorage.deleteCompany(id);
+        },
+        async getAgents() {
+            return dbStorage.getAgents();
+        },
+        async getAgent(id) {
+            return dbStorage.getAgent(id);
+        },
+        async getAgentByApiKey(apiKey) {
+            return dbStorage.getAgentByApiKey(apiKey);
+        },
+        async createAgent(data) {
+            return dbStorage.createAgent(data);
+        },
+        async updateAgent(id, updates) {
+            return dbStorage.updateAgent(id, updates);
+        },
+        async updateAgentStatus(id, status, lastHeartbeat) {
+            return dbStorage.updateAgentStatus(id, status, lastHeartbeat);
+        },
+        async deleteAgent(id) {
+            return dbStorage.deleteAgent(id);
+        },
+        async getQueries() {
+            return dbStorage.getQueries();
+        },
+        async getQuery(id) {
+            return dbStorage.getQuery(id);
+        },
+        async getRecentQueries(limit) {
+            return dbStorage.getRecentQueries(limit);
+        },
+        async getPendingQueriesForAgent(agentId) {
+            return dbStorage.getPendingQueriesForAgent(agentId);
+        },
+        async getActiveQuery() {
+            return dbStorage.getActiveQuery();
+        },
+        async createQuery(data) {
+            return dbStorage.createQuery(data);
+        },
+        async updateQueryStatus(id, status, updates) {
+            return dbStorage.updateQueryStatus(id, status, updates);
+        },
+    };
+}

package/dist/drizzle-storage.d.ts

@@ -1,2 +1,6 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { NeonHttpDatabase } from "drizzle-orm/neon-http";
 import type { IBridgeStorage } from "./storage";
-export declare function createDrizzleBridgeStorage(dbStorage: any): IBridgeStorage;
+type DrizzleDB = NodePgDatabase<any> | NeonHttpDatabase<any>;
+export declare function createDrizzleBridgeStorage(db: DrizzleDB): IBridgeStorage;
+export {};

package/dist/drizzle-storage.js

@@ -1,61 +1,89 @@
-export function createDrizzleBridgeStorage(dbStorage) {
+import { eq, desc, and, asc } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { bridgeCompanies, bridgeAgents, bridgeQueries } from "./schema";
+export function createDrizzleBridgeStorage(db) {
     return {
         async getCompanies() {
-            return dbStorage.getCompanies();
+            return db.select().from(bridgeCompanies);
         },
         async getCompany(id) {
-            return dbStorage.getCompany(id);
+            const rows = await db.select().from(bridgeCompanies).where(eq(bridgeCompanies.id, id));
+            return rows[0];
         },
         async createCompany(name, description) {
-            return dbStorage.createCompany({ name, description });
+            const rows = await db.insert(bridgeCompanies).values({ name, description }).returning();
+            return rows[0];
         },
         async updateCompany(id, updates) {
-            return dbStorage.updateCompany(id, updates);
+            await db.update(bridgeCompanies).set(updates).where(eq(bridgeCompanies.id, id));
         },
         async deleteCompany(id) {
-            return dbStorage.deleteCompany(id);
+            await db.delete(bridgeCompanies).where(eq(bridgeCompanies.id, id));
         },
         async getAgents() {
-            return dbStorage.getAgents();
+            return db.select().from(bridgeAgents);
         },
         async getAgent(id) {
-            return dbStorage.getAgent(id);
+            const rows = await db.select().from(bridgeAgents).where(eq(bridgeAgents.id, id));
+            return rows[0];
         },
         async getAgentByApiKey(apiKey) {
-            return dbStorage.getAgentByApiKey(apiKey);
+            const rows = await db.select().from(bridgeAgents).where(eq(bridgeAgents.apiKey, apiKey));
+            return rows[0];
         },
         async createAgent(data) {
-            return dbStorage.createAgent(data);
+            const apiKey = `agent_${randomUUID().replace(/-/g, "")}`;
+            const rows = await db.insert(bridgeAgents).values({
+                name: data.name,
+                serverName: data.serverName,
+                capabilities: data.capabilities || ["sql_server"],
+                companyId: data.companyId || null,
+                apiKey,
+                status: "offline",
+            }).returning();
+            return rows[0];
         },
         async updateAgent(id, updates) {
-            return dbStorage.updateAgent(id, updates);
+            await db.update(bridgeAgents).set(updates).where(eq(bridgeAgents.id, id));
         },
         async updateAgentStatus(id, status, lastHeartbeat) {
-            return dbStorage.updateAgentStatus(id, status, lastHeartbeat);
+            await db.update(bridgeAgents).set({ status, lastHeartbeat }).where(eq(bridgeAgents.id, id));
         },
         async deleteAgent(id) {
-            return dbStorage.deleteAgent(id);
+            await db.delete(bridgeQueries).where(eq(bridgeQueries.agentId, id));
+            await db.delete(bridgeAgents).where(eq(bridgeAgents.id, id));
         },
         async getQueries() {
-            return dbStorage.getQueries();
+            return db.select().from(bridgeQueries).orderBy(desc(bridgeQueries.submittedAt));
         },
         async getQuery(id) {
-            return dbStorage.getQuery(id);
+            const rows = await db.select().from(bridgeQueries).where(eq(bridgeQueries.id, id));
+            return rows[0];
         },
         async getRecentQueries(limit) {
-            return dbStorage.getRecentQueries(limit);
+            return db.select().from(bridgeQueries).orderBy(desc(bridgeQueries.submittedAt)).limit(limit);
         },
         async getPendingQueriesForAgent(agentId) {
-            return dbStorage.getPendingQueriesForAgent(agentId);
+            return db.select().from(bridgeQueries)
+                .where(and(eq(bridgeQueries.agentId, agentId), eq(bridgeQueries.status, "pending")))
+                .orderBy(asc(bridgeQueries.submittedAt));
         },
         async getActiveQuery() {
-            return dbStorage.getActiveQuery();
+            const rows = await db.select().from(bridgeQueries).orderBy(desc(bridgeQueries.submittedAt)).limit(1);
+            return rows[0] || null;
         },
         async createQuery(data) {
-            return dbStorage.createQuery(data);
+            const rows = await db.insert(bridgeQueries).values({
+                agentId: data.agentId || null,
+                targetType: data.targetType || "sql_server",
+                sqlQuery: data.sqlQuery,
+                requestPayload: data.requestPayload || null,
+                status: "pending",
+            }).returning();
+            return rows[0];
         },
         async updateQueryStatus(id, status, updates) {
-            return dbStorage.updateQueryStatus(id, status, updates);
+            await db.update(bridgeQueries).set({ status, ...updates }).where(eq(bridgeQueries.id, id));
         },
     };
 }

package/dist/index.d.ts

@@ -3,5 +3,7 @@ import { type IBridgeStorage } from "./storage";
 export declare function createSAPB1Bridge(options: SAPB1BridgeOptions, storage?: IBridgeStorage): Promise<SAPB1BridgeAPI>;
 export { SAPB1Bridge } from "./core";
 export { MemBridgeStorage } from "./storage";
-export type { IBridgeStorage } from "./storage";
+export { createDrizzleBridgeStorage } from "./drizzle-storage";
+export { bridgeCompanies, bridgeAgents, bridgeQueries } from "./schema";
+export type { IBridgeStorage, BridgeQuery } from "./storage";
 export type { SAPB1BridgeOptions, SAPB1BridgeAPI, AgentInfo, QueryResult, ServiceLayerRequest, DiApiRequest, CapabilityStatus, AgentCapabilities, CompanyInfo, RegisterAgentOptions, } from "./types";

package/dist/index.js

@@ -4,3 +4,5 @@ export async function createSAPB1Bridge(options, storage) {
 }
 export { SAPB1Bridge } from "./core";
 export { MemBridgeStorage } from "./storage";
+export { createDrizzleBridgeStorage } from "./drizzle-storage";
+export { bridgeCompanies, bridgeAgents, bridgeQueries } from "./schema";

package/dist/schema.d.ts

@@ -0,0 +1,499 @@
+export declare const bridgeCompanies: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "bridge_companies";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "bridge_companies";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "bridge_companies";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "bridge_companies";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "bridge_companies";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const bridgeAgents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "bridge_agents";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "bridge_agents";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "bridge_agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        serverName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "server_name";
+            tableName: "bridge_agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        companyId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "company_id";
+            tableName: "bridge_agents";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "bridge_agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastHeartbeat: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_heartbeat";
+            tableName: "bridge_agents";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "bridge_agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        apiKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "api_key";
+            tableName: "bridge_agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        capabilities: import("drizzle-orm/pg-core").PgColumn<{
+            name: "capabilities";
+            tableName: "bridge_agents";
+            dataType: "array";
+            columnType: "PgArray";
+            data: string[];
+            driverParam: string | string[];
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: import("drizzle-orm").Column<{
+                name: "capabilities";
+                tableName: "bridge_agents";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "capabilities";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                enumValues: [string, ...string[]];
+                driverParam: string;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+            size: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const bridgeQueries: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "bridge_queries";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "bridge_queries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "bridge_queries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        targetType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "target_type";
+            tableName: "bridge_queries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sqlQuery: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sql_query";
+            tableName: "bridge_queries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requestPayload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "request_payload";
+            tableName: "bridge_queries";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "bridge_queries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        submittedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "submitted_at";
+            tableName: "bridge_queries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        executedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "executed_at";
+            tableName: "bridge_queries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "bridge_queries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rowCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "row_count";
+            tableName: "bridge_queries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        executionTime: import("drizzle-orm/pg-core").PgColumn<{
+            name: "execution_time";
+            tableName: "bridge_queries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "bridge_queries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        result: import("drizzle-orm/pg-core").PgColumn<{
+            name: "result";
+            tableName: "bridge_queries";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/schema.js

@@ -0,0 +1,34 @@
+import { sql } from "drizzle-orm";
+import { pgTable, text, varchar, timestamp, jsonb, integer } from "drizzle-orm/pg-core";
+export const bridgeCompanies = pgTable("bridge_companies", {
+    id: varchar("id").primaryKey().default(sql `gen_random_uuid()`),
+    name: text("name").notNull(),
+    description: text("description"),
+    createdAt: timestamp("created_at").defaultNow(),
+});
+export const bridgeAgents = pgTable("bridge_agents", {
+    id: varchar("id").primaryKey().default(sql `gen_random_uuid()`),
+    name: text("name").notNull(),
+    serverName: text("server_name").notNull(),
+    companyId: varchar("company_id").references(() => bridgeCompanies.id),
+    status: text("status").notNull().default("offline"),
+    lastHeartbeat: timestamp("last_heartbeat"),
+    version: text("version"),
+    apiKey: text("api_key").notNull().unique(),
+    capabilities: text("capabilities").array().notNull().default(sql `ARRAY['sql_server']::text[]`),
+});
+export const bridgeQueries = pgTable("bridge_queries", {
+    id: varchar("id").primaryKey().default(sql `gen_random_uuid()`),
+    agentId: varchar("agent_id").references(() => bridgeAgents.id),
+    targetType: text("target_type").notNull().default("sql_server"),
+    sqlQuery: text("sql_query").notNull(),
+    requestPayload: jsonb("request_payload"),
+    status: text("status").notNull().default("pending"),
+    submittedAt: timestamp("submitted_at").defaultNow(),
+    executedAt: timestamp("executed_at"),
+    completedAt: timestamp("completed_at"),
+    rowCount: integer("row_count"),
+    executionTime: integer("execution_time"),
+    error: text("error"),
+    result: jsonb("result"),
+});

package/dist/test-ui.js

@@ -266,16 +266,31 @@ export function getTestUIHTML(options) {
     <div class="page" id="page-agents">
       <div class="page-title">Agents</div>
 
+      <div class="card" style="margin-bottom:20px; background: var(--surface-2); border-color: var(--primary); border-left: 3px solid var(--primary);">
+        <div class="card-title" style="display:flex; align-items:center; gap:8px;">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"/><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"/></svg>
+          Agent Connection Info
+        </div>
+        <div style="font-size:13px; color: var(--text-dim); margin-bottom:8px;">
+          Configure your Windows agent software to connect to this WebSocket URL:
+        </div>
+        <div style="display:flex; align-items:center; gap:8px;">
+          <code id="wsUrlDisplay" data-testid="text-ws-url" style="flex:1; background:var(--bg); padding:8px 12px; border-radius:var(--radius); font-family:var(--mono); font-size:13px; border:1px solid var(--border); word-break:break-all;"></code>
+          <button class="btn btn-ghost btn-sm" onclick="copyWsUrl()" data-testid="button-copy-ws-url">Copy</button>
+        </div>
+      </div>
+
       <div class="card" style="margin-bottom:20px">
         <div class="card-title">Register New Agent</div>
         <div class="form-row">
           <div class="form-group">
             <label class="form-label">Agent Name</label>
-            <input id="newAgentName" placeholder="Production Server" data-testid="input-agent-name" />
+            <input id="newAgentName" placeholder="e.g. Main Office" data-testid="input-agent-name" />
           </div>
           <div class="form-group">
-            <label class="form-label">Server Name</label>
-            <input id="newAgentServer" placeholder="SQLPROD01" data-testid="input-agent-server" />
+            <label class="form-label">Server Description</label>
+            <input id="newAgentServer" placeholder="e.g. Production ERP" data-testid="input-agent-server" />
+            <div style="font-size:11px; color:var(--text-dim); margin-top:4px;">A friendly label to identify this server (not a hostname or connection string)</div>
           </div>
         </div>
         <button class="btn btn-primary" id="registerBtn" data-testid="button-register-agent">Register Agent</button>
@@ -344,6 +359,16 @@ export function getTestUIHTML(options) {
   }
   connectWS();
 
+  // WebSocket URL display
+  const wsProto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const wsUrl = wsProto + '//' + location.host + WS_PATH;
+  const wsUrlEl = document.getElementById('wsUrlDisplay');
+  if (wsUrlEl) wsUrlEl.textContent = wsUrl;
+
+  window.copyWsUrl = function() {
+    navigator.clipboard.writeText(wsUrl).then(() => alert('WebSocket URL copied!'));
+  };
+
   // API helpers
   async function api(path, opts) {
     const res = await fetch(API + path, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bestoneconsulting/sap-b1-bridge",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "type": "module",
   "license": "MIT",
   "description": "SAP Business One & SQL Server bridge for secure database and ERP access behind firewalls via WebSocket agents",
@@ -27,7 +27,13 @@
   "peerDependencies": {
     "express": ">=4.0.0",
     "ws": ">=8.0.0",
-    "zod": ">=3.0.0"
+    "zod": ">=3.0.0",
+    "drizzle-orm": ">=0.30.0"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "tsc -p ../tsconfig.bridge.json",