From 6406610f5dd4d0ae7c530c449b5de4171aa50f27 Mon Sep 17 00:00:00 2001
From: Mateusz Krupa <mateusz.krupa@onwelo.com>
Date: Tue, 28 Aug 2018 11:02:13 +0200
Subject: [PATCH] [@types/pg-large-object] Added missing part

---
 types/pg-large-object/index.d.ts              | 52 ++++++++++++++++--
 .../pg-large-object/pg-large-object-tests.ts  | 54 +++++++++++++++++--
 2 files changed, 99 insertions(+), 7 deletions(-)

diff --git a/types/pg-large-object/index.d.ts b/types/pg-large-object/index.d.ts
index 804b86df1a..64a450d545 100644
--- a/types/pg-large-object/index.d.ts
+++ b/types/pg-large-object/index.d.ts
@@ -2,14 +2,58 @@
 // Project: https://github.com/Joris-van-der-Wel/node-pg-large-object#readme
 // Definitions by: Mateusz Krupa <https://github.com/mateuszkrupa>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="node" />
 
-import { WriteStream } from "fs";
+import stream = require("stream");
+import pg = require("pg");
+
+export class LargeObject {
+  static readonly SEEK_SET: number;
+  static readonly SEEK_CUR: number;
+  static readonly SEEK_END: number;
+  constructor(query: any, oid: number, fd: any);
+  close(callback: (error: Error) => void): void;
+  closeAsync(): Promise<any>;
+  read(length: number, callback: (error: Error, data: Buffer) => void): void;
+  readAsync(length: number): Promise<Buffer>;
+  write(buffer: Buffer, callback?: (error: Error) => void): void;
+  writeAsync(buffer: Buffer): Promise<any>;
+  seek(position: number, ref: number, callback?: (error: Error, position: number) => void): void;
+  seekAsync(position: number, ref: number): Promise<number>;
+  tell(callback: (error: Error, position: number) => void): void;
+  tellAsync(): Promise<number>;
+  size(callback: (error: Error, size: number) => void): void;
+  sizeAsync(): Promise<number>;
+  truncate(length: number, callback?: (error: Error) => void): void;
+  truncateAsync(length: number): Promise<any>;
+  getReadableStream(bufferSize?: number): ReadStream;
+  getWritableStream(bufferSize?: number): WriteStream;
+}
+
+export interface LargeObjectManagerSettings {
+  pg?: pg.Client;
+  pgPromise?: object; // module: pg-promise/Task
+}
 
 export class LargeObjectManager {
-  constructor(options: any);
-  openAndReadableStreamAsync(oid: number, bufferSize: number): Promise<[number, NodeJS.ReadableStream]>;
-  createAndWritableStreamAsync(bufferSize: number): Promise<[number, WriteStream]>;
+  static readonly WRITE: number;
+  static readonly READ: number;
+  static readonly READWRITE: number;
+  constructor(options: LargeObjectManagerSettings|object);
+  open(oid: number, mode: number, callback: (error: Error, result: LargeObject) => void): void;
+  openAsync(oid: number, mode: number): Promise<LargeObject>;
+  create(callback: (error: Error, oid: number) => void): void;
+  createAsync(): Promise<number>;
+  openAndReadableStream(oid: number, bufferSize: number, callback: (error: Error, size: number, stream: ReadStream) => void): void;
+  openAndReadableStreamAsync(oid: number, bufferSize?: number): Promise<[number, ReadStream]>;
+  createAndWritableStream(bufferSize?: number, callback?: (error: Error, oid: number, stream: WriteStream) => void): void;
+  createAndWritableStreamAsync(bufferSize?: number): Promise<[number, WriteStream]>;
+  unlink(oid: number, callback?: (error: Error) => void): void;
   unlinkAsync(oid: number): Promise<any>;
 }
