BREAKING CHANGE: make optional dict values non-nullable by default (#12)

* add extra option for non-nullable optional keys

* make non-nullable optionals the default behavor

* fix type error

Author: TheLartians

README.md

@@ -45,7 +45,7 @@ from typing_extensions import Any, Dict, List, Literal, NotRequired, Optional, T
 class Foo(TypedDict):
   type: Literal["foo"]
   foo: List[float]
-  optional: NotRequired[Optional[str]]
+  optional: NotRequired[str]
 
 class Ts2PyHelperType1(TypedDict):
   foo: Foo
@@ -89,9 +89,16 @@ TypeScript2Python supports many of TypeScripts type constructs, including:
 - Unions, `string | number`
 - Arrays, `boolean[]`
 - Nested objects `{ bar: { foo: string } }`, that will get transpiled into helper dictionaries
-- Optional properties `{ optional?: number }`, that get transpiled to `NotRequired[Optional[...]]` attributes
+- Optional properties `{ optional?: number }`, that get transpiled to `NotRequired[...]` attributes
 - Docstrings `/** this is very useful */`
 
+## Transpilation options
+
+### Nullable optionals
+
+In TypeScript objects, optional values can also be set to `undefined`. By default we assume the according Python
+type to be non-nullable, but a more closely matching behavior can be achieved using the flag `--nullable-optionals`.  
+
 ## Limitations
 
 We currently do not support the following features:

src/ParserState.ts

@@ -1,14 +1,16 @@
 import ts from "typescript";
+import { Ts2PyConfig } from "./config";
 
 export type ParserState = {
   helperCount: number;
   statements: string[];
   typechecker: ts.TypeChecker;
   knownTypes: Map<ts.Type | string, string>;
   imports: Set<string>;
+  config: Ts2PyConfig;
 };
 
-export const createNewParserState = (typechecker: ts.TypeChecker): ParserState => {
+export const createNewParserState = (typechecker: ts.TypeChecker, config: Ts2PyConfig): ParserState => {
   const knownTypes = new Map<ts.Type, string>();
   knownTypes.set(typechecker.getVoidType(), "None");
   knownTypes.set(typechecker.getUndefinedType(), "None");
@@ -22,5 +24,6 @@ export const createNewParserState = (typechecker: ts.TypeChecker): ParserState =
     typechecker,
     knownTypes,
     imports: new Set(),
+    config,
   };
 }

src/config.ts

@@ -0,0 +1,4 @@
+
+export type Ts2PyConfig = {
+    nullableOptionals?: boolean;
+}

src/index.ts

@@ -4,8 +4,9 @@ import ts from "typescript";
 import path from "path";
 import { program } from "@commander-js/extra-typings";
 import { typeScriptToPython } from "./typeScriptToPython";
+import { Ts2PyConfig } from "./config";
 
-const compile = (fileNames: string[]) => {
+const compile = (fileNames: string[], config: Ts2PyConfig) => {
   const program = ts.createProgram(fileNames, {
     noEmit: true,
     allowJs: true,
@@ -21,16 +22,17 @@ const compile = (fileNames: string[]) => {
         .reduce((a, b) => a || b),
     );
 
-  const transpiled = typeScriptToPython(program.getTypeChecker(), relevantSourceFiles)
+  const transpiled = typeScriptToPython(program.getTypeChecker(), relevantSourceFiles, config)
   console.log(transpiled);
 }
 
 program
   .name("typescript2python")
   .description("A program that converts TypeScript type definitions to Python")
+  .option("--nullable-optionals", "if set, optional entries in dictionaries will be nullable, e.g. `NotRequired[Optional[T]]`")
   .arguments("<input...>")
-  .action(args => {
-    compile(args)
+  .action((args, options) => {
+    compile(args, options)
   })
   .parse(process.argv)
 

src/parseExports.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { ParserState } from "./ParserState";
 import { parseTypeDefinition } from "./parseTypeDefinition";
+import { Ts2PyConfig } from "./config";
 
 export function parseExports(state: ParserState, sourceFile: ts.SourceFile) {
   for (const statement of sourceFile.statements) {

src/parseInlineType.ts

@@ -19,7 +19,7 @@ export const parseInlineType = (state: ParserState, type: ts.Type) => {
  * strings match. 
  **/
 const getCanonicalTypeName = (state: ParserState, type: ts.Type) => {
-  const tmpState = createNewParserState(state.typechecker);
+  const tmpState = createNewParserState(state.typechecker, state.config);
   parseTypeDefinition(tmpState, "TS2PyTmpType", type);
   return tmpState.statements.join("\n")
 }

src/parseProperty.ts

@@ -18,8 +18,12 @@ export const parseProperty = (state: ParserState, symbol: ts.Symbol) => {
 
   if (symbol.flags & ts.SymbolFlags.Optional) {
     state.imports.add("NotRequired");
-    state.imports.add("Optional");
-    return `${name}: NotRequired[Optional[${definition}]]${documentationSuffix}`;
+    if (state.config.nullableOptionals) {
+      state.imports.add("Optional");
+      return `${name}: NotRequired[Optional[${definition}]]${documentationSuffix}`;
+    } else {
+      return `${name}: NotRequired[${definition}]${documentationSuffix}`;
+    }
   } else {
     return `${name}: ${definition}${documentationSuffix}`;
   }

src/testing/dicts.test.ts

@@ -58,4 +58,18 @@ class A(TypedDict):
     );
     expect(result).toContain(`class A(TypedDict):\n  foo: str\n  bar: float`);
   });
+
+  it("transpiles optional values as NotRequired[Optional[T]]", async () => {
+    const result = await transpileString(`export type A = { foo?: string }`);
+    expect(result).toContain(`class A(TypedDict):\n  foo: NotRequired[str]`);
+  });
+
+  it("transpiles optional values with non-null optionals as NotRequired[T]", async () => {
+    const result = await transpileString(`export type A = { foo?: string }`, {
+      nullableOptionals: true,
+    });
+    expect(result).toContain(
+      `class A(TypedDict):\n  foo: NotRequired[Optional[str]]`,
+    );
+  });
 });

src/testing/imports.test.ts

@@ -22,9 +22,11 @@ describe("transpiling referenced types", () => {
       );
     }
 
-    const transpiled = typeScriptToPython(program.getTypeChecker(), [
-      barSource,
-    ]);
+    const transpiled = typeScriptToPython(
+      program.getTypeChecker(),
+      [barSource],
+      {},
+    );
     expect(transpiled).toEqual(
       `from typing_extensions import TypedDict
 

src/testing/utils.ts

@@ -1,11 +1,28 @@
+import { Ts2PyConfig } from "../config";
 import { typeScriptToPython } from "../typeScriptToPython";
 import { createProject, ts } from "@ts-morph/bootstrap";
 
-export const transpileString = async (code: string) => {
-  const project = await createProject();
-  const fileName = "test.ts";
+/**
+ * We create only a single global project to improve performance when sequentially
+ * transpiling multiple files.
+ **/
+let globalProject: ReturnType<typeof createProject> | undefined;
 
-  const sourceFile = project.createSourceFile(fileName, code);
+export const transpileString = async (
+  code: string,
+  config: Ts2PyConfig = {},
+) => {
+  if (globalProject === undefined) {
+    globalProject = createProject({
+      useInMemoryFileSystem: true,
+    });
+  }
+
+  const project = await globalProject;
+  const fileName = `source.ts`;
+
+  // instead of adding a new source file for each program, we update the existing one.
+  const sourceFile = project.updateSourceFile(fileName, code);
   const program = project.createProgram();
   const diagnostics = ts.getPreEmitDiagnostics(program);
 
@@ -17,5 +34,5 @@ export const transpileString = async (code: string) => {
     );
   }
 
-  return typeScriptToPython(program.getTypeChecker(), [sourceFile]);
+  return typeScriptToPython(program.getTypeChecker(), [sourceFile], config);
 };