monetdb 1.3.4 → 2.0.0

package/src/connection.ts

@@ -0,0 +1,125 @@
+import { EventEmitter } from "events";
+import {
+  MapiConfig,
+  MapiConnection,
+  parseMapiUri,
+  createMapiConfig,
+  HandShakeOption,
+  QueryResult,
+  QueryStream,
+} from "./mapi";
+import PrepareStatement from "./PrepareStatement";
+
+// MAPI URI:
+//  tcp socket:  mapi:monetdb://[<username>[:<password>]@]<host>[:<port>]/<database>
+//  unix domain socket: mapi:monetdb:///[<username>[:<password>]@]path/to/socket?database=<database>
+type MAPI_URI = string;
+
+type ConnectCallback = (err?: Error) => void;
+
+class Connection extends EventEmitter {
+  autoCommit?: boolean;
+  replySize?: number;
+  sizeHeader?: boolean;
+  mapi: MapiConnection;
+
+  constructor(params: MapiConfig | MAPI_URI) {
+    super();
+    const config =
+      typeof params === "string"
+        ? createMapiConfig(parseMapiUri(params))
+        : createMapiConfig(params);
+    this.mapi = new MapiConnection(config);
+    this.autoCommit = config.autoCommit;
+    this.replySize = config.replySize;
+  }
+
+  connect(callback?: ConnectCallback): Promise<boolean> {
+    const options = [
+      new HandShakeOption(
+        1,
+        "auto_commit",
+        this.autoCommit,
+        this.setAutocommit
+      ),
+      new HandShakeOption(2, "reply_size", this.replySize, this.setReplySize),
+      new HandShakeOption(3, "size_header", true, this.setSizeHeader),
+      new HandShakeOption(
+        5,
+        "time_zone",
+        new Date().getTimezoneOffset() * 60,
+        this.setTimezone
+      ),
+    ];
+    const mapi = this.mapi;
+    return new Promise(async function (resolve, reject) {
+      try {
+        await mapi.connect(options);
+        resolve(mapi.ready());
+        if (callback) callback();
+      } catch (err) {
+        reject(err);
+        if (callback) callback(err);
+      }
+    });
+  }
+
+  close(): Promise<boolean> {
+    return this.mapi.disconnect();
+  }
+
+  commit(): Promise<void> {
+    return this.execute("COMMIT");
+  }
+
+  private command(str: string): Promise<any> {
+    return this.mapi.request(str);
+  }
+
+  execute(sql: string, stream: boolean = false): Promise<any> {
+    const query = `s${sql};\n`;
+    if (stream && this.replySize !== -1) this.setReplySize(-1);
+    return this.mapi.request(query, stream);
+  }
+
+  async prepare(sql: string): Promise<PrepareStatement> {
+    const prepSQL = `PREPARE ${sql}`;
+    const res = await this.execute(prepSQL);
+    return new PrepareStatement(res, this.mapi);
+  }
+
+  setAutocommit(v: boolean): Promise<boolean> {
+    const cmd = `Xauto_commit ${Number(v)}`;
+    return this.command(cmd).then(() => {
+      this.autoCommit = v;
+      return this.autoCommit;
+    });
+  }
+
+  setReplySize(v: number): Promise<number> {
+    const cmd = `Xreply_size ${Number(v)}`;
+    return this.command(cmd).then(() => {
+      this.replySize = Number(v);
+      return this.replySize;
+    });
+  }
+
+  setSizeHeader(v: boolean): Promise<boolean> {
+    const cmd = `Xsizeheader ${Number(v)}`;
+    return this.command(cmd).then(() => {
+      this.sizeHeader = v;
+      return this.sizeHeader;
+    });
+  }
+
+  setTimezone(sec: number): Promise<any> {
+    const qry = `SET TIME ZONE INTERVAL '${sec}' SECOND`;
+    return this.execute(qry);
+  }
+
+  rollback(): Promise<void> {
+    return this.execute("ROLLBACK");
+  }
+}
+
+export default Connection;

package/src/defaults.ts

@@ -0,0 +1,13 @@
+
+const defaults = {
+    host: process.env.MAPI_HOST || 'localhost',
+    port: process.env.MAPI_PORT || 50000,
+    username: process.env.MAPI_USER || 'monetdb',
+    password: process.env.MAPI_PASSWORD || 'monetdb',
+    database: process.env.MAPI_DATABASE,
+    autoCommit: false,
+    replySize: 100,
+};
+
+export default defaults;
+

package/src/file-transfer.ts

