@zintrust/db-sqlserver 0.1.8

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export type DatabaseConfig = {
+    driver: 'sqlite' | 'postgresql' | 'mysql' | 'sqlserver' | 'd1';
+    database?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    synchronize?: boolean;
+    logging?: boolean;
+    readHosts?: string[];
+};
+export type QueryResult = {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+};
+export interface IDatabaseAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query(sql: string, parameters: unknown[]): Promise<QueryResult>;
+    queryOne(sql: string, parameters: unknown[]): Promise<Record<string, unknown> | null>;
+    ping(): Promise<void>;
+    transaction<T>(callback: (adapter: IDatabaseAdapter) => Promise<T>): Promise<T>;
+    rawQuery<T = unknown>(sql: string, parameters?: unknown[]): Promise<T[]>;
+    getType(): string;
+    isConnected(): boolean;
+    getPlaceholder(index: number): string;
+}
+export declare const SQLServerAdapter: Readonly<{
+    create: (config: DatabaseConfig) => IDatabaseAdapter;
+}>;
+export default SQLServerAdapter;

package/dist/index.js

@@ -0,0 +1,67 @@
+import { ErrorFactory, FeatureFlags, Logger, QueryBuilder } from '@zintrust/core';
+function ensureConnected(state) {
+    if (!state.connected)
+        throw ErrorFactory.createConnectionError('Database not connected');
+}
+function connect(state, config) {
+    if (config.host === 'error') {
+        throw ErrorFactory.createConnectionError('Failed to connect to SQL Server: Error: Connection failed');
+    }
+    state.connected = true;
+    Logger.info(`✓ SQL Server connected (${config.host}:${config.port})`);
+}
+function disconnect(state) {
+    state.connected = false;
+    Logger.info('✓ SQL Server disconnected');
+}
+async function rawQuery(state, sql, parameters) {
+    if (!FeatureFlags.isRawQueryEnabled()) {
+        throw ErrorFactory.createConfigError('Raw SQL queries are disabled. Set USE_RAW_QRY=true environment variable to enable.');
+    }
+    ensureConnected(state);
+    Logger.warn(`Raw SQL Query executed: ${sql}`, { parameters });
+    try {
+        if (sql.toUpperCase().includes('INVALID')) {
+            throw ErrorFactory.createDatabaseError('Invalid SQL syntax');
+        }
+        return [];
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Raw SQL Query failed', error);
+    }
+}
+function createSqlServerAdapter(config) {
+    const state = { connected: false };
+    const adapter = {
+        connect: async () => connect(state, config),
+        disconnect: async () => disconnect(state),
+        query: async () => {
+            ensureConnected(state);
+            return { rows: [], rowCount: 0 };
+        },
+        queryOne: async (sql, parameters) => {
+            const result = await adapter.query(sql, parameters);
+            return result.rows[0] ?? null;
+        },
+        ping: async () => {
+            await adapter.query(QueryBuilder.create('').select('1').toSQL(), []);
+        },
+        transaction: async (callback) => {
+            try {
+                return await callback(adapter);
+            }
+            catch (error) {
+                throw ErrorFactory.createTryCatchError('Transaction failed', error);
+            }
+        },
+        getType: () => 'sqlserver',
+        isConnected: () => state.connected,
+        rawQuery: async (sql, parameters) => rawQuery(state, sql, parameters),
+        getPlaceholder: (index) => `@param${index}`,
+    };
+    return adapter;
+}
+export const SQLServerAdapter = Object.freeze({
+    create: (config) => createSqlServerAdapter(config),
+});
+export default SQLServerAdapter;

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+type Registry = {
+    register: (driver: string, factory: (cfg: unknown) => unknown) => void;
+};
+export declare function registerSqlServerAdapter(registry: Registry): void;
+export {};

package/dist/register.js

@@ -0,0 +1,8 @@
+import { SQLServerAdapter } from './index.js';
+export function registerSqlServerAdapter(registry) {
+    registry.register('sqlserver', (config) => SQLServerAdapter.create(config));
+}
+const core = (await import('@zintrust/core'));
+if (core.DatabaseAdapterRegistry !== undefined) {
+    registerSqlServerAdapter(core.DatabaseAdapterRegistry);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@zintrust/db-sqlserver",
+  "version": "0.1.8",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@zintrust/core": "^0.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  }
+}