@flink-app/flink 0.12.1-alpha.0 → 0.12.1-alpha.10

package/src/FlinkApp.ts

@@ -2,9 +2,9 @@ import Ajv, { ValidateFunction } from "ajv";
 import addFormats from "ajv-formats";
 import bodyParser, { OptionsJson } from "body-parser";
 import cors from "cors";
-import express, { Express, Request } from "express";
+import express, { Express, Request, RequestHandler } from "express";
 import { JSONSchema7 } from "json-schema";
-import mongodb, { Db, MongoClient, ServerApiVersion } from "mongodb";
+import { Db, MongoClient, ServerApiVersion } from "mongodb";
 import morgan from "morgan";
 import ms from "ms";
 import { AsyncTask, CronJob, SimpleIntervalJob, ToadScheduler } from "toad-scheduler";
@@ -217,6 +217,7 @@ export class FlinkApp<C extends FlinkContext> {
     public name: string;
     public expressApp?: Express;
     public db?: Db;
+    public dbClient?: MongoClient;
     public handlers: HandlerConfig[] = [];
     public port?: number;
     public started = false;
@@ -227,13 +228,14 @@ export class FlinkApp<C extends FlinkContext> {
     private onDbConnection?: FlinkOptions["onDbConnection"];
 
     private plugins: FlinkPlugin[] = [];
-    private auth?: FlinkAuthPlugin;
+    public auth?: FlinkAuthPlugin;
     private corsOpts: FlinkOptions["cors"];
     private routingConfigured = false;
     private jsonOptions?: OptionsJson;
     private rawContentTypes?: string[];
     private schedulingOptions?: FlinkOptions["scheduling"];
     private disableHttpServer = false;
+    private expressServer: any; // for simplicity, we don't want to import types from express/node here
 
     private repos: { [x: string]: FlinkRepo<C, any> } = {};
 
@@ -303,14 +305,14 @@ export class FlinkApp<C extends FlinkContext> {
 
             if (this.rawContentTypes) {
                 for (const type of this.rawContentTypes) {
-                    this.expressApp.use(express.raw({ type }));
+                    this.expressApp.use(express.raw({ type }) as RequestHandler);
                 }
             }
 
-            this.expressApp.use(bodyParser.json(this.jsonOptions));
+            this.expressApp.use(bodyParser.json(this.jsonOptions) as RequestHandler);
 
             if (this.accessLog.enabled) {
-                this.expressApp.use(morgan(this.accessLog.format));
+                this.expressApp.use(morgan(this.accessLog.format) as RequestHandler);
             }
 
             this.expressApp.use((req, res, next) => {
@@ -367,7 +369,7 @@ export class FlinkApp<C extends FlinkContext> {
             log.info("🚧 HTTP server is disabled, but flink app is running");
             this.started = true;
         } else {
-            this.expressApp?.listen(this.port, () => {
+            this.expressServer = this.expressApp?.listen(this.port, () => {
                 log.fontColorLog("magenta", `⚡️ HTTP server '${this.name}' is running and waiting for connections on ${this.port}`);
                 this.started = true;
             });
@@ -376,6 +378,28 @@ export class FlinkApp<C extends FlinkContext> {
         return this;
     }
 
+    async stop() {
+        log.info("🛑 Stopping Flink app...");
+
+        if (this.scheduler) {
+            await this.scheduler.stop();
+        }
+
+        if (this.expressServer) {
+            return new Promise<void>((resolve, reject) => {
+                const int = setTimeout(() => {
+                    reject("Failed to stop HTTP server in time");
+                }, 2000);
+
+                this.expressServer.close(() => {
+                    clearInterval(int);
+                    log.info("HTTP server stopped");
+                    resolve();
+                });
+            });
+        }
+    }
+
     /**
      * Manually registers a handler.
      *
@@ -717,7 +741,7 @@ export class FlinkApp<C extends FlinkContext> {
     private async buildContext() {
         if (this.dbOpts) {
             for (const { collectionName, repoInstanceName, Repo } of autoRegisteredRepos) {
-                const repoInstance: FlinkRepo<C, any> = new Repo(collectionName, this.db);
+                const repoInstance: FlinkRepo<C, any> = new Repo(collectionName, this.db, this.dbClient);
 
                 this.repos[repoInstanceName] = repoInstance;
 
@@ -755,6 +779,7 @@ export class FlinkApp<C extends FlinkContext> {
                 log.debug("Connecting to db");
                 const client = await MongoClient.connect(this.dbOpts.uri, this.getMongoConnectionOptions());
                 this.db = client.db();
+                this.dbClient = client;
             } catch (err) {
                 log.error("Failed to connect to db: " + err);
                 process.exit(1);

package/src/FlinkRepo.ts

@@ -1,6 +1,12 @@
-import { Collection, Db, Document, InsertOneResult, ObjectId } from "mongodb";
+import { Collection, Db, Document, InsertOneResult, MongoClient, ObjectId } from "mongodb";
 import { FlinkContext } from "./FlinkContext";
 
+/**
+ * Partial model to have intellisense for partial updates but
+ * also allow any other properties to be set such as nested objects etc.
+ */
+type PartialModel<Model> = Partial<Model> & { [x: string]: any };
+
 export abstract class FlinkRepo<C extends FlinkContext, Model extends Document> {
     collection: Collection;
 
@@ -15,23 +21,29 @@ export abstract class FlinkRepo<C extends FlinkContext, Model extends Document>
         return this._ctx;
     }
 
-    constructor(private collectionName: string, private db: Db) {
+    constructor(public collectionName: string, public db: Db, public client?: MongoClient) {
         this.collection = db.collection(this.collectionName);
     }
 
     async findAll(query = {}): Promise<Model[]> {
         const res = await this.collection.find<Model>(query).toArray();
-        return res.map(this.objectIdToString);
+        return res.map(this.objectIdToString) as Model[];
     }
 
     async getById(id: string | ObjectId) {
         const res = await this.collection.findOne<Model>({ _id: this.buildId(id) });
-        return this.objectIdToString(res);
+        if (res) {
+            return this.objectIdToString(res) as Model;
+        }
+        return null;
     }
 
     async getOne(query = {}) {
         const res = await this.collection.findOne<Model>(query);
-        return this.objectIdToString(res);
+        if (res) {
+            return this.objectIdToString(res) as Model;
+        }
+        return null;
     }
 
     async create<C = Omit<Model, "_id">>(model: C): Promise<C & { _id: string }> {
@@ -39,19 +51,26 @@ export abstract class FlinkRepo<C extends FlinkContext, Model extends Document>
         return { ...model, _id: result.insertedId.toString() };
     }
 
-    async updateOne(id: string | ObjectId, model: Partial<Model>): Promise<Model | null> {
+    async updateOne(id: string | ObjectId, model: PartialModel<Model>): Promise<Model | null> {
         const oid = this.buildId(id);
 
-        await this.collection.updateOne({ _id: oid }, { $set: model });
+        const { _id, ...modelWithoutId } = model;
+
+        await this.collection.updateOne({ _id: oid }, { $set: modelWithoutId });
 
         const res = await this.collection.findOne<Model>({ _id: oid });
 
-        return this.objectIdToString(res);
+        if (res) {
+            return this.objectIdToString(res) as Model;
+        }
+        return null;
     }
 
-    async updateMany<U = Partial<Model>>(query: any, model: U): Promise<number> {
+    async updateMany<U = PartialModel<Model>>(query: any, model: U): Promise<number> {
+        const { _id, ...modelWithoutId } = model as any;
+
         const { modifiedCount } = await this.collection.updateMany(query, {
-            $set: model as any,
+            $set: modelWithoutId as any,
         });
         return modifiedCount;
     }
@@ -77,7 +96,7 @@ export abstract class FlinkRepo<C extends FlinkContext, Model extends Document>
         return oid;
     }
 
-    private objectIdToString(doc: any & { _id?: any }) {
+    private objectIdToString<T>(doc: T & { _id?: any }) {
         if (doc && doc._id) {
             doc._id = doc._id.toString();
         }

package/src/TypeScriptCompiler.ts

@@ -2,7 +2,7 @@ import { promises as fsPromises } from "fs";
 import { JSONSchema7 } from "json-schema";
 import { join } from "path";
 import glob from "tiny-glob";
-import { Config, createFormatter, createParser, Schema, SchemaGenerator } from "ts-json-schema-generator";
+import { CompletedConfig, Config, createFormatter, createParser, Schema, SchemaGenerator } from "ts-json-schema-generator";
 import {
     ArrayLiteralExpression,
     DiagnosticCategory,
@@ -437,9 +437,20 @@ import "..${appEntryScript.replace(/\.ts/g, "")}";
     }
 
     private initJsonSchemaGenerator() {
-        const conf: Config = {
+        const conf: CompletedConfig = {
             expose: "none", // Do not create shared $ref definitions.
             topRef: false, // Removes the wrapper object around the schema.
+            additionalProperties: false,
+            jsDoc: "basic",
+            sortProps: false,
+            strictTuples: false,
+            minify: false,
+            markdownDescription: false,
+            skipTypeCheck: false,
+            encodeRefs: false,
+            extraTags: [],
+            functions: "fail",
+            discriminatorType: "json-schema",
         };
         const formatter = createFormatter(conf);
         const parser = createParser(this.project.getProgram().compilerObject, conf);

package/src/TypeScriptUtils.ts

@@ -1,13 +1,4 @@
-import {
-  ImportDeclarationStructure,
-  Node,
-  OptionalKind,
-  SourceFile,
-  Symbol,
-  SyntaxKind,
-  ts,
-  Type,
-} from "ts-morph";
+import { ImportDeclarationStructure, Node, OptionalKind, SourceFile, Symbol, SyntaxKind, ts, Type } from "ts-morph";
 import { getJsDocComment } from "./utils";
 
 /**
@@ -18,85 +9,66 @@ import { getJsDocComment } from "./utils";
  * Declared types of those are returned.
  */
 export function getTypesToImport(node: Node<ts.Node>) {
-  const typeRefIdentifiers = node
-    .getDescendantsOfKind(SyntaxKind.TypeReference)
-    .filter(
-      (typeRefNode) => !!typeRefNode.getFirstChildIfKind(SyntaxKind.Identifier)
-    )
-    .map((typeRefNode) =>
-      typeRefNode.getFirstChildIfKindOrThrow(SyntaxKind.Identifier)
-    );
+    const typeRefIdentifiers = node
+        .getDescendantsOfKind(SyntaxKind.TypeReference)
+        .filter((typeRefNode) => !!typeRefNode.getFirstChildIfKind(SyntaxKind.Identifier))
+        .map((typeRefNode) => typeRefNode.getFirstChildIfKindOrThrow(SyntaxKind.Identifier));
 
-  const typesToImport: Type<ts.Type>[] = [];
+    const typesToImport: Type<ts.Type>[] = [];
 
-  for (const typeRefIdentifier of typeRefIdentifiers) {
-    const typeSymbol = typeRefIdentifier.getSymbolOrThrow();
+    for (const typeRefIdentifier of typeRefIdentifiers) {
+        const typeSymbol = typeRefIdentifier.getSymbolOrThrow();
 
-    const declaredType = typeSymbol.getDeclaredType();
-    const declaration = declaredType.getSymbol()?.getDeclarations()[0];
+        const declaredType = typeSymbol.getDeclaredType();
+        const declaration = declaredType.getSymbol()?.getDeclarations()[0];
 
-    if (!declaration) {
-      continue; // should not happen, right?
-    }
+        if (!declaration) {
+            continue; // should not happen, right?
+        }
 
-    if (declaration.getSourceFile() !== node.getSourceFile()) {
-      typesToImport.push(declaration.getSymbolOrThrow().getDeclaredType());
-    } else {
-      typesToImport.push(...getTypesToImport(declaration));
+        if (declaration.getSourceFile() !== node.getSourceFile()) {
+            typesToImport.push(declaration.getSymbolOrThrow().getDeclaredType());
+        } else {
+            typesToImport.push(...getTypesToImport(declaration));
+        }
     }
-  }
 
-  return typesToImport;
+    return typesToImport;
 }
 
 export function addImport(toSourceFile: SourceFile, symbol: Symbol) {
-  const symbolDeclaration = symbol.getDeclarations()[0];
-
-  if (!symbolDeclaration) {
-    throw new Error(
-      "Missing declaration for symbol " + symbol.getFullyQualifiedName()
-    );
-  }
-
-  const importName = symbol.getEscapedName();
-  const symbolSourceFile = symbolDeclaration.getSourceFile();
+    const symbolDeclaration = symbol.getDeclarations()[0];
 
-  const isDefaultExport = symbol
-    .getDeclaredType()
-    .getText()
-    .endsWith(".default");
+    if (!symbolDeclaration) {
+        throw new Error("Missing declaration for symbol " + symbol.getFullyQualifiedName());
+    }
 
-  const importDec = toSourceFile
-    .getImportDeclarations()
-    .find(
-      (importDeclarataion) =>
-        importDeclarataion.getModuleSpecifierSourceFile() === symbolSourceFile
-    );
+    const importName = symbol.getEscapedName();
+    const symbolSourceFile = symbolDeclaration.getSourceFile();
 
-  if (importDec) {
-    // File already has import to file
-    if (isDefaultExport) {
-      if (!importDec.getDefaultImport()) {
-        importDec.setDefaultImport(importName);
-      }
+    const isDefaultExport = symbol.getDeclaredType().getText().endsWith(".default");
+
+    const importDec = toSourceFile.getImportDeclarations().find((importDeclarataion) => importDeclarataion.getModuleSpecifierSourceFile() === symbolSourceFile);
+
+    if (importDec) {
+        // File already has import to file
+        if (isDefaultExport) {
+            if (!importDec.getDefaultImport()) {
+                importDec.setDefaultImport(importName);
+            }
+        } else {
+            if (!importDec.getNamedImports().find((specifier) => specifier.getText() === importName)) {
+                importDec.addNamedImport(importName);
+            }
+        }
     } else {
-      if (
-        !importDec
-          .getNamedImports()
-          .find((specifier) => specifier.getText() === importName)
-      ) {
-        importDec.addNamedImport(importName);
-      }
+        // Add new import declaration
+        toSourceFile.addImportDeclaration({
+            moduleSpecifier: toSourceFile.getRelativePathAsModuleSpecifierTo(symbolSourceFile),
+            defaultImport: isDefaultExport ? symbol.getEscapedName() : undefined,
+            namedImports: isDefaultExport ? undefined : [symbol.getEscapedName()],
+        });
     }
-  } else {
-    // Add new import declaration
-    toSourceFile.addImportDeclaration({
-      moduleSpecifier:
-        toSourceFile.getRelativePathAsModuleSpecifierTo(symbolSourceFile),
-      defaultImport: isDefaultExport ? symbol.getEscapedName() : undefined,
-      namedImports: isDefaultExport ? undefined : [symbol.getEscapedName()],
-    });
-  }
 }
 
 /**
@@ -106,63 +78,47 @@ export function addImport(toSourceFile: SourceFile, symbol: Symbol) {
  * @param symbols
  */
 export function addImports(toSourceFile: SourceFile, symbols: Symbol[]) {
-  const importsByModuleSpecifier = new Map<
-    string,
-    { defaultImportName?: string; namedImports: string[] }
-  >();
+    const importsByModuleSpecifier = new Map<string, { defaultImportName?: string; namedImports: string[] }>();
 
-  for (const symbol of symbols) {
-    const symbolDeclaration = symbol.getDeclarations()[0];
+    for (const symbol of symbols) {
+        const symbolDeclaration = symbol.getDeclarations()[0];
 
-    if (!symbolDeclaration) {
-      throw new Error(
-        "Missing declaration for symbol " + symbol.getFullyQualifiedName()
-      );
-    }
+        if (!symbolDeclaration) {
+            throw new Error("Missing declaration for symbol " + symbol.getFullyQualifiedName());
+        }
 
-    const importName = symbol.getDeclaredType().isInterface()
-      ? getInterfaceName(symbol)
-      : symbol.getEscapedName();
+        const importName = symbol.getDeclaredType().isInterface() ? getInterfaceName(symbol) : symbol.getEscapedName();
 
-    const symbolSourceFile = symbolDeclaration.getSourceFile();
-    const isDefaultExport = symbol
-      .getDeclaredType()
-      .getText()
-      .endsWith(".default");
+        const symbolSourceFile = symbolDeclaration.getSourceFile();
+        const isDefaultExport = symbol.getDeclaredType().getText().endsWith(".default");
 
-    const moduleSpecifier =
-      toSourceFile.getRelativePathAsModuleSpecifierTo(symbolSourceFile);
+        const moduleSpecifier = toSourceFile.getRelativePathAsModuleSpecifierTo(symbolSourceFile);
 
-    let aImport = importsByModuleSpecifier.get(moduleSpecifier);
+        let aImport = importsByModuleSpecifier.get(moduleSpecifier);
 
-    if (!aImport) {
-      importsByModuleSpecifier.set(moduleSpecifier, {
-        defaultImportName: isDefaultExport ? importName : undefined,
-        namedImports: isDefaultExport ? [] : [importName],
-      });
-    } else {
-      if (isDefaultExport) {
-        aImport.defaultImportName = importName;
-      } else if (!aImport.namedImports.includes(importName)) {
-        aImport.namedImports.push(importName);
-      }
+        if (!aImport) {
+            importsByModuleSpecifier.set(moduleSpecifier, {
+                defaultImportName: isDefaultExport ? importName : undefined,
+                namedImports: isDefaultExport ? [] : [importName],
+            });
+        } else {
+            if (isDefaultExport) {
+                aImport.defaultImportName = importName;
+            } else if (!aImport.namedImports.includes(importName)) {
+                aImport.namedImports.push(importName);
+            }
+        }
     }
-  }
-
-  toSourceFile.addImportDeclarations(
-    Array.from(importsByModuleSpecifier.entries()).map(
-      ([
-        moduleSpecifier,
-        aImport,
-      ]): OptionalKind<ImportDeclarationStructure> => ({
-        moduleSpecifier,
-        defaultImport: aImport.defaultImportName,
-        namedImports: aImport.namedImports.length
-          ? aImport.namedImports
-          : undefined,
-      })
-    )
-  );
+
+    toSourceFile.addImportDeclarations(
+        Array.from(importsByModuleSpecifier.entries()).map(
+            ([moduleSpecifier, aImport]): OptionalKind<ImportDeclarationStructure> => ({
+                moduleSpecifier,
+                defaultImport: aImport.defaultImportName,
+                namedImports: aImport.namedImports.length ? aImport.namedImports : undefined,
+            })
+        )
+    );
 }
 
 /**
@@ -171,21 +127,17 @@ export function addImports(toSourceFile: SourceFile, symbols: Symbol[]) {
  * @returns
  */
 export function getDefaultExport(sf: SourceFile) {
-  const exportAssignment = sf.getFirstDescendantByKind(
-    SyntaxKind.ExportAssignment
-  );
+    const exportAssignment = sf.getFirstDescendantByKind(SyntaxKind.ExportAssignment);
 
-  if (exportAssignment) {
-    const identifier = exportAssignment.getFirstChildByKind(
-      SyntaxKind.Identifier
-    );
+    if (exportAssignment) {
+        const identifier = exportAssignment.getFirstChildByKind(SyntaxKind.Identifier);
 
-    if (identifier) {
-      return identifier.getSymbolOrThrow().getDeclarations()[0];
-    } else {
-      return exportAssignment.getFirstChild();
+        if (identifier) {
+            return identifier.getSymbolOrThrow().getDeclarations()[0];
+        } else {
+            return exportAssignment.getFirstChild();
+        }
     }
-  }
 }
 
 /**
@@ -195,48 +147,42 @@ export function getDefaultExport(sf: SourceFile) {
  * @returns
  */
 export function getInterfaceName(symbol: Symbol) {
-  const declaration = symbol.getDeclarations()[0];
+    const declaration = symbol.getDeclarations()[0];
 
-  if (!declaration) {
-    throw new Error("Missing declaration of interface symbol");
-  }
+    if (!declaration) {
+        throw new Error("Missing declaration of interface symbol");
+    }
 
-  return declaration
-    .getFirstChildByKindOrThrow(SyntaxKind.Identifier)
-    .getText();
+    return declaration.getFirstChildByKindOrThrow(SyntaxKind.Identifier).getText();
 }
 
 export function getSymbolOrAlias(type: Type<ts.Type>) {
-  return type.getAliasSymbol() || type.getSymbol();
+    return type.getAliasSymbol() || type.getSymbol();
 }
 
 export function getTypeMetadata(type: Type<ts.Type>) {
-  if (["void", "any"].includes(type.getText())) {
-    return [];
-  }
+    if (!type || ["void", "any"].includes(type.getText())) {
+        return [];
+    }
 
-  const symbol = getSymbolOrAlias(type);
+    const symbol = getSymbolOrAlias(type);
 
-  if (!symbol) {
-    throw new Error("Could not get type symbol for type: " + type.getText());
-  }
+    if (!symbol) {
+        throw new Error("Could not get type symbol for type: " + type.getText());
+    }
 
-  const [declaration] = symbol.getDeclarations();
+    const [declaration] = symbol.getDeclarations();
 
-  if (!declaration) {
-    throw new Error("Could not get declaration for type: " + type.getText());
-  }
+    if (!declaration) {
+        throw new Error("Could not get declaration for type: " + type.getText());
+    }
 
-  return declaration
-    .getDescendantsOfKind(SyntaxKind.PropertySignature)
-    .map((prop) => {
-      const description = getJsDocComment(
-        prop.getLeadingCommentRanges()[0]?.getText() || ""
-      );
+    return declaration.getDescendantsOfKind(SyntaxKind.PropertySignature).map((prop) => {
+        const description = getJsDocComment(prop.getLeadingCommentRanges()[0]?.getText() || "");
 
-      return {
-        description,
-        name: prop.getName(),
-      };
+        return {
+            description,
+            name: prop.getName(),
+        };
     });
 }