@@ -0,0 +1,173 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { cwd } from 'node:process';
+
+
+class FileHandler {
+    mapi: any;
+    file: string;
+    state: string;
+    err?: string;
+    eof?: boolean;
+    fhandle?: fs.FileHandle;
+    resolve?: (v?: any) => void;
+    reject?: (err?: Error) => void;
+
+    constructor(mapi: any, file: string) {
+        this.mapi = mapi;
+        this.file = file;
+        this.state = 'init';
+    }
+
+    async close(): Promise<void> {
+        if (this.fhandle) {
+            this.state = 'closed';
+            await this.fhandle.close();
+            this.fhandle = undefined;
+        }
+    }
+
+    protected makePromise(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+
+    ready(): boolean {
+        return this.fhandle !== undefined 
+            && this.err === undefined 
+            && this.state === 'ready';
+    }
+
+    async initTransfer(flag: 'r'|'w'): Promise<void> {
+        if (this.fhandle === undefined) {
+            // for security reasons we do 
+            // expect file to be relative to cwd
+            const fpath = path.join(cwd(), this.file);
+            if (fpath.startsWith(cwd())) {
+                try {
+                    this.fhandle = await fs.open(fpath, flag);
+                } catch (err) {
+                    await this.mapi.requestFileTransferError(`${err}\n`, this);
+                    return this.makePromise();
+                }
+                // tell server we are okay with the download
+                // send magic new line
+                await this.mapi.requestFileTransfer(Buffer.from('\n'), this);
+                this.state = 'ready';
+                if (flag === 'r')
+                    this.eof = false;
+                return this.makePromise();
+            } else {
+                // send err msg
+                await this.mapi.requestFileTransferError('Forbidden\n', this);
+                return this.makePromise();
+            }
+        }
+
+    }
+}
+
+
+class FileDownloader extends FileHandler {
+    bytesWritten: number;
+
+    constructor(mapi: any, file: string) {
+        super(mapi, file);
+        this.bytesWritten = 0;
+    }
+
+    async download(): Promise<void> {
+        if (this.state === 'init')
+            return this.initTransfer('w');
+    }
+
+    async writeChunk(data: Buffer): Promise<number> {
+        let bytes = 0;
+        if (this.ready()) {
+            try {
+                const { bytesWritten, buffer } = await this.fhandle.write(data);
+                bytes += bytesWritten;
+            } catch(err) {
+                this.err = err;
+                try {
+                    await this.mapi.requestAbort();
+                } catch(err) {
+                    // pass
+                    console.error(err);
+                }
+                await this.close();
+                this.reject(err);
+                // kill connection
+                await this.mapi.disconnect();
+                throw err;
+            }
+        }
+        this.bytesWritten += bytes;
+        return bytes;
+    }
+}
+
+
+class FileUploader extends FileHandler {
+    skip: number;
+    bytesSent: number;
+    chunkSize: number;
+    eof: boolean;
+    
+    constructor(mapi: any, file: string, skip: number = 0) {
+        super(mapi, file);
+        this.skip = skip > 0 ? skip - 1 : 0; // line based offset, super confusing
+        this.bytesSent = 0;
+        // configurable?
+        this.chunkSize = 1024 * 1024;
+    }
+
+    async upload(): Promise<void> {
+        if (this.state === 'init')
+            return this.initTransfer('r');
+        try {
+            await this.sendChunk();
+        } catch(err) {
+            this.err = err;
+            await this.mapi.requestAbort();
+            await this.close();
+            return this.reject(err);
+        }
+    }
+
+    private async sendChunk(): Promise<void> {
+        let bytesRead: number = 0;
+        let buffer: Buffer = Buffer.alloc(0);
+        do {
+            const res = await this.fhandle.read(Buffer.alloc(this.chunkSize), 0, this.chunkSize);
+            bytesRead += res.bytesRead;
+            const data = Buffer.concat([buffer, res.buffer]).toString('utf8');
+            let offset: number = 0;
+            let eol = data.indexOf('\n');
+            while(this.skip && eol) {
+                offset = eol + 1;
+                this.skip--;
+                eol = data.indexOf('\n', offset);
+            }
+            buffer = Buffer.from(data).subarray(offset);
+        } while(this.skip && this.bytesSent === 0)
+
+        if (bytesRead > 0) {
+            // console.log(`read ${bytesRead} bytes`)
+            await this.mapi.requestFileTransfer(buffer.subarray(0, bytesRead), this);
+            this.bytesSent += bytesRead;
+            // console.log(`sent ${bytesRead} bytes`)
+        } else {
+            // reached EOF
+            this.eof = true;
+            // console.log(`reached eof`);
+            // send empty block to indicate end of upload
+            await this.mapi.requestFileTransfer(Buffer.from(''), this);
+        }
+    }
+}
+
+export { FileUploader, FileDownloader };
+

package/src/index.ts

@@ -0,0 +1,3 @@
+import Connection from './connection';
+
+export { Connection };