Merge pull request #3912 from ColsaCorp/master

Adding AWS S3 Bucket Image Uploader and Microsoft SQL Node Engine

mssql/mssql-tests.ts

@@ -0,0 +1,70 @@
+/// <reference path="../node/node.d.ts" />
+/// <reference path="mssql.d.ts" />
+
+import sql = require('mssql');
+
+var config: sql.config = {
+    user: 'user',
+    password: 'password',
+    server: 'ip',
+    database: 'database',
+    connectionTimeout: 10000,
+    options: {
+        encrypt: true
+    }
+}
+
+var connection: sql.Connection = new sql.Connection(config, function (err: any) {
+    if (err != null) {
+        console.warn("Issue with connecting to SQL Server!");
+    }
+    else {
+        var requestQuery = new sql.Request(connection);
+
+        var getArticlesQuery = "SELECT * FROM TABLE";
+
+        requestQuery.query(getArticlesQuery, function (err, recordSet) {
+            if (err) {
+                console.error('Error happened calling Query: ' + err.name + " " + err.message);
+
+            }
+            // checking to see if the articles returned as at least one.
+            else if (recordSet.length > 0) {
+            }
+        });
+
+        var requestStoredProcedure = new sql.Request(connection);
+        var testId: number = 0;
+        var testString: string = 'test';
+
+        requestStoredProcedure.input('pId', testId);
+        requestStoredProcedure.input('pString', testString);
+        
+
+        requestStoredProcedure.execute('StoredProcedureName', function (err, recordsets, returnValue) {
+            if (err != null) {
+                console.error('Error happened calling Query: ' + err.name + " " + err.message);
+            }
+            else {
+                console.info(returnValue);
+            }
+        });
+
+        var requestStoredProcedureWithOutput = new sql.Request(connection);
+        var testId: number = 0;
+        var testString: string = 'test';
+
+        requestStoredProcedure.input('pId', testId);
+        requestStoredProcedure.input('pString', testString);
+        requestStoredProcedure.output('output', sql.Int);
+
+        requestStoredProcedure.execute('StoredProcedureName', function (err, recordsets, returnValue) {
+            if (err != null) {
+                console.error('Error happened calling Query: ' + err.name + " " + err.message);
+            }
+            else {
+                console.info(requestStoredProcedureWithOutput.parameters.output.value);
+            }
+        });
+    }
+});

mssql/mssql.d.ts

@@ -0,0 +1,96 @@
+// Type definitions for mssql
+// Project: https://www.npmjs.com/package/mssql
+// Definitions by: COLSA Corporation <http://www.colsa.com/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "mssql" {
+
+    export var DateTime: any;
+    export var NVarChar: any;
+    export var Int: any;
+    export var Bit: any;
+    export var VarBinary: any;
+    export var TVP: any;
+
+    export interface options {
+        encrypt: boolean;
+    }
+
+    export interface pool {
+        min: number;
+        max: number;
+        idleTimeoutMillis: number;
+    }
+
+    export interface config {
+        driver?: string;
+        user?: string;
+        password?: string;
+        server: string;
+        port?: number;
+        domain?: string;
+        database: string;
+        connectionTimeout?: number;
+        requestTimeout?: number;
+        stream?: boolean;
+        options?: options;
+        pool?: pool;
+
+    }
+
+    export class Connection {
+
+        public constructor(config: config, callback?: (err?: any) => void);
+
+        public connect(callback?: (err?: any) => void): void;
+
+        public close(): void;
+    }
+
+    class columns {
+        public add(name: string, type: any, options: any): void;
+    }
+
+    class rows {
+        public add(row: any): void;
+    }
+
+    export class Table {
+        public create: boolean;
+        public columns: columns;
+        public rows: rows;
+        public constructor(tableName: string);
+
+    }
+
+    export class Request {
+        public constructor(connection?: Connection);
+        public execute(procedure: string, callback?: (err?: any, recordsets?: any, returnValue?: any) => void): void;
+        public input(name: string, value: any): void;
+        public input(name: string, type: any, value: any): void;
+        public output(name: string, type: any, value?: any): void;
+        public pipe(stream: any): void;
+        public query(command: string, callback?: (err?: any, recordset?: any) => void): void;
+        public batch(batch: string, callback?: (err?: any, recordset?: any) => void): void;
+        public bulk(table: Table, callback?: (err?: any, rowCount?: any) => void): void;
+        public cancel(): void;
+        public parameters: any;
+    }
+
+    export class Transaction {
+        public constructor(connection?: Connection);
+        public begin(isolationLevel?: any, callback?: (err?: any) => void): void;
+        public begin(callback?: (err?: any) => void): void;
+        public commit(callback?: (err?: any) => void): void;
+        public rollback(callback?: (err?: any) => void): void;
+    }
+
+    export class PreparedStatement {
+        public constructor(connection?: Connection);
+        public input(name: string, type: any): void;
+        public output(name: string, type: any): void;
+        public prepare(statement: string, callback?: (err?: any) => void): void;
+        public execute(values: any, callback?: (err?: any) => void): void;
+        public unprepare(callback?: (err?: any) => void): void;
+    }
+}