+
+export class ReadStream extends stream.Readable {}
+
+export class WriteStream extends stream.Writable {}
diff --git a/types/pg-large-object/pg-large-object-tests.ts b/types/pg-large-object/pg-large-object-tests.ts
index 050fad80f6..42a939572b 100644
--- a/types/pg-large-object/pg-large-object-tests.ts
+++ b/types/pg-large-object/pg-large-object-tests.ts
@@ -1,8 +1,56 @@
-import { LargeObjectManager } from 'pg-large-object';
+import {
+  LargeObject,
+  LargeObjectManager,
+  LargeObjectManagerSettings,
+  ReadStream,
+  WriteStream
+} from "pg-large-object";
+import { Buffer } from "buffer";
+import pg = require("pg");
 
+const buffer = new Buffer("");
 const bufferSize = 16384;
+const length = 16384;
 const oid = 1;
-const lom = new LargeObjectManager({});
+const seekSetConst = LargeObject.SEEK_SET; // $ExpectType number
+const seekCurConst = LargeObject.SEEK_CUR; // $ExpectType number
+const seekEndConst = LargeObject.SEEK_END; // $ExpectType number
+
+const lo = new LargeObject({}, oid, {});
+lo.close((error: Error) => {}); // $ExpectType void
+lo.closeAsync(); // $ExpectType Promise<any>
+lo.read(length, (error: Error, data: Buffer) => {}); // $ExpectType void
+lo.readAsync(length); // $ExpectType Promise<Buffer>
+lo.write(buffer, (error: Error) => {}); // $ExpectType void
+lo.writeAsync(buffer); // $ExpectType Promise<any>
+lo.seek(0, LargeObject.SEEK_CUR, (error: Error, position: number) => {}); // $ExpectType void
+lo.seekAsync(0, LargeObject.SEEK_CUR); // $ExpectType Promise<number>
+lo.tell((error: Error, position: number) => {}); // $ExpectType void
+lo.tellAsync(); // $ExpectType Promise<number>
+lo.size((error: Error, size: number) => {}); // $ExpectType void
+lo.sizeAsync(); //// $ExpectType Promise<number>
+lo.truncate(length, (error: Error) => {}); // $ExpectType void
+lo.truncateAsync(length); // $ExpectType Promise<any>
+lo.getReadableStream(bufferSize); // $ExpectType ReadStream
+lo.getWritableStream(bufferSize); // $ExpectType WriteStream
+
+const writeConst = LargeObjectManager.WRITE; // $ExpectType number
+const readConst = LargeObjectManager.READ; // $ExpectType number
+const readWriteConst = LargeObjectManager.READWRITE; // $ExpectType number
+const config: LargeObjectManagerSettings = {
+  pg: new pg.Client(),
+  pgPromise: {}
+};
+
+const lom = new LargeObjectManager(config);
+lom.open(oid, LargeObjectManager.READWRITE, (error: Error, result: LargeObject) => {}); // $ExpectType void
+lom.openAsync(oid, LargeObjectManager.READWRITE); // $ExpectType Promise<LargeObject>
+lom.create((error: Error, oid: number) => {}); // $ExpectType void
+lom.createAsync(); // $ExpectType Promise<number>
+lom.unlink(oid, (error: Error) => {}); // $ExpectType void
+lom.unlinkAsync(oid); // $ExpectType Promise<any>
+lom.openAndReadableStream(oid, bufferSize, (error: Error, size: number, stream: ReadStream) => {}); // $ExpectType void
+lom.openAndReadableStreamAsync(oid, bufferSize); // $ExpectType Promise<[number, ReadStream]>
+lom.createAndWritableStream(bufferSize, (error: Error, oid: number, stream: WriteStream) => {}); // $ExpectType void
 lom.createAndWritableStreamAsync(bufferSize); // $ExpectType Promise<[number, WriteStream]>
-lom.openAndReadableStreamAsync(oid, bufferSize); // $ExpectType Promise<[number, ReadableStream]>
 lom.unlinkAsync(oid); // $ExpectType Promise<any>