@bestoneconsulting/sap-b1-bridge 1.1.0 → 1.2.0

package/README.md

@@ -335,6 +335,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bestoneconsulting/sap-b1-bridge",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "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",