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

package/src/FlinkRepo.ts

@@ -26,12 +26,18 @@ export abstract class FlinkRepo<C extends FlinkContext, Model extends Document>
 
     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);
+        }
+        return null;
     }
 
     async getOne(query = {}) {
         const res = await this.collection.findOne<Model>(query);
-        return this.objectIdToString(res);
+        if (res) {
+            return this.objectIdToString(res);
+        }
+        return null;
     }
 
     async create<C = Omit<Model, "_id">>(model: C): Promise<C & { _id: string }> {
@@ -46,7 +52,10 @@ export abstract class FlinkRepo<C extends FlinkContext, Model extends Document>
 
         const res = await this.collection.findOne<Model>({ _id: oid });
 
-        return this.objectIdToString(res);
+        if (res) {
+            return this.objectIdToString(res);
+        }
+        return null;
     }
 
     async updateMany<U = Partial<Model>>(query: any, model: U): Promise<number> {
@@ -77,7 +86,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(),
+        };
     });
 }

package/cli/generate-schemas.ts

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-import { JSONSchema7, JSONSchema7Definition } from "json-schema";
-import { join } from "path";
-import {
-  createFormatter,
-  createParser,
-  SchemaGenerator,
-} from "ts-json-schema-generator";
-import { Project, SyntaxKind, ts } from "ts-morph";
-import { writeJsonFile } from "../src/FsUtils";
-import { getOption } from "./cli-utils";
-
-module.exports = async function run(args: string[]) {
-  if (args.includes("--help")) {
-    console.log(`
-    Description
-      Generates JSON schemas for types located in schemas directory or if any other directory
-      is specified with option --types-dir. 
-
-      Outputs generated file(s) to dir '.flink' or if any other --out-dir is specified.
-
-    Usage
-      $ flink generate-schemas <dir> --types-dir <types-dir> --out-file <out-file>
-
-      <dir> is project root as directory where tsconfig.son resides.
-       
-    Options            
-      --types-dir   Directory where typescript types are located relative to <dir>, default "./src/schemas"
-      --out-file    Path to file that will contain generated json schemas relative to <dir>, default "./.flink/generated-schemas.json"
-      --help        Displays this message
-      `);
-
-    process.exit(0);
-  }
-
-  let dir = "./";
-  if (args[0] && !args[0].startsWith("--")) {
-    dir = args[0];
-  }
-
-  const verbose = getOption(args, "verbose", false, {
-    isBoolean: true,
-  }) as boolean;
-
-  const typesDir = getOption(args, "types-dir", "./src/schemas") as string;
-
-  const outFile = getOption(
-    args,
-    "out-file",
-    "./.flink/generated-schemas.json"
-  ) as string;
-
-  const project = new Project({
-    tsConfigFilePath: join(dir, "tsconfig.json"),
-    skipAddingFilesFromTsConfig: true,
-    compilerOptions: {
-      noEmit: true,
-    },
-  });
-
-  project.addSourceFilesAtPaths(join(dir, typesDir, "**/*.ts"));
-
-  console.log("Found", project.getSourceFiles().length, "files");
-
-  const schemaDeclarations: ts.Node[] = [];
-
-  const generator = initJsonSchemaGenerator(project);
-
-  const jsonSchemas: JSONSchema7[] = [];
-
-  for (const sf of project.getSourceFiles()) {
-    if (sf.getDefaultExportSymbol()) {
-      console.warn(
-        `WARN: Schema file ${sf.getBaseName()} has default export, but only named exports are picked up by json schemas parser`
-      );
-    }
-
-    const sourceFileInterfaceDeclarations = sf.getChildrenOfKind(
-      SyntaxKind.InterfaceDeclaration
-    );
-
-    const sourceFileEnumDeclarations = sf.getChildrenOfKind(
-      SyntaxKind.EnumDeclaration
-    );
-
-    const sourceFileDeclarations = [
-      ...sourceFileEnumDeclarations,
-      ...sourceFileInterfaceDeclarations,
-    ];
-
-    schemaDeclarations.push(
-      ...sourceFileDeclarations.map((d) => d.compilerNode)
-    );
-
-    verbose &&
-      console.log(
-        "Found",
-        sourceFileDeclarations.length,
-        "schema(s) in file",
-        sf.getBaseName()
-      );
-
-    try {
-      const schema = generator.createSchemaFromNodes(
-        sourceFileInterfaceDeclarations.map((d) => d.compilerNode)
-      );
-      jsonSchemas.push(schema);
-      // console.log("Created schemas");
-    } catch (err) {
-      console.error(
-        "Failed to generate schema in file",
-        sf.getBaseName() + ":",
-        err
-      );
-    }
-  }
-
-  const mergedSchemas = jsonSchemas.reduce(
-    (out, schema) => {
-      if (schema)
-        if (schema.definitions) {
-          out.definitions = { ...out.definitions, ...schema.definitions };
-        }
-      return out;
-    },
-    {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      $ref: "#/definitions/Schemas",
-      definitions: {},
-    }
-  );
-
-  const file = join(dir, outFile);
-
-  await writeJsonFile(file, mergedSchemas, {
-    ensureDir: true,
-  });
-
-  console.log("Wrote file", file);
-};
-
-function initJsonSchemaGenerator(project: Project) {
-  const formatter = createFormatter({});
-  const parser = createParser(project.getProgram().compilerObject, {});
-  const generator = new SchemaGenerator(
-    project.getProgram().compilerObject,
-    parser,
-    formatter,
-    { expose: "export" }
-  );
-
-  return generator;
-}

package/dist/cli/generate-schemas.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};