@flink-app/flink 0.11.4 → 0.11.9

package/dist/src/FlinkApp.d.ts

@@ -100,6 +100,10 @@ export interface FlinkOptions {
      * Options for json body parser
      */
     jsonOptions?: OptionsJson;
+    /**
+     * Optional: content-types that should be parsed as raw body, and passed as a Buffer object instead of json
+     */
+    rawContentTypes?: string | string[];
     scheduling?: {
         /**
          * If true, the scheduler will be enabled.
@@ -164,6 +168,7 @@ export declare class FlinkApp<C extends FlinkContext> {
     private corsOpts;
     private routingConfigured;
     private jsonOptions?;
+    private rawContentTypes?;
     private schedulingOptions?;
     private disableHttpServer;
     private repos;

package/dist/src/FlinkApp.js

@@ -107,6 +107,7 @@ var FlinkApp = /** @class */ (function () {
         this.onDbConnection = opts.onDbConnection;
         this.plugins = opts.plugins || [];
         this.corsOpts = __assign(__assign({}, defaultCorsOptions), opts.cors);
+        this.rawContentTypes = Array.isArray(opts.rawContentTypes) ? opts.rawContentTypes : (typeof opts.rawContentTypes === 'string' ? [opts.rawContentTypes] : undefined);
         this.auth = opts.auth;
         this.jsonOptions = opts.jsonOptions || { limit: "1mb" };
         this.schedulingOptions = opts.scheduling;
@@ -126,23 +127,23 @@ var FlinkApp = /** @class */ (function () {
     FlinkApp.prototype.start = function () {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var startTime, offsetTime, _i, _b, plugin, db;
+            var startTime, offsetTime, _i, _b, type, _c, _d, plugin, db;
             var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         startTime = Date.now();
                         offsetTime = 0;
                         return [4 /*yield*/, this.initDb()];
                     case 1:
-                        _c.sent();
+                        _e.sent();
                         if (this.debug) {
                             offsetTime = Date.now();
                             FlinkLog_1.log.bgColorLog("cyan", "Init db took " + (offsetTime - startTime) + " ms");
                         }
                         return [4 /*yield*/, this.buildContext()];
                     case 2:
-                        _c.sent();
+                        _e.sent();
                         if (this.debug) {
                             FlinkLog_1.log.bgColorLog("cyan", "Build context took " + (Date.now() - offsetTime) + " ms");
                             offsetTime = Date.now();
@@ -156,6 +157,12 @@ var FlinkApp = /** @class */ (function () {
                         if (!this.disableHttpServer) {
                             this.expressApp = express_1.default();
                             this.expressApp.use(cors_1.default(this.corsOpts));
+                            if (this.rawContentTypes) {
+                                for (_i = 0, _b = this.rawContentTypes; _i < _b.length; _i++) {
+                                    type = _b[_i];
+                                    this.expressApp.use(express_1.default.raw({ type: type }));
+                                }
+                            }
                             this.expressApp.use(body_parser_1.default.json(this.jsonOptions));
                             if (this.accessLog.enabled) {
                                 this.expressApp.use(morgan_1.default(this.accessLog.format));
@@ -165,32 +172,32 @@ var FlinkApp = /** @class */ (function () {
                                 next();
                             });
                         }
-                        _i = 0, _b = this.plugins;
-                        _c.label = 3;
+                        _c = 0, _d = this.plugins;
+                        _e.label = 3;
                     case 3:
-                        if (!(_i < _b.length)) return [3 /*break*/, 9];
-                        plugin = _b[_i];
+                        if (!(_c < _d.length)) return [3 /*break*/, 9];
+                        plugin = _d[_c];
                         db = void 0;
                         if (!plugin.db) return [3 /*break*/, 5];
                         return [4 /*yield*/, this.initPluginDb(plugin)];
                     case 4:
-                        db = _c.sent();
-                        _c.label = 5;
+                        db = _e.sent();
+                        _e.label = 5;
                     case 5:
                         if (!plugin.init) return [3 /*break*/, 7];
                         return [4 /*yield*/, plugin.init(this, db)];
                     case 6:
-                        _c.sent();
-                        _c.label = 7;
+                        _e.sent();
+                        _e.label = 7;
                     case 7:
                         FlinkLog_1.log.info("Initialized plugin '" + plugin.id + "'");
-                        _c.label = 8;
+                        _e.label = 8;
                     case 8:
-                        _i++;
+                        _c++;
                         return [3 /*break*/, 3];
                     case 9: return [4 /*yield*/, this.registerAutoRegisterableHandlers()];
                     case 10:
-                        _c.sent();
+                        _e.sent();
                         if (this.debug) {
                             FlinkLog_1.log.bgColorLog("cyan", "Register handlers took " + (Date.now() - offsetTime) + " ms");
                             offsetTime = Date.now();
@@ -198,12 +205,12 @@ var FlinkApp = /** @class */ (function () {
                         if (!this.isSchedulingEnabled) return [3 /*break*/, 12];
                         return [4 /*yield*/, this.registerAutoRegisterableJobs()];
                     case 11:
-                        _c.sent();
+                        _e.sent();
                         if (this.debug) {
                             FlinkLog_1.log.bgColorLog("cyan", "Register jobs took " + (Date.now() - offsetTime) + " ms");
                             offsetTime = Date.now();
                         }
-                        _c.label = 12;
+                        _e.label = 12;
                     case 12:
                         // Register 404 with slight delay to allow all manually added routes to be added
                         // TODO: Is there a better solution to force this handler to always run last?

package/dist/src/FlinkRepo.d.ts

@@ -17,4 +17,5 @@ export declare abstract class FlinkRepo<C extends FlinkContext, Model = any> {
     updateOne<U = Partial<Model>>(id: string, model: U): Promise<Model>;
     updateMany<U = Partial<Model>>(query: any, model: U): Promise<number>;
     deleteById(id: string): Promise<number>;
+    private buildId;
 }

package/dist/src/FlinkRepo.js

@@ -67,7 +67,7 @@ var FlinkRepo = /** @class */ (function () {
     FlinkRepo.prototype.getById = function (id) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.collection.findOne({ _id: new mongodb_1.ObjectID(id) })];
+                return [2 /*return*/, this.collection.findOne({ _id: this.buildId(id) })];
             });
         });
     };
@@ -98,7 +98,7 @@ var FlinkRepo = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        oid = new mongodb_1.ObjectID(id);
+                        oid = this.buildId(id);
                         return [4 /*yield*/, this.collection.updateOne({
                                 _id: oid,
                             }, {
@@ -132,7 +132,7 @@ var FlinkRepo = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.collection.deleteOne({
-                            _id: new mongodb_1.ObjectID(id),
+                            _id: this.buildId(id),
                         })];
                     case 1:
                         deletedCount = (_a.sent()).deletedCount;
@@ -141,6 +141,19 @@ var FlinkRepo = /** @class */ (function () {
             });
         });
     };
+    FlinkRepo.prototype.buildId = function (id) {
+        var oid;
+        if (typeof id === "string") {
+            oid = new mongodb_1.ObjectId(id);
+        }
+        else if (id instanceof mongodb_1.ObjectId) {
+            oid = id;
+        }
+        else {
+            throw new Error("Invalid id type");
+        }
+        return oid;
+    };
     return FlinkRepo;
 }());
 exports.FlinkRepo = FlinkRepo;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flink-app/flink",
-    "version": "0.11.4",
+    "version": "0.11.9",
     "description": "Typescript only framework for creating REST-like APIs on top of Express and mongodb",
     "types": "dist/src/index.d.ts",
     "main": "dist/src/index.js",
@@ -67,5 +67,5 @@
         "rimraf": "^3.0.2",
         "ts-node": "^9.1.1"
     },
-    "gitHead": "5f36b236f3059fbd77cb01b363d60e3061bdf714"
+    "gitHead": "cc04e10ae82ed022031ef8bcfaafa9beb1d6564f"
 }

package/spec/FlinkRepo.spec.ts

@@ -2,61 +2,68 @@ import { FlinkRepo } from "../src/FlinkRepo";
 import mongodb, { Collection, Db } from "mongodb";
 
 interface Model {
-  _id: string;
-  name: string;
+    _id: string;
+    name: string;
 }
 
 class Repo extends FlinkRepo<any, Model> {}
 
 describe("FlinkRepo", () => {
-  if (!process.env.CI) {
-    console.warn("Skipping repo test which requires db if CI flag is not set");
-    return;
-  }
+    if (!process.env.CI) {
+        console.warn("Skipping repo test which requires db if CI flag is not set");
+        return;
+    }
 
-  let db: Db;
-  let collection: Collection;
-  let repo: Repo;
+    let db: Db;
+    let collection: Collection;
+    let repo: Repo;
 
-  beforeAll(async () => {
-    const client = await mongodb.connect(
-      "mongodb://localhost:27017/flink-test-db"
-    );
-    db = client.db();
-    collection = db.collection("test-coll");
+    beforeAll(async () => {
+        const client = await mongodb.connect("mongodb://localhost:27017/flink-test-db");
+        db = client.db();
+        collection = db.collection("test-coll");
 
-    repo = new Repo("test-coll", db);
-  });
+        repo = new Repo("test-coll", db);
+    });
+
+    it("should get document by id", async () => {
+        const { insertedId } = await collection.insertOne({ name: "foo" });
 
-  it("should get document by id", async () => {
-    const { insertedId } = await collection.insertOne({ name: "foo" });
+        const doc = await repo.getById(insertedId + "");
 
-    const doc = await repo.getById(insertedId + "");
+        expect(doc).toBeDefined();
+        expect(doc?.name).toBe("foo");
+    });
 
-    expect(doc).toBeDefined();
-    expect(doc?.name).toBe("foo");
-  });
+    it("should get document by id using ObjectId", async () => {
+        const { insertedId } = await collection.insertOne({ name: "foo" });
 
-  it("should create and delete document", async () => {
-    const createdDoc = await repo.create<{ name: string }>({ name: "bar" });
+        const doc = await repo.getById(insertedId);
 
-    expect(createdDoc).toBeDefined();
-    expect(createdDoc?._id).toBeDefined();
-    expect(createdDoc?.name).toBe("bar");
+        expect(doc).toBeDefined();
+        expect(doc?.name).toBe("foo");
+    });
 
-    const delCount = await repo.deleteById(createdDoc._id);
+    it("should create and delete document", async () => {
+        const createdDoc = await repo.create<{ name: string }>({ name: "bar" });
 
-    expect(delCount).toBe(1);
-  });
+        expect(createdDoc).toBeDefined();
+        expect(createdDoc?._id).toBeDefined();
+        expect(createdDoc?.name).toBe("bar");
 
-  it("should update document", async () => {
-    const createdDoc = await repo.create({ name: "bar" });
+        const delCount = await repo.deleteById(createdDoc._id);
 
-    const updatedDoc = await repo.updateOne(createdDoc._id + "", {
-      name: "foo",
+        expect(delCount).toBe(1);
     });
 
-    expect(updatedDoc).toBeDefined();
-    expect(updatedDoc.name).toBe("foo");
-  });
+    it("should update document", async () => {
+        const createdDoc = await repo.create({ name: "bar" });
+
+        const updatedDoc = await repo.updateOne(createdDoc._id + "", {
+            name: "foo",
+        });
+
+        expect(updatedDoc).toBeDefined();
+        expect(updatedDoc.name).toBe("foo");
+    });
 });

package/src/FlinkApp.ts

@@ -138,6 +138,11 @@ export interface FlinkOptions {
      */
     jsonOptions?: OptionsJson;
 
+    /**
+     * Optional: content-types that should be parsed as raw body, and passed as a Buffer object instead of json
+     */
+    rawContentTypes?: string | string[];
+
     scheduling?: {
         /**
          * If true, the scheduler will be enabled.
@@ -226,6 +231,7 @@ export class FlinkApp<C extends FlinkContext> {
     private corsOpts: FlinkOptions["cors"];
     private routingConfigured = false;
     private jsonOptions?: OptionsJson;
+    private rawContentTypes?: string[];
     private schedulingOptions?: FlinkOptions["scheduling"];
     private disableHttpServer = false;
 
@@ -248,6 +254,7 @@ export class FlinkApp<C extends FlinkContext> {
         this.onDbConnection = opts.onDbConnection;
         this.plugins = opts.plugins || [];
         this.corsOpts = { ...defaultCorsOptions, ...opts.cors };
+        this.rawContentTypes = Array.isArray(opts.rawContentTypes) ? opts.rawContentTypes : (typeof opts.rawContentTypes === 'string' ? [opts.rawContentTypes] : undefined);
         this.auth = opts.auth;
         this.jsonOptions = opts.jsonOptions || { limit: "1mb" };
         this.schedulingOptions = opts.scheduling;
@@ -289,6 +296,13 @@ export class FlinkApp<C extends FlinkContext> {
         if (!this.disableHttpServer) {
             this.expressApp = express();
             this.expressApp.use(cors(this.corsOpts));
+
+            if (this.rawContentTypes) {
+                for (const type of this.rawContentTypes) {
+                    this.expressApp.use(express.raw({ type }));
+                }
+            }
+
             this.expressApp.use(bodyParser.json(this.jsonOptions));
 
             if (this.accessLog.enabled) {

package/src/FlinkRepo.ts

@@ -1,66 +1,80 @@
-import { Collection, Db, ObjectID } from "mongodb";
+import { Collection, Db, ObjectId } from "mongodb";
 import { FlinkContext } from "./FlinkContext";
 
 export abstract class FlinkRepo<C extends FlinkContext, Model = any> {
-  collection: Collection;
-
-  private _ctx?: C;
-
-  set ctx(ctx: FlinkContext) {
-    this._ctx = ctx as C;
-  }
-
-  get ctx() {
-    if (!this._ctx) throw new Error("Missing FlinkContext");
-    return this._ctx;
-  }
-
-  constructor(private collectionName: string, private db: Db) {
-    this.collection = db.collection(this.collectionName);
-  }
-
-  async findAll(query = {}): Promise<Model[]> {
-    return this.collection.find(query).toArray();
-  }
-
-  async getById(id: string): Promise<Model | null> {
-    return this.collection.findOne({ _id: new ObjectID(id) });
-  }
-
-  async getOne(query = {}): Promise<Model | null> {
-    return this.collection.findOne(query);
-  }
-
-  async create<C = Omit<Model, "_id">>(model: C): Promise<C & { _id: string }> {
-    const { ops } = await this.collection.insertOne(model);
-    return ops[0];
-  }
-
-  async updateOne<U = Partial<Model>>(id: string, model: U): Promise<Model> {
-    const oid = new ObjectID(id);
-
-    await this.collection.updateOne(
-      {
-        _id: oid,
-      },
-      {
-        $set: model,
-      }
-    );
-    return this.collection.findOne({ _id: oid });
-  }
-
-  async updateMany<U = Partial<Model>>(query: any, model: U): Promise<number> {
-    const { modifiedCount } = await this.collection.updateMany(query, {
-      $set: model,
-    });
-    return modifiedCount;
-  }
-
-  async deleteById(id: string): Promise<number> {
-    const { deletedCount } = await this.collection.deleteOne({
-      _id: new ObjectID(id),
-    });
-    return deletedCount || 0;
-  }
+    collection: Collection;
+
+    private _ctx?: C;
+
+    set ctx(ctx: FlinkContext) {
+        this._ctx = ctx as C;
+    }
+
+    get ctx() {
+        if (!this._ctx) throw new Error("Missing FlinkContext");
+        return this._ctx;
+    }
+
+    constructor(private collectionName: string, private db: Db) {
+        this.collection = db.collection(this.collectionName);
+    }
+
+    async findAll(query = {}): Promise<Model[]> {
+        return this.collection.find(query).toArray();
+    }
+
+    async getById(id: string): Promise<Model | null> {
+        return this.collection.findOne({ _id: this.buildId(id) });
+    }
+
+    async getOne(query = {}): Promise<Model | null> {
+        return this.collection.findOne(query);
+    }
+
+    async create<C = Omit<Model, "_id">>(model: C): Promise<C & { _id: string }> {
+        const { ops } = await this.collection.insertOne(model);
+        return ops[0];
+    }
+
+    async updateOne<U = Partial<Model>>(id: string, model: U): Promise<Model> {
+        const oid = this.buildId(id);
+
+        await this.collection.updateOne(
+            {
+                _id: oid,
+            },
+            {
+                $set: model,
+            }
+        );
+        return this.collection.findOne({ _id: oid });
+    }
+
+    async updateMany<U = Partial<Model>>(query: any, model: U): Promise<number> {
+        const { modifiedCount } = await this.collection.updateMany(query, {
+            $set: model,
+        });
+        return modifiedCount;
+    }
+
+    async deleteById(id: string): Promise<number> {
+        const { deletedCount } = await this.collection.deleteOne({
+            _id: this.buildId(id),
+        });
+        return deletedCount || 0;
+    }
+
+    private buildId(id: string | ObjectId) {
+        let oid: ObjectId | string;
+
+        if (typeof id === "string") {
+            oid = new ObjectId(id);
+        } else if (id instanceof ObjectId) {
+            oid = id;
+        } else {
+            throw new Error("Invalid id type");
+        }
+
+        return oid;
+    }
 }