metal-orm 1.0.25 → 1.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/core/execution/executors/mssql-executor.ts

@@ -37,3 +37,142 @@ export function createMssqlExecutor(
     },
   };
 }
+
+// ---------------------------------------------------------------------------
+// Tedious integration helper (driver adapter)
+// ---------------------------------------------------------------------------
+
+export interface TediousColumn {
+  metadata: { colName: string };
+  value: unknown;
+}
+
+export interface TediousRequest {
+  addParameter(name: string, type: unknown, value: unknown): void;
+  on(event: 'row', listener: (columns: TediousColumn[]) => void): void;
+}
+
+export interface TediousRequestCtor {
+  new (sql: string, callback: (err?: Error | null) => void): TediousRequest;
+}
+
+export interface TediousTypes {
+  NVarChar: unknown;
+  Int: unknown;
+  Float: unknown;
+  BigInt: unknown;
+  Bit: unknown;
+  DateTime: unknown;
+  VarBinary: unknown;
+  [key: string]: unknown;
+}
+
+export interface TediousModule {
+  Request: TediousRequestCtor;
+  TYPES: TediousTypes;
+}
+
+export interface TediousConnectionLike {
+  execSql(request: TediousRequest): void;
+  beginTransaction?(cb: (err?: Error | null) => void): void;
+  commitTransaction?(cb: (err?: Error | null) => void): void;
+  rollbackTransaction?(cb: (err?: Error | null) => void): void;
+}
+
+export interface CreateTediousClientOptions {
+  inferType?(value: unknown, TYPES: TediousTypes): unknown;
+}
+
+const defaultInferType = (value: unknown, TYPES: TediousTypes): unknown => {
+  if (value === null || value === undefined) return TYPES.NVarChar;
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? TYPES.Int : TYPES.Float;
+  }
+  if (typeof value === 'bigint') return TYPES.BigInt;
+  if (typeof value === 'boolean') return TYPES.Bit;
+  if (value instanceof Date) return TYPES.DateTime;
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+    return TYPES.VarBinary;
+  }
+  return TYPES.NVarChar;
+};
+
+export function createTediousMssqlClient(
+  connection: TediousConnectionLike,
+  { Request, TYPES }: TediousModule,
+  options?: CreateTediousClientOptions
+): MssqlClientLike {
+  const inferType = options?.inferType ?? defaultInferType;
+
+  return {
+    async query(sql: string, params: unknown[] = []) {
+      const rows = await new Promise<Array<Record<string, unknown>>>(
+        (resolve, reject) => {
+          const collected: Record<string, unknown>[] = [];
+
+          const request = new Request(sql, err => {
+            if (err) return reject(err);
+            resolve(collected);
+          });
+
+          params.forEach((value, idx) => {
+            const sqlType = inferType(value, TYPES);
+            request.addParameter(
+              `p${idx + 1}`,
+              sqlType,
+              value as unknown
+            );
+          });
+
+          request.on('row', cols => {
+            const row: Record<string, unknown> = {};
+            for (const col of cols) {
+              row[col.metadata.colName] = col.value;
+            }
+            collected.push(row);
+          });
+
+          connection.execSql(request);
+        }
+      );
+
+      return { recordset: rows };
+    },
+
+    beginTransaction: connection.beginTransaction
+      ? () =>
+          new Promise<void>((resolve, reject) => {
+            connection.beginTransaction!(err =>
+              err ? reject(err) : resolve()
+            );
+          })
+      : undefined,
+
+    commit: connection.commitTransaction
+      ? () =>
+          new Promise<void>((resolve, reject) => {
+            connection.commitTransaction!(err =>
+              err ? reject(err) : resolve()
+            );
+          })
+      : undefined,
+
+    rollback: connection.rollbackTransaction
+      ? () =>
+          new Promise<void>((resolve, reject) => {
+            connection.rollbackTransaction!(err =>
+              err ? reject(err) : resolve()
+            );
+          })
+      : undefined,
+  };
+}
+
+export function createTediousExecutor(
+  connection: TediousConnectionLike,
+  module: TediousModule,
+  options?: CreateTediousClientOptions
+): DbExecutor {
+  const client = createTediousMssqlClient(connection, module, options);
+  return createMssqlExecutor(client);
+}

package/src/index.ts

@@ -2,11 +2,11 @@ export * from './schema/table.js';
 export * from './schema/column.js';
 export * from './schema/relation.js';
 export * from './schema/types.js';
-export * from './query-builder/select.js';
-export * from './query-builder/select-helpers.js';
-export * from './query-builder/insert.js';
-export * from './query-builder/update.js';
-export * from './query-builder/delete.js';
+export * from './query-builder/select.js';
+export * from './query-builder/select-helpers.js';
+export * from './query-builder/insert.js';
+export * from './query-builder/update.js';
+export * from './query-builder/delete.js';
 export * from './core/ast/expression.js';
 export * from './core/hydration/types.js';
 export * from './core/dialect/mysql/index.js';