s3-uploader/s3-uploader-tests.ts

@@ -0,0 +1,44 @@
+/// <reference path="../node/node.d.ts" />
+/// <reference path="s3-uploader.d.ts" />
+
+//NOTE: Does require GM (https://github.com/aheckmann/gm) thus requires GraphicsMagick (http://www.graphicsmagick.org/) or ImageMagick (http://www.imagemagick.org/)
+
+import Upload = require('s3-uploader');
+
+var s3VersionOriginal: S3UploaderVersion = {
+    original: true
+};
+
+var s3VersionHeader: S3UploaderVersion = {
+    suffix: '-header',
+    quality: 100,
+    maxHeight: 300,
+    maxWidth: 600
+}
+
+var s3Config: S3UploaderOptions = {
+    awsAccessKeyId: 'awsKeyId',
+    awsSecretAccessKey: 'awsSecretAccessKey',
+    awsBucketPath: '',
+    awsBucketRegion: 'us-east-1' /*Whatever region s3 is located*/,
+    awsBucketAcl: 'public-read',
+    awsHttpTimeout: 60000,
+    versions: [s3VersionOriginal, s3VersionHeader]
+}
+
+var client = new Upload('bucketName', s3Config);
+
+client.upload('/images/File.png', s3Config, function (err, images, meta) {
+    var returnVal: boolean = false;
+    if (err) {
+        console.log(err);
+    }
+    else {
+        if (images.length >= 2) {
+            var originalImageUrl = images[0].url;
+            var headerImageUrl = images[1].url;
+
+            console.log('Original: ' + originalImageUrl + ' headerImageUrl: ' + headerImageUrl);
+        }
+    }
+});

s3-uploader/s3-uploader.d.ts

@@ -0,0 +1,66 @@
+// Type definitions for s3-uploader
+// Project: https://www.npmjs.com/package/s3-uploader
+// Definitions by: COLSA Corporation <http://www.colsa.com/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+//NOTE: Does require GM (https://github.com/aheckmann/gm) thus requires GraphicsMagick (http://www.graphicsmagick.org/) or ImageMagick (http://www.imagemagick.org/)
+
+declare module "s3-uploader" {
+    export = Upload;
+}
+interface S3UploaderVersion {
+    original?: boolean;
+    suffix?: string;
+    quality?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+
+interface S3UploaderOptions {
+    awsAccessKeyId?: string;
+    awsSecretAccessKey?: string;
+    awsBucketRegion?: string;
+    awsBucketPath?: string;
+    awsBucketAcl?: string;
+    awsMaxRetries?: number;
+    awsHttpTimeout?: number;
+    resizeQuality?: number;
+    returnExif?: boolean;
+    tmpDir?: string;
+    workers?: number;
+    url?: string;
+    versions?: S3UploaderVersion;
+}
+
+declare class Meta {
+    public format: string;
+    public fileSize: string;
+    public imageSize: imageSize;
+    public orientation: string;
+    public colorSpace: string;
+    public compression: string;
+    public quallity: string;
+}
+
+declare class imageSize {
+    public height: number;
+    public width: number;
+}
+
+declare class image {
+    public etag: string;
+    public format: string;
+    public height: number;
+    public original: boolean;
+    public path: string;
+    public size: string;
+    public src: string;
+    public url: string;
+    public width: number;
+}
+
+declare class Upload {
+    public constructor(awsBucketName: string, opts: S3UploaderOptions);
+
+    public upload(src: string, opts?: S3UploaderOptions, cb?: (err: string, images: image[], meta: Meta) => void): void;
